agentic-qe 2.8.0 → 2.8.2

package/dist/agents/BaseAgent.js

@@ -31,6 +31,13 @@ Object.defineProperty(exports, "isSwarmMemoryManager", { enumerable: true, get:
 Object.defineProperty(exports, "validateLearningConfig", { enumerable: true, get: function () { return utils_1.validateLearningConfig; } });
 // Code Intelligence Context (Wave 6 - Knowledge Graph Integration)
 const KnowledgeGraphContextBuilder_js_1 = require("./context/KnowledgeGraphContextBuilder.js");
+const NervousSystemEnhancement_js_1 = require("../nervous-system/integration/NervousSystemEnhancement.js");
+// Nervous System Persistence (Wave 7.1 - State Persistence)
+const NervousSystemPersistenceManager_js_1 = require("../nervous-system/persistence/NervousSystemPersistenceManager.js");
+const NetworkPolicyManager_js_1 = require("../infrastructure/network/NetworkPolicyManager.js");
+const default_policies_js_1 = require("../infrastructure/network/policies/default-policies.js");
+const SandboxManager_js_1 = require("../infrastructure/sandbox/SandboxManager.js");
+const agent_profiles_js_1 = require("../infrastructure/sandbox/profiles/agent-profiles.js");
 class BaseAgent extends events_1.EventEmitter {
     constructor(config) {
         super();
@@ -38,6 +45,11 @@ class BaseAgent extends events_1.EventEmitter {
         this.performanceMetrics = { tasksCompleted: 0, averageExecutionTime: 0, errorCount: 0, lastActivity: new Date() };
         this.federatedInitialized = false;
         this.patternStoreInitialized = false;
+        this.nervousSystemEnhanced = false;
+        this.networkPolicyInitialized = false;
+        this.networkPolicyOwned = false; // true if we created the manager (not shared)
+        this.sandboxInitialized = false;
+        this.sandboxOwned = false; // true if we created the manager (not shared)
         this.agentId = { id: config.id || (0, utils_1.generateAgentId)(config.type), type: config.type, created: new Date() };
         this.capabilities = new Map((config.capabilities || []).map(cap => [cap.name, cap]));
         this.context = config.context;
@@ -65,6 +77,14 @@ class BaseAgent extends events_1.EventEmitter {
         };
         // Code Intelligence configuration (Wave 6 - Knowledge Graph Integration)
         this.codeIntelligenceConfig = config.codeIntelligence;
+        // Nervous System configuration (Wave 7 - Bio-Inspired Intelligence)
+        this.nervousSystemConfig = config.nervousSystem;
+        // Network Policy configuration (SP-3 - Issue #146)
+        // Default enabled for security, opt-out available
+        this.networkPolicyConfig = config.networkPolicy ?? { enabled: true };
+        // Sandbox configuration (SP-1 - Issue #146)
+        // Default disabled (opt-in) - requires Docker infrastructure
+        this.sandboxConfig = config.sandbox ?? { enabled: false };
         // Early validation (Issue #137)
         const validation = (0, utils_1.validateLearningConfig)(config);
         if (!validation.valid && validation.warning) {
@@ -133,6 +153,12 @@ class BaseAgent extends events_1.EventEmitter {
                     await this.initializePatternStore();
                     // Initialize Code Intelligence Context Builder (Wave 6)
                     await this.initializeCodeIntelligence();
+                    // Initialize Nervous System (Wave 7 - Bio-Inspired Intelligence)
+                    await this.initializeNervousSystem();
+                    // Initialize Network Policy (SP-3 - Issue #146)
+                    await this.initializeNetworkPolicy();
+                    // Initialize Sandbox (SP-1 - Issue #146)
+                    await this.initializeSandbox();
                     await this.initializeComponents();
                     await this.executeHook('post-initialization');
                     this.coordinator.emitEvent('agent.initialized', { agentId: this.agentId });
@@ -189,6 +215,9 @@ class BaseAgent extends events_1.EventEmitter {
                     await this.cleanupLLM(); // Phase 0: Cleanup LLM resources
                     await this.cleanupFederated(); // Phase 0 M0.5: Cleanup federated learning
                     await this.cleanupPatternStore(); // Phase 0.5: Cleanup pattern store
+                    await this.cleanupNervousSystem(); // Wave 7: Cleanup nervous system
+                    await this.cleanupNetworkPolicy(); // SP-3: Cleanup network policy
+                    await this.cleanupSandbox(); // SP-1: Cleanup sandbox container
                     this.coordinator.clearAllHandlers();
                 },
                 onPostTermination: async () => {
@@ -1424,6 +1453,634 @@ class BaseAgent extends events_1.EventEmitter {
             this.federatedManager = undefined;
         }
     }
+    // ============================================
+    // Nervous System Methods (Wave 7 - Bio-Inspired Intelligence)
+    // ============================================
+    /**
+     * Initialize Nervous System for bio-inspired intelligence
+     *
+     * Enables:
+     * - HDC-accelerated pattern storage (50ns binding operations)
+     * - BTSP one-shot learning from failures (vs 10+ examples with RL)
+     * - Global Workspace attention coordination (Miller's Law: 7±2 items)
+     * - Circadian duty cycling (5-50x compute savings)
+     */
+    async initializeNervousSystem() {
+        if (!this.nervousSystemConfig) {
+            return;
+        }
+        // Skip if no features are enabled
+        const hasEnabledFeature = this.nervousSystemConfig.enableHdcPatterns ||
+            this.nervousSystemConfig.enableOneShotLearning ||
+            this.nervousSystemConfig.enableWorkspaceCoordination ||
+            this.nervousSystemConfig.enableCircadianCycling;
+        if (!hasEnabledFeature) {
+            return;
+        }
+        try {
+            // Enhance this agent with nervous system capabilities
+            const enhanced = await (0, NervousSystemEnhancement_js_1.enhanceWithNervousSystem)(this, this.nervousSystemConfig);
+            // Store the methods for access
+            this.nervousSystemMethods = enhanced;
+            this.nervousSystemEnhanced = true;
+            this.logger.info(`[${this.agentId.id}] Nervous System initialized with: ` +
+                `HDC=${!!this.nervousSystemConfig.enableHdcPatterns}, ` +
+                `BTSP=${!!this.nervousSystemConfig.enableOneShotLearning}, ` +
+                `Workspace=${!!this.nervousSystemConfig.enableWorkspaceCoordination}, ` +
+                `Circadian=${!!this.nervousSystemConfig.enableCircadianCycling}`);
+            // Wave 7.1: Initialize persistence and restore prior state
+            try {
+                this.nervousSystemPersistence = await (0, NervousSystemPersistenceManager_js_1.getSharedPersistenceManager)();
+                await (0, NervousSystemEnhancement_js_1.restoreNervousSystemState)(this, this.nervousSystemPersistence);
+                this.logger.debug(`[${this.agentId.id}] Nervous System state restored from persistence`);
+            }
+            catch (persistError) {
+                this.logger.debug(`[${this.agentId.id}] No prior nervous system state to restore:`, persistError.message);
+                // Not an error - agent starts with fresh state
+            }
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Nervous System initialization failed:`, error.message);
+            // Don't throw - agent can work without nervous system (graceful degradation)
+        }
+    }
+    /**
+     * Check if nervous system is enabled
+     */
+    hasNervousSystem() {
+        return this.nervousSystemEnhanced && this.nervousSystemMethods !== undefined;
+    }
+    /**
+     * Get nervous system statistics
+     *
+     * Returns comprehensive stats for HDC patterns, BTSP learning,
+     * workspace coordination, and circadian cycling.
+     */
+    getNervousSystemStats() {
+        if (!this.nervousSystemMethods) {
+            return null;
+        }
+        return this.nervousSystemMethods.getNervousSystemStats();
+    }
+    // === HDC Pattern Methods ===
+    /**
+     * Store a pattern using HDC acceleration (50ns binding)
+     *
+     * Uses Hyperdimensional Computing for sub-microsecond pattern binding,
+     * enabling 1000x faster pattern storage than traditional methods.
+     *
+     * @param pattern - The test pattern to store
+     */
+    async storePatternHdc(pattern) {
+        if (!this.nervousSystemMethods?.storePatternHdc) {
+            throw new Error(`[${this.agentId.id}] HDC Pattern Store not available - enable nervousSystem.enableHdcPatterns`);
+        }
+        await this.nervousSystemMethods.storePatternHdc(pattern);
+    }
+    /**
+     * Search patterns using HDC acceleration
+     *
+     * Uses hypervector similarity for pre-filtering, then HNSW for precision.
+     * Achieves O(1) candidate selection vs O(log n) for pure HNSW.
+     *
+     * @param embedding - Query embedding vector
+     * @param k - Number of results to return
+     * @returns Array of matching patterns with similarity scores
+     */
+    async searchPatternsHdc(embedding, k = 10) {
+        if (!this.nervousSystemMethods?.searchPatternsHdc) {
+            return [];
+        }
+        return this.nervousSystemMethods.searchPatternsHdc(embedding, k);
+    }
+    // === BTSP One-Shot Learning Methods ===
+    /**
+     * Learn from a single task failure using BTSP (Behavioral Timescale Synaptic Plasticity)
+     *
+     * Unlike traditional RL which requires 10+ examples, BTSP enables one-shot learning
+     * from a single failure, dramatically reducing time-to-learning.
+     *
+     * @param failure - Information about the task failure
+     */
+    async learnOneShot(failure) {
+        if (!this.nervousSystemMethods?.learnOneShot) {
+            throw new Error(`[${this.agentId.id}] BTSP Learning not available - enable nervousSystem.enableOneShotLearning`);
+        }
+        await this.nervousSystemMethods.learnOneShot(failure);
+    }
+    /**
+     * Recall a strategy based on task state using BTSP associative memory
+     *
+     * Uses one-shot learned patterns for instant strategy recall with
+     * high confidence (vs gradual Q-value learning).
+     *
+     * @param state - Current task state
+     * @returns Strategy recommendation or null if no match
+     */
+    async recallStrategy(state) {
+        if (!this.nervousSystemMethods?.recallStrategy) {
+            return null;
+        }
+        return this.nervousSystemMethods.recallStrategy(state);
+    }
+    // === Workspace Coordination Methods ===
+    /**
+     * Broadcast an item to the Global Workspace for attention competition
+     *
+     * Uses biological Global Workspace Theory where only 7±2 items can
+     * occupy conscious attention at once, enabling focused coordination.
+     *
+     * @param item - The workspace item to broadcast
+     * @returns Whether broadcast succeeded
+     */
+    async broadcastToWorkspace(item) {
+        if (!this.nervousSystemMethods?.broadcastToWorkspace) {
+            return false;
+        }
+        return this.nervousSystemMethods.broadcastToWorkspace(item);
+    }
+    /**
+     * Get items currently in the workspace relevant to this agent
+     *
+     * @returns Array of workspace items
+     */
+    async getWorkspaceItems() {
+        if (!this.nervousSystemMethods?.getWorkspaceItems) {
+            return [];
+        }
+        return this.nervousSystemMethods.getWorkspaceItems();
+    }
+    /**
+     * Check if this agent currently has attention in the Global Workspace
+     *
+     * Agents with attention should proceed with full execution.
+     * Agents without attention should defer or reduce activity.
+     *
+     * @returns Whether this agent has attention
+     */
+    async hasAttention() {
+        if (!this.nervousSystemMethods?.hasAttention) {
+            return true; // Default to true if workspace not enabled
+        }
+        return this.nervousSystemMethods.hasAttention();
+    }
+    // === Circadian Cycling Methods ===
+    /**
+     * Get current circadian phase (Active, Dawn, Dusk, Rest)
+     *
+     * Agents should adjust behavior based on phase:
+     * - Active: Full compute operations
+     * - Dawn/Dusk: Transition states
+     * - Rest: Minimal activity for 5-50x compute savings
+     */
+    getCurrentPhase() {
+        if (!this.nervousSystemMethods?.getCurrentPhase) {
+            return 'Active'; // Default to active if circadian not enabled
+        }
+        return this.nervousSystemMethods.getCurrentPhase();
+    }
+    /**
+     * Check if agent should be active based on circadian phase and criticality
+     *
+     * Critical agents stay active even during rest phase.
+     * Non-critical agents can sleep for compute savings.
+     *
+     * @returns Whether agent should be active
+     */
+    shouldBeActive() {
+        if (!this.nervousSystemMethods?.shouldBeActive) {
+            return true; // Default to active if circadian not enabled
+        }
+        return this.nervousSystemMethods.shouldBeActive();
+    }
+    /**
+     * Get energy savings report from circadian cycling
+     *
+     * Shows saved compute cycles, total rest time, and cost reduction factor.
+     */
+    getEnergySavings() {
+        if (!this.nervousSystemMethods?.getEnergySavings) {
+            return {
+                savedCycles: 0,
+                savingsPercentage: 0,
+                totalRestTime: 0,
+                totalActiveTime: 0,
+                averageDutyFactor: 1,
+                costReductionFactor: 1,
+            };
+        }
+        return this.nervousSystemMethods.getEnergySavings();
+    }
+    /**
+     * Cleanup nervous system resources on agent termination
+     */
+    async cleanupNervousSystem() {
+        if (!this.nervousSystemEnhanced) {
+            return;
+        }
+        try {
+            // Wave 7.1: Save nervous system state before cleanup
+            if (this.nervousSystemPersistence) {
+                try {
+                    await (0, NervousSystemEnhancement_js_1.saveNervousSystemState)(this, this.nervousSystemPersistence);
+                    this.logger.info(`[${this.agentId.id}] Nervous System state saved to persistence`);
+                }
+                catch (saveError) {
+                    this.logger.warn(`[${this.agentId.id}] Failed to save nervous system state:`, saveError.message);
+                }
+            }
+            // The enhancement uses WeakMap, so cleanup happens automatically
+            // when agent reference is garbage collected. We just need to clear our flags.
+            this.nervousSystemMethods = undefined;
+            this.nervousSystemEnhanced = false;
+            this.nervousSystemPersistence = undefined;
+            this.logger.info(`[${this.agentId.id}] Nervous System cleanup complete`);
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Nervous System cleanup error:`, error.message);
+        }
+    }
+    // ============================================
+    // Network Policy Methods (SP-3 - Issue #146)
+    // ============================================
+    /**
+     * Initialize Network Policy Manager for domain whitelisting and rate limiting
+     * Provides security hardening for agent network access
+     */
+    async initializeNetworkPolicy() {
+        if (this.networkPolicyConfig.enabled === false) {
+            this.logger.info(`[${this.agentId.id}] Network Policy disabled by configuration`);
+            return;
+        }
+        try {
+            // Use shared manager if provided, otherwise create a new one
+            if (this.networkPolicyConfig.sharedManager) {
+                this.networkPolicyManager = this.networkPolicyConfig.sharedManager;
+                this.networkPolicyOwned = false;
+            }
+            else {
+                this.networkPolicyManager = (0, NetworkPolicyManager_js_1.createNetworkPolicyManager)({
+                    enableAuditLogging: this.networkPolicyConfig.enableAuditLogging ?? true,
+                    debug: this.networkPolicyConfig.debug ?? false,
+                });
+                await this.networkPolicyManager.initialize();
+                this.networkPolicyOwned = true;
+            }
+            // Apply any policy overrides for this agent type
+            if (this.networkPolicyConfig.policyOverrides) {
+                this.networkPolicyManager.updatePolicy(this.agentId.type, this.networkPolicyConfig.policyOverrides);
+            }
+            this.networkPolicyInitialized = true;
+            this.logger.info(`[${this.agentId.id}] Network Policy initialized (owned: ${this.networkPolicyOwned})`);
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Network Policy initialization failed:`, error.message);
+            // Don't throw - agent can work without network policy (graceful degradation)
+        }
+    }
+    /**
+     * Check if network policy enforcement is available
+     */
+    hasNetworkPolicy() {
+        return this.networkPolicyInitialized && this.networkPolicyManager !== undefined;
+    }
+    /**
+     * Get the network policy for this agent type
+     */
+    getNetworkPolicy() {
+        if (!this.networkPolicyManager) {
+            return (0, default_policies_js_1.getNetworkPolicy)(this.agentId.type);
+        }
+        return this.networkPolicyManager.getPolicy(this.agentId.type);
+    }
+    /**
+     * Check if a network request to a domain is allowed
+     * Does NOT consume rate limit tokens - use for pre-flight checks
+     *
+     * @param domain - The target domain (e.g., "api.anthropic.com")
+     * @returns PolicyCheckResult with allowed status and details
+     */
+    async checkNetworkRequest(domain) {
+        if (!this.networkPolicyManager) {
+            // No policy enforcement - allow all
+            return {
+                allowed: true,
+                policy: (0, default_policies_js_1.getNetworkPolicy)(this.agentId.type),
+            };
+        }
+        return this.networkPolicyManager.checkRequest(this.agentId.id, this.agentId.type, domain);
+    }
+    /**
+     * Record a network request (consumes rate limit token)
+     * Call this after making an actual network request
+     *
+     * @param domain - The target domain
+     * @param allowed - Whether the request was allowed
+     * @param responseTimeMs - Response time in milliseconds (optional)
+     */
+    async recordNetworkRequest(domain, allowed, responseTimeMs) {
+        if (!this.networkPolicyManager) {
+            return;
+        }
+        await this.networkPolicyManager.recordRequest(this.agentId.id, this.agentId.type, domain, allowed, responseTimeMs);
+    }
+    /**
+     * Make a policy-enforced network request
+     * Checks domain whitelist and rate limits before allowing the request
+     *
+     * @param url - The full URL to request
+     * @param requestFn - Function that performs the actual request
+     * @returns The result of requestFn if allowed
+     * @throws Error if request is blocked by policy
+     *
+     * @example
+     * ```typescript
+     * const response = await this.makeNetworkRequest(
+     *   'https://api.anthropic.com/v1/messages',
+     *   async () => fetch('https://api.anthropic.com/v1/messages', { method: 'POST', ... })
+     * );
+     * ```
+     */
+    async makeNetworkRequest(url, requestFn) {
+        // Extract domain from URL
+        let domain;
+        try {
+            const parsedUrl = new URL(url);
+            domain = parsedUrl.hostname;
+        }
+        catch {
+            throw new Error(`Invalid URL: ${url}`);
+        }
+        // Check if request is allowed
+        const check = await this.checkNetworkRequest(domain);
+        if (!check.allowed) {
+            const error = new Error(`Network request blocked: ${check.reason} - ${check.details || domain}`);
+            error.policyCheckResult = check;
+            throw error;
+        }
+        // Make the actual request
+        const startTime = Date.now();
+        try {
+            const result = await requestFn();
+            const responseTime = Date.now() - startTime;
+            await this.recordNetworkRequest(domain, true, responseTime);
+            return result;
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            await this.recordNetworkRequest(domain, false, responseTime);
+            throw error;
+        }
+    }
+    /**
+     * Get rate limit status for this agent
+     */
+    getNetworkRateLimitStatus() {
+        if (!this.networkPolicyManager) {
+            return null;
+        }
+        return this.networkPolicyManager.getRateLimitStatus(this.agentId.id, this.agentId.type);
+    }
+    /**
+     * Get network audit statistics
+     * @param since - Optional start date for stats
+     */
+    async getNetworkAuditStats(since) {
+        if (!this.networkPolicyManager) {
+            return null;
+        }
+        return this.networkPolicyManager.getAuditStats(since);
+    }
+    /**
+     * Get network policy statistics for this agent
+     */
+    getNetworkPolicyStats() {
+        if (!this.hasNetworkPolicy()) {
+            return { enabled: false };
+        }
+        return {
+            enabled: true,
+            policy: this.getNetworkPolicy(),
+            rateLimitStatus: this.getNetworkRateLimitStatus(),
+        };
+    }
+    /**
+     * Cleanup network policy resources on agent termination
+     */
+    async cleanupNetworkPolicy() {
+        if (!this.networkPolicyInitialized) {
+            return;
+        }
+        try {
+            // Only shutdown if we own the manager (not shared)
+            if (this.networkPolicyOwned && this.networkPolicyManager) {
+                await this.networkPolicyManager.shutdown();
+                this.logger.info(`[${this.agentId.id}] Network Policy cleanup complete`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Network Policy cleanup error:`, error.message);
+        }
+        this.networkPolicyInitialized = false;
+        this.networkPolicyManager = undefined;
+    }
+    // ============================================
+    // Sandbox Infrastructure Methods (SP-1 - Issue #146)
+    // ============================================
+    /**
+     * Initialize Sandbox Manager for Docker-based agent isolation
+     * Provides secure, isolated execution environments with resource limits
+     */
+    async initializeSandbox() {
+        if (this.sandboxConfig.enabled === false) {
+            this.logger.debug(`[${this.agentId.id}] Sandbox disabled by configuration`);
+            return;
+        }
+        try {
+            // Use shared manager if provided, otherwise create a new one
+            if (this.sandboxConfig.sharedManager) {
+                this.sandboxManager = this.sandboxConfig.sharedManager;
+                this.sandboxOwned = false;
+            }
+            else {
+                this.sandboxManager = (0, SandboxManager_js_1.createSandboxManager)({
+                    agentImage: process.env.AQE_SANDBOX_IMAGE || 'agentic-qe-agent',
+                    imageTag: process.env.AQE_SANDBOX_TAG || 'latest',
+                    cleanupOnShutdown: true,
+                });
+                await this.sandboxManager.initialize();
+                this.sandboxOwned = true;
+            }
+            // Auto-create sandbox container if configured
+            if (this.sandboxConfig.autoCreateSandbox !== false) {
+                const result = await this.createSandboxContainer();
+                if (result.success && result.container) {
+                    this.containerId = result.container.containerId;
+                }
+                else if (!result.success) {
+                    // Docker not available - graceful degradation
+                    this.logger.info(`[${this.agentId.id}] Sandbox container creation skipped: ${result.error}`);
+                }
+            }
+            this.sandboxInitialized = true;
+            this.logger.info(`[${this.agentId.id}] Sandbox initialized (owned: ${this.sandboxOwned}, container: ${this.containerId || 'none'})`);
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Sandbox initialization failed:`, error.message);
+            // Don't throw - agent can work without sandbox (graceful degradation)
+        }
+    }
+    /**
+     * Check if sandbox isolation is available
+     */
+    hasSandbox() {
+        return this.sandboxInitialized && this.sandboxManager !== undefined;
+    }
+    /**
+     * Check if agent is running in a sandbox container
+     */
+    isInSandbox() {
+        return this.containerId !== undefined;
+    }
+    /**
+     * Get the container ID if running in sandbox
+     */
+    getContainerId() {
+        return this.containerId;
+    }
+    /**
+     * Get sandbox configuration for this agent type
+     */
+    getSandboxConfig() {
+        return (0, agent_profiles_js_1.getAgentSandboxConfig)(this.agentId.type);
+    }
+    /**
+     * Create a sandbox container for this agent
+     * @param customConfig - Optional custom sandbox configuration
+     */
+    async createSandboxContainer(customConfig) {
+        if (!this.sandboxManager) {
+            return {
+                success: false,
+                error: 'Sandbox manager not initialized',
+            };
+        }
+        // Check if Docker is available
+        const dockerAvailable = await this.sandboxManager.isDockerAvailable();
+        if (!dockerAvailable) {
+            return {
+                success: false,
+                error: 'Docker not available',
+            };
+        }
+        // Merge profile config with any overrides
+        const mergedConfig = {
+            ...this.sandboxConfig.sandboxOverrides,
+            ...customConfig,
+        };
+        return this.sandboxManager.createSandbox(this.agentId.id, this.agentId.type, mergedConfig);
+    }
+    /**
+     * Get resource usage for the sandbox container
+     */
+    async getSandboxResourceUsage() {
+        if (!this.sandboxManager || !this.containerId) {
+            return null;
+        }
+        return this.sandboxManager.getResourceUsage(this.containerId);
+    }
+    /**
+     * Check sandbox container health
+     */
+    async checkSandboxHealth() {
+        if (!this.sandboxManager || !this.containerId) {
+            return null;
+        }
+        return this.sandboxManager.healthCheck(this.containerId);
+    }
+    /**
+     * Execute a command in the sandbox container
+     * @param command - Command to execute as array of strings
+     */
+    async execInSandbox(command) {
+        if (!this.sandboxManager || !this.containerId) {
+            return null;
+        }
+        return this.sandboxManager.exec(this.containerId, command);
+    }
+    /**
+     * Get sandbox container logs
+     * @param options - Log retrieval options
+     */
+    async getSandboxLogs(options) {
+        if (!this.sandboxManager || !this.containerId) {
+            return null;
+        }
+        return this.sandboxManager.getLogs(this.containerId, options);
+    }
+    /**
+     * Subscribe to sandbox events
+     * @param handler - Event handler function
+     */
+    onSandboxEvent(handler) {
+        if (this.sandboxManager) {
+            this.sandboxManager.on(handler);
+        }
+    }
+    /**
+     * Unsubscribe from sandbox events
+     * @param handler - Event handler to remove
+     */
+    offSandboxEvent(handler) {
+        if (this.sandboxManager) {
+            this.sandboxManager.off(handler);
+        }
+    }
+    /**
+     * Get sandbox statistics for this agent
+     */
+    getSandboxStats() {
+        if (!this.hasSandbox()) {
+            return { enabled: false, inSandbox: false };
+        }
+        return {
+            enabled: true,
+            inSandbox: this.isInSandbox(),
+            containerId: this.containerId,
+            sandboxConfig: this.getSandboxConfig(),
+        };
+    }
+    /**
+     * Cleanup sandbox resources on agent termination
+     */
+    async cleanupSandbox() {
+        if (!this.sandboxInitialized) {
+            return;
+        }
+        try {
+            // Destroy our container if we have one
+            if (this.containerId && this.sandboxManager) {
+                const result = await this.sandboxManager.destroySandbox(this.containerId, true);
+                if (result.success) {
+                    this.logger.info(`[${this.agentId.id}] Sandbox container ${this.containerId} destroyed`);
+                }
+                else {
+                    this.logger.warn(`[${this.agentId.id}] Sandbox container destruction failed: ${result.error}`);
+                }
+            }
+            // Only shutdown manager if we own it (not shared)
+            if (this.sandboxOwned && this.sandboxManager) {
+                await this.sandboxManager.shutdown();
+                this.logger.info(`[${this.agentId.id}] Sandbox manager shutdown complete`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`[${this.agentId.id}] Sandbox cleanup error:`, error.message);
+        }
+        this.sandboxInitialized = false;
+        this.sandboxManager = undefined;
+        this.containerId = undefined;
+    }
 }
 exports.BaseAgent = BaseAgent;
 class BaseAgentFactory {