agentic-qe 2.6.0 → 2.6.2

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

@@ -0,0 +1,118 @@
+/**
+ * QE Agent Pool Factory
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Bridges the AgentPool with the existing QE agent creation system.
+ * Provides a factory implementation that creates poolable agents.
+ */
+import { QEAgentType } from '../../types';
+import { BaseAgent } from '../BaseAgent';
+import { AgentFactory, AgentPool } from './AgentPool';
+import { IResettableAgent, AgentPoolConfig, AgentTypePoolConfig } from './types';
+/**
+ * Wrapper that makes BaseAgent poolable
+ */
+export declare class PoolableAgent implements IResettableAgent {
+    private readonly agent;
+    private healthy;
+    constructor(agent: BaseAgent);
+    /**
+     * Get the underlying BaseAgent
+     */
+    getBaseAgent(): BaseAgent;
+    /**
+     * Reset agent state for reuse
+     */
+    reset(): Promise<void>;
+    /**
+     * Check if agent is healthy
+     */
+    isHealthy(): boolean;
+    /**
+     * Get agent ID
+     */
+    getId(): string;
+    /**
+     * Get agent type
+     */
+    getType(): QEAgentType;
+}
+/**
+ * Configuration for the pool factory
+ */
+export interface PoolFactoryConfig {
+    /** Enable learning for agents */
+    enableLearning?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Agent creator function type
+ * This allows the caller to provide their own agent creation logic
+ */
+export type AgentCreator = (type: QEAgentType) => Promise<BaseAgent>;
+/**
+ * Factory for creating poolable QE agents
+ *
+ * Uses a provided creator function to decouple from QEAgentFactory dependencies
+ */
+export declare class QEAgentPoolFactory implements AgentFactory<PoolableAgent> {
+    private readonly creator;
+    private readonly config;
+    constructor(creator: AgentCreator, config?: PoolFactoryConfig);
+    /**
+     * Create a new poolable agent (constructor only, no initialization)
+     */
+    create(type: QEAgentType): Promise<PoolableAgent>;
+    /**
+     * Initialize an agent (heavy async operations)
+     */
+    initialize(agent: PoolableAgent): Promise<void>;
+    /**
+     * Dispose an agent
+     */
+    dispose(agent: PoolableAgent): Promise<void>;
+}
+/**
+ * Default pool configuration optimized for QE workloads
+ */
+export declare const DEFAULT_QE_POOL_CONFIG: Partial<AgentPoolConfig>;
+/**
+ * Type-specific pool configurations
+ */
+export declare const QE_TYPE_CONFIGS: Map<QEAgentType, AgentTypePoolConfig>;
+/**
+ * Create a configured QE agent pool
+ *
+ * @param creator - Function to create agents
+ * @param factoryConfig - Factory configuration
+ * @param poolConfig - Pool configuration
+ *
+ * @example
+ * ```typescript
+ * import { QEAgentFactory } from '../index';
+ *
+ * // Setup factory with your dependencies
+ * const qeFactory = new QEAgentFactory({ eventBus, memoryStore, context });
+ *
+ * // Create pool with custom creator
+ * const pool = await createQEAgentPool(
+ *   (type) => qeFactory.createAgent(type),
+ *   { enableLearning: true },
+ *   { debug: true }
+ * );
+ *
+ * await pool.warmup();
+ *
+ * const { agent, meta } = await pool.acquire(QEAgentType.TEST_GENERATOR);
+ * const baseAgent = agent.getBaseAgent();
+ * // Use baseAgent...
+ * await pool.release(meta.poolId);
+ * ```
+ */
+export declare function createQEAgentPool(creator: AgentCreator, factoryConfig?: PoolFactoryConfig, poolConfig?: Partial<AgentPoolConfig>): Promise<AgentPool<PoolableAgent>>;
+/**
+ * Get the BaseAgent from a pooled agent
+ */
+export declare function unwrapPooledAgent(poolable: PoolableAgent): BaseAgent;
+//# sourceMappingURL=QEAgentPoolFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QEAgentPoolFactory.d.ts","sourceRoot":"","sources":["../../../src/agents/pool/QEAgentPoolFactory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAe,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEjF;;GAEG;AACH,qBAAa,aAAc,YAAW,gBAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,OAAO,CAAQ;gBAEX,KAAK,EAAE,SAAS;IAI5B;;OAEG;IACH,YAAY,IAAI,SAAS;IAIzB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB5B;;OAEG;IACH,SAAS,IAAI,OAAO;IAapB;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,OAAO,IAAI,WAAW;CAGvB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;AAErE;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,YAAY,CAAC,aAAa,CAAC;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,GAAE,iBAAsB;IAKjE;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAKvD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD;;OAEG;IACG,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CASnD;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAAC,eAAe,CAa3D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,GAAG,CAAC,WAAW,EAAE,mBAAmB,CA6DhE,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,YAAY,EACrB,aAAa,GAAE,iBAAsB,EACrC,UAAU,GAAE,OAAO,CAAC,eAAe,CAAM,GACxC,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAenC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAEpE"}

package/dist/agents/pool/QEAgentPoolFactory.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * QE Agent Pool Factory
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Bridges the AgentPool with the existing QE agent creation system.
+ * Provides a factory implementation that creates poolable agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QE_TYPE_CONFIGS = exports.DEFAULT_QE_POOL_CONFIG = exports.QEAgentPoolFactory = exports.PoolableAgent = void 0;
+exports.createQEAgentPool = createQEAgentPool;
+exports.unwrapPooledAgent = unwrapPooledAgent;
+const types_1 = require("../../types");
+const AgentPool_1 = require("./AgentPool");
+/**
+ * Wrapper that makes BaseAgent poolable
+ */
+class PoolableAgent {
+    constructor(agent) {
+        this.healthy = true;
+        this.agent = agent;
+    }
+    /**
+     * Get the underlying BaseAgent
+     */
+    getBaseAgent() {
+        return this.agent;
+    }
+    /**
+     * Reset agent state for reuse
+     */
+    async reset() {
+        try {
+            // Clear current task using type assertion to access protected member
+            this.agent.currentTask = undefined;
+            // Reset performance metrics (keep accumulated stats but clear current)
+            if (this.agent.performanceMetrics) {
+                this.agent.performanceMetrics.lastTaskDuration = 0;
+            }
+            // Clear any pending events
+            this.agent.removeAllListeners();
+            // Re-setup event handlers if available
+            if (typeof this.agent.setupEventHandlers === 'function') {
+                this.agent.setupEventHandlers();
+            }
+            this.healthy = true;
+        }
+        catch (error) {
+            this.healthy = false;
+            throw error;
+        }
+    }
+    /**
+     * Check if agent is healthy
+     */
+    isHealthy() {
+        if (!this.healthy)
+            return false;
+        try {
+            // Check lifecycle status - getStatus() returns an object with .status
+            const statusObj = this.agent.getStatus();
+            const status = statusObj.status;
+            return status !== types_1.AgentStatus.ERROR && status !== types_1.AgentStatus.TERMINATED;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return this.agent.getAgentId().id;
+    }
+    /**
+     * Get agent type
+     */
+    getType() {
+        return this.agent.getAgentId().type;
+    }
+}
+exports.PoolableAgent = PoolableAgent;
+/**
+ * Factory for creating poolable QE agents
+ *
+ * Uses a provided creator function to decouple from QEAgentFactory dependencies
+ */
+class QEAgentPoolFactory {
+    constructor(creator, config = {}) {
+        this.creator = creator;
+        this.config = config;
+    }
+    /**
+     * Create a new poolable agent (constructor only, no initialization)
+     */
+    async create(type) {
+        const agent = await this.creator(type);
+        return new PoolableAgent(agent);
+    }
+    /**
+     * Initialize an agent (heavy async operations)
+     */
+    async initialize(agent) {
+        await agent.getBaseAgent().initialize();
+    }
+    /**
+     * Dispose an agent
+     */
+    async dispose(agent) {
+        try {
+            await agent.getBaseAgent().terminate();
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.warn(`Error disposing agent ${agent.getId()}:`, error);
+            }
+        }
+    }
+}
+exports.QEAgentPoolFactory = QEAgentPoolFactory;
+/**
+ * Default pool configuration optimized for QE workloads
+ */
+exports.DEFAULT_QE_POOL_CONFIG = {
+    debug: false,
+    globalMaxAgents: 50,
+    warmupStrategy: 'lazy',
+    healthCheckIntervalMs: 60000,
+    defaultConfig: {
+        minSize: 1,
+        maxSize: 5,
+        warmupCount: 1,
+        preInitialize: false,
+        idleTtlMs: 300000, // 5 minutes
+        growthIncrement: 1,
+    },
+};
+/**
+ * Type-specific pool configurations
+ */
+exports.QE_TYPE_CONFIGS = new Map([
+    [
+        types_1.QEAgentType.TEST_GENERATOR,
+        {
+            type: types_1.QEAgentType.TEST_GENERATOR,
+            minSize: 2,
+            maxSize: 8,
+            warmupCount: 2,
+            preInitialize: true, // Pre-init for fast response
+            idleTtlMs: 600000, // 10 minutes (high demand)
+            growthIncrement: 2,
+        },
+    ],
+    [
+        types_1.QEAgentType.COVERAGE_ANALYZER,
+        {
+            type: types_1.QEAgentType.COVERAGE_ANALYZER,
+            minSize: 1,
+            maxSize: 4,
+            warmupCount: 1,
+            preInitialize: true,
+            idleTtlMs: 300000,
+            growthIncrement: 1,
+        },
+    ],
+    [
+        types_1.QEAgentType.QUALITY_GATE,
+        {
+            type: types_1.QEAgentType.QUALITY_GATE,
+            minSize: 1,
+            maxSize: 3,
+            warmupCount: 1,
+            preInitialize: true, // Fast response needed for gates
+            idleTtlMs: 180000, // 3 minutes
+            growthIncrement: 1,
+        },
+    ],
+    [
+        types_1.QEAgentType.PERFORMANCE_TESTER,
+        {
+            type: types_1.QEAgentType.PERFORMANCE_TESTER,
+            minSize: 1,
+            maxSize: 4,
+            warmupCount: 0, // Heavy resource, lazy create
+            preInitialize: false,
+            idleTtlMs: 120000, // 2 minutes (resource intensive)
+            growthIncrement: 1,
+        },
+    ],
+    [
+        types_1.QEAgentType.SECURITY_SCANNER,
+        {
+            type: types_1.QEAgentType.SECURITY_SCANNER,
+            minSize: 1,
+            maxSize: 3,
+            warmupCount: 1,
+            preInitialize: false,
+            idleTtlMs: 300000,
+            growthIncrement: 1,
+        },
+    ],
+]);
+/**
+ * Create a configured QE agent pool
+ *
+ * @param creator - Function to create agents
+ * @param factoryConfig - Factory configuration
+ * @param poolConfig - Pool configuration
+ *
+ * @example
+ * ```typescript
+ * import { QEAgentFactory } from '../index';
+ *
+ * // Setup factory with your dependencies
+ * const qeFactory = new QEAgentFactory({ eventBus, memoryStore, context });
+ *
+ * // Create pool with custom creator
+ * const pool = await createQEAgentPool(
+ *   (type) => qeFactory.createAgent(type),
+ *   { enableLearning: true },
+ *   { debug: true }
+ * );
+ *
+ * await pool.warmup();
+ *
+ * const { agent, meta } = await pool.acquire(QEAgentType.TEST_GENERATOR);
+ * const baseAgent = agent.getBaseAgent();
+ * // Use baseAgent...
+ * await pool.release(meta.poolId);
+ * ```
+ */
+async function createQEAgentPool(creator, factoryConfig = {}, poolConfig = {}) {
+    const factory = new QEAgentPoolFactory(creator, factoryConfig);
+    const config = {
+        ...exports.DEFAULT_QE_POOL_CONFIG,
+        ...poolConfig,
+        typeConfigs: new Map([
+            ...exports.QE_TYPE_CONFIGS,
+            ...(poolConfig.typeConfigs || new Map()),
+        ]),
+    };
+    const pool = new AgentPool_1.AgentPool(factory, config);
+    return pool;
+}
+/**
+ * Get the BaseAgent from a pooled agent
+ */
+function unwrapPooledAgent(poolable) {
+    return poolable.getBaseAgent();
+}
+//# sourceMappingURL=QEAgentPoolFactory.js.map

package/dist/agents/pool/QEAgentPoolFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QEAgentPoolFactory.js","sourceRoot":"","sources":["../../../src/agents/pool/QEAgentPoolFactory.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,34 @@
+/**
+ * Agent Pool Module
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Provides pre-allocated agent pooling for fast acquisition.
+ *
+ * @example
+ * ```typescript
+ * import { AgentPool, createQEAgentFactory } from './pool';
+ *
+ * const factory = createQEAgentFactory(memoryStore, config);
+ * const pool = new AgentPool(factory, {
+ *   typeConfigs: new Map([
+ *     ['test-generator', { minSize: 3, maxSize: 10, warmupCount: 3 }],
+ *   ]),
+ * });
+ *
+ * // Warmup during startup
+ * await pool.warmup();
+ *
+ * // Fast acquisition (<6ms target)
+ * const { agent, meta } = await pool.acquire('test-generator');
+ *
+ * // Use agent
+ * await agent.executeTask(task);
+ *
+ * // Return to pool
+ * await pool.release(meta.poolId);
+ * ```
+ */
+export { AgentPool, AgentFactory } from './AgentPool';
+export { AgentPoolConfig, AgentTypePoolConfig, PooledAgentState, PooledAgentMeta, PoolStats, TypePoolStats, AcquireOptions, ReleaseOptions, AcquireResult, PoolEvents, IResettableAgent, ExpansionPolicy, } from './types';
+export { QEAgentPoolFactory, createQEAgentPool, unwrapPooledAgent, PoolableAgent, PoolFactoryConfig, AgentCreator, } from './QEAgentPoolFactory';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/pool/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,EAEL,eAAe,EACf,mBAAmB,EAGnB,gBAAgB,EAChB,eAAe,EAGf,SAAS,EACT,aAAa,EAGb,cAAc,EACd,cAAc,EACd,aAAa,EAGb,UAAU,EAGV,gBAAgB,EAChB,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,sBAAsB,CAAC"}

package/dist/agents/pool/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Agent Pool Module
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Provides pre-allocated agent pooling for fast acquisition.
+ *
+ * @example
+ * ```typescript
+ * import { AgentPool, createQEAgentFactory } from './pool';
+ *
+ * const factory = createQEAgentFactory(memoryStore, config);
+ * const pool = new AgentPool(factory, {
+ *   typeConfigs: new Map([
+ *     ['test-generator', { minSize: 3, maxSize: 10, warmupCount: 3 }],
+ *   ]),
+ * });
+ *
+ * // Warmup during startup
+ * await pool.warmup();
+ *
+ * // Fast acquisition (<6ms target)
+ * const { agent, meta } = await pool.acquire('test-generator');
+ *
+ * // Use agent
+ * await agent.executeTask(task);
+ *
+ * // Return to pool
+ * await pool.release(meta.poolId);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolableAgent = exports.unwrapPooledAgent = exports.createQEAgentPool = exports.QEAgentPoolFactory = exports.PooledAgentState = exports.AgentPool = void 0;
+var AgentPool_1 = require("./AgentPool");
+Object.defineProperty(exports, "AgentPool", { enumerable: true, get: function () { return AgentPool_1.AgentPool; } });
+var types_1 = require("./types");
+// State and metadata
+Object.defineProperty(exports, "PooledAgentState", { enumerable: true, get: function () { return types_1.PooledAgentState; } });
+var QEAgentPoolFactory_1 = require("./QEAgentPoolFactory");
+Object.defineProperty(exports, "QEAgentPoolFactory", { enumerable: true, get: function () { return QEAgentPoolFactory_1.QEAgentPoolFactory; } });
+Object.defineProperty(exports, "createQEAgentPool", { enumerable: true, get: function () { return QEAgentPoolFactory_1.createQEAgentPool; } });
+Object.defineProperty(exports, "unwrapPooledAgent", { enumerable: true, get: function () { return QEAgentPoolFactory_1.unwrapPooledAgent; } });
+Object.defineProperty(exports, "PoolableAgent", { enumerable: true, get: function () { return QEAgentPoolFactory_1.PoolableAgent; } });
+//# sourceMappingURL=index.js.map

package/dist/agents/pool/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/agents/pool/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;;;AAEH,yCAAsD;AAA7C,sGAAA,SAAS,OAAA;AAElB,iCAwBiB;AAnBf,qBAAqB;AACrB,yGAAA,gBAAgB,OAAA;AAoBlB,2DAO8B;AAN5B,wHAAA,kBAAkB,OAAA;AAClB,uHAAA,iBAAiB,OAAA;AACjB,uHAAA,iBAAiB,OAAA;AACjB,mHAAA,aAAa,OAAA"}

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

@@ -0,0 +1,227 @@
+/**
+ * Agent Pool Types
+ * Phase 3 D1: Memory Pooling for 16x Agent Spawn Speedup
+ *
+ * Target: Reduce spawn time from ~50-100ms to ~3-6ms
+ */
+import { QEAgentType } from '../../types';
+/**
+ * Pool configuration for a specific agent type
+ */
+export interface AgentTypePoolConfig {
+    /** Agent type identifier */
+    type: QEAgentType;
+    /** Minimum number of agents to keep warm in pool */
+    minSize: number;
+    /** Maximum pool size (prevents memory bloat) */
+    maxSize: number;
+    /** Number of agents to pre-warm during startup */
+    warmupCount: number;
+    /** Whether to pre-initialize agents (run initialize() during warmup) */
+    preInitialize: boolean;
+    /** Time-to-live for idle agents in ms (0 = no expiration) */
+    idleTtlMs: number;
+    /** Growth increment when pool is exhausted */
+    growthIncrement: number;
+}
+/**
+ * Overall pool configuration
+ */
+export interface AgentPoolConfig {
+    /** Per-type pool configurations */
+    typeConfigs: Map<QEAgentType, AgentTypePoolConfig>;
+    /** Default config for types without specific configuration */
+    defaultConfig: Omit<AgentTypePoolConfig, 'type'>;
+    /** Enable debug logging */
+    debug: boolean;
+    /** Maximum total agents across all pools */
+    globalMaxAgents: number;
+    /** Warmup strategy: 'eager' (all at once) or 'lazy' (on first request) */
+    warmupStrategy: 'eager' | 'lazy';
+    /** Health check interval in ms (0 = disabled) */
+    healthCheckIntervalMs: number;
+}
+/**
+ * State of a pooled agent
+ */
+export declare enum PooledAgentState {
+    /** Agent is available for acquisition */
+    AVAILABLE = "available",
+    /** Agent is currently in use */
+    IN_USE = "in_use",
+    /** Agent is being initialized */
+    INITIALIZING = "initializing",
+    /** Agent is being reset for reuse */
+    RESETTING = "resetting",
+    /** Agent has an error and needs recovery */
+    ERROR = "error",
+    /** Agent is marked for removal */
+    DISPOSING = "disposing"
+}
+/**
+ * Metadata for a pooled agent
+ */
+export interface PooledAgentMeta {
+    /** Unique pool-assigned ID */
+    poolId: string;
+    /** Agent type */
+    type: QEAgentType;
+    /** Current state in pool */
+    state: PooledAgentState;
+    /** When the agent was created */
+    createdAt: number;
+    /** When the agent was last acquired */
+    lastAcquiredAt: number | null;
+    /** When the agent was last released */
+    lastReleasedAt: number | null;
+    /** Number of times this agent has been reused */
+    reuseCount: number;
+    /** Total time spent in use (ms) */
+    totalUseTimeMs: number;
+    /** Whether agent has been initialized */
+    isInitialized: boolean;
+    /** Last error if any */
+    lastError: Error | null;
+}
+/**
+ * Pool statistics for monitoring
+ */
+export interface PoolStats {
+    /** Total agents across all types */
+    totalAgents: number;
+    /** Available agents ready for use */
+    availableAgents: number;
+    /** Agents currently in use */
+    inUseAgents: number;
+    /** Agents being initialized */
+    initializingAgents: number;
+    /** Per-type breakdown */
+    byType: Map<QEAgentType, TypePoolStats>;
+    /** Average acquisition time (ms) */
+    avgAcquisitionTimeMs: number;
+    /** Cache hit rate (acquisitions from pool vs new creates) */
+    hitRate: number;
+    /** Total acquisitions since startup */
+    totalAcquisitions: number;
+    /** Total pool misses (had to create new) */
+    totalMisses: number;
+}
+/**
+ * Per-type pool statistics
+ */
+export interface TypePoolStats {
+    type: QEAgentType;
+    total: number;
+    available: number;
+    inUse: number;
+    minSize: number;
+    maxSize: number;
+    avgReuseCount: number;
+}
+/**
+ * Options for acquiring an agent from the pool
+ */
+export interface AcquireOptions {
+    /** Timeout for acquisition in ms (default: 5000) */
+    timeoutMs?: number;
+    /** Whether to wait for an agent if none available (default: true) */
+    waitIfUnavailable?: boolean;
+    /** Priority level for acquisition (higher = first in queue) */
+    priority?: number;
+    /** Custom capabilities required (filters available agents) */
+    requiredCapabilities?: string[];
+}
+/**
+ * Options for releasing an agent back to the pool
+ */
+export interface ReleaseOptions {
+    /** Whether to reset agent state (default: true) */
+    reset?: boolean;
+    /** Mark agent as having an error (will be recovered or disposed) */
+    hasError?: boolean;
+    /** Force disposal instead of returning to pool */
+    dispose?: boolean;
+}
+/**
+ * Pool expansion policy
+ */
+export type ExpansionPolicy = 'none' | 'linear' | 'exponential' | 'adaptive';
+/**
+ * Result of an acquire operation
+ */
+export interface AcquireResult<T> {
+    /** The acquired agent */
+    agent: T;
+    /** Pool metadata for this agent */
+    meta: PooledAgentMeta;
+    /** Whether this was a cache hit (from pool) or miss (newly created) */
+    fromPool: boolean;
+    /** Time taken to acquire in ms */
+    acquisitionTimeMs: number;
+}
+/**
+ * Events emitted by the pool
+ */
+export interface PoolEvents {
+    'agent:acquired': {
+        poolId: string;
+        type: QEAgentType;
+        fromPool: boolean;
+    };
+    'agent:released': {
+        poolId: string;
+        type: QEAgentType;
+    };
+    'agent:created': {
+        poolId: string;
+        type: QEAgentType;
+    };
+    'agent:disposed': {
+        poolId: string;
+        type: QEAgentType;
+        reason: string;
+    };
+    'agent:error': {
+        poolId: string;
+        type: QEAgentType;
+        error: Error;
+    };
+    'pool:exhausted': {
+        type: QEAgentType;
+        waitingCount: number;
+    };
+    'pool:expanded': {
+        type: QEAgentType;
+        newSize: number;
+    };
+    'pool:warmed': {
+        type: QEAgentType;
+        count: number;
+    };
+    'pool:healthCheck': {
+        stats: PoolStats;
+    };
+}
+/**
+ * Interface for resettable agents (agents that can be reused)
+ */
+export interface IResettableAgent {
+    /**
+     * Reset agent state for reuse
+     * Called when agent is returned to pool
+     */
+    reset(): Promise<void>;
+    /**
+     * Check if agent is healthy and can be reused
+     */
+    isHealthy(): boolean;
+    /**
+     * Get agent's unique identifier
+     */
+    getId(): string;
+    /**
+     * Get agent type
+     */
+    getType(): QEAgentType;
+}
+//# sourceMappingURL=types.d.ts.map