agentic-qe 2.5.4 → 2.5.6

package/dist/agents/BaseAgent.js

@@ -1,15 +1,11 @@
 "use strict";
 /**
  * BaseAgent - Abstract base class for all QE agents
- * Implements core lifecycle hooks, event handling, and memory access
- * Based on SPARC Phase 2 Pseudocode and Phase 3 Architecture
+ * Phase 2 B1.2: Decomposed with strategy pattern (~500 LOC target)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAgentFactory = exports.BaseAgent = void 0;
-exports.isSwarmMemoryManager = isSwarmMemoryManager;
-exports.validateLearningConfig = validateLearningConfig;
+exports.BaseAgentFactory = exports.BaseAgent = exports.validateLearningConfig = exports.isSwarmMemoryManager = void 0;
 const events_1 = require("events");
-const SecureRandom_js_1 = require("../utils/SecureRandom.js");
 const types_1 = require("../types");
 const hooks_1 = require("../core/hooks");
 const MemoryStoreAdapter_1 = require("../adapters/MemoryStoreAdapter");
@@ -20,85 +16,27 @@ const AgentLifecycleManager_1 = require("./lifecycle/AgentLifecycleManager");
 const AgentCoordinator_1 = require("./coordination/AgentCoordinator");
 const AgentMemoryService_1 = require("./memory/AgentMemoryService");
 const adapters_1 = require("./adapters");
-/**
- * Check if a memory store is SwarmMemoryManager
- *
- * @remarks
- * This is a runtime check using instanceof. Use this to verify if learning
- * features are available before attempting to use them.
- *
- * Note: This is NOT a TypeScript type guard because MemoryStore and
- * SwarmMemoryManager have incompatible method signatures. After checking
- * with this function, use a type assertion: `store as SwarmMemoryManager`
- *
- * @example
- * ```typescript
- * if (isSwarmMemoryManager(config.memoryStore)) {
- *   const swarm = config.memoryStore as SwarmMemoryManager;
- *   // Use swarm's learning features
- * }
- * ```
- */
-function isSwarmMemoryManager(store) {
-    return store instanceof SwarmMemoryManager_1.SwarmMemoryManager;
-}
-/**
- * Validate agent config for learning features
- *
- * @remarks
- * Call this early in agent initialization to fail fast with clear error message.
- * This helps developers identify configuration issues immediately rather than
- * discovering disabled learning features at runtime.
- *
- * Issue #137: FleetManager was passing MemoryManager instead of SwarmMemoryManager,
- * causing learning features to be silently disabled for all agents.
- *
- * @param config - Agent configuration to validate
- * @param options - Validation options
- * @param options.throwOnMismatch - If true, throws an error instead of returning warning
- * @returns Validation result with valid flag and optional warning message
- *
- * @example
- * ```typescript
- * // In agent constructor:
- * const validation = validateLearningConfig(config);
- * if (!validation.valid) {
- *   console.warn(validation.warning);
- * }
- * ```
- */
-function validateLearningConfig(config, options = {}) {
-    const enableLearning = config.enableLearning ?? true;
-    if (enableLearning && !isSwarmMemoryManager(config.memoryStore)) {
-        const warning = `Learning is enabled but memoryStore is not SwarmMemoryManager. ` +
-            `Got ${config.memoryStore.constructor.name}. ` +
-            `Learning features (Q-learning, patterns, metrics) will be DISABLED. ` +
-            `To fix: Use SwarmMemoryManager or set enableLearning: false.`;
-        if (options.throwOnMismatch) {
-            throw new Error(warning);
-        }
-        return { valid: false, warning };
-    }
-    return { valid: true };
-}
+// Extracted utilities (B1.2)
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "isSwarmMemoryManager", { enumerable: true, get: function () { return utils_1.isSwarmMemoryManager; } });
+Object.defineProperty(exports, "validateLearningConfig", { enumerable: true, get: function () { return utils_1.validateLearningConfig; } });
 class BaseAgent extends events_1.EventEmitter {
     constructor(config) {
         super();
         this.performanceMetrics = { tasksCompleted: 0, averageExecutionTime: 0, errorCount: 0, lastActivity: new Date() };
-        this.agentId = { id: config.id || this.generateAgentId(config.type), type: config.type, created: new Date() };
+        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;
         this.memoryStore = config.memoryStore;
         this.eventBus = config.eventBus;
         this.enableLearning = config.enableLearning ?? true;
         this.learningConfig = config.learningConfig;
-        // Early validation: Warn immediately if learning config is invalid
-        // Issue #137: Fail-fast pattern to catch configuration issues at construction time
-        const validation = validateLearningConfig(config);
+        // Early validation (Issue #137)
+        const validation = (0, utils_1.validateLearningConfig)(config);
         if (!validation.valid && validation.warning) {
             console.warn(`[${this.agentId.id}] CONFIG WARNING: ${validation.warning}`);
         }
-        // Initialize service classes
+        // Initialize services
         const memoryAdapter = new MemoryStoreAdapter_1.MemoryStoreAdapter(this.memoryStore);
         this.hookManager = new hooks_1.VerificationHookManager(memoryAdapter);
         this.lifecycleManager = new AgentLifecycleManager_1.AgentLifecycleManager(this.agentId);
@@ -115,83 +53,47 @@ class BaseAgent extends events_1.EventEmitter {
         this.setupEventHandlers();
         this.setupLifecycleHooks();
     }
-    // ============================================================================
-    // Public Interface
-    // ============================================================================
-    /**
-     * Initialize the agent - must be called after construction
-     * Thread-safe: Multiple concurrent calls will wait for the first to complete
-     */
+    // === Public Interface ===
     async initialize() {
-        // Thread-safety: If initialization is in progress, wait for it
         if (this.initializationMutex) {
-            console.info(`[${this.agentId.id}] Initialization already in progress, waiting for completion`);
             await this.initializationMutex;
-            // Check if initialization succeeded or failed
-            const statusAfterWait = this.lifecycleManager.getStatus();
-            if (statusAfterWait === types_1.AgentStatus.ERROR) {
-                throw new Error(`Initialization failed (status: ${statusAfterWait})`);
+            if (this.lifecycleManager.getStatus() === types_1.AgentStatus.ERROR) {
+                throw new Error(`Initialization failed`);
             }
             return;
         }
-        // Guard: Skip if already initialized (ACTIVE or IDLE)
         const currentStatus = this.lifecycleManager.getStatus();
-        if (currentStatus === types_1.AgentStatus.ACTIVE || currentStatus === types_1.AgentStatus.IDLE) {
-            console.warn(`[${this.agentId.id}] Agent already initialized (status: ${currentStatus}), skipping`);
+        if (currentStatus === types_1.AgentStatus.ACTIVE || currentStatus === types_1.AgentStatus.IDLE)
             return;
-        }
-        // Create initialization mutex - lock acquired
         let resolveMutex;
-        this.initializationMutex = new Promise((resolve) => {
-            resolveMutex = resolve;
-        });
+        this.initializationMutex = new Promise((resolve) => { resolveMutex = resolve; });
         try {
-            // Guard: Reset from ERROR state before initializing
-            if (currentStatus === types_1.AgentStatus.ERROR) {
-                console.info(`[${this.agentId.id}] Resetting agent from ERROR state before initialization`);
+            if (currentStatus === types_1.AgentStatus.ERROR)
                 this.lifecycleManager.reset(false);
-            }
-            // Delegate lifecycle initialization to lifecycleManager
             await this.lifecycleManager.initialize({
-                onPreInitialization: async () => {
-                    await this.executeHook('pre-initialization');
-                },
+                onPreInitialization: () => this.executeHook('pre-initialization'),
                 onPostInitialization: async () => {
-                    // Load agent knowledge and state
                     await this.loadKnowledge();
                     const savedState = await this.memoryService.restoreState();
-                    if (savedState && savedState.performanceMetrics) {
+                    if (savedState?.performanceMetrics) {
                         this.performanceMetrics = { ...this.performanceMetrics, ...savedState.performanceMetrics };
                     }
-                    // Initialize PerformanceTracker if learning is enabled
-                    // Issue #137: FleetManager now provides SwarmMemoryManager to enable learning
+                    // Initialize learning if SwarmMemoryManager
                     if (this.enableLearning && this.memoryStore instanceof SwarmMemoryManager_1.SwarmMemoryManager) {
                         this.performanceTracker = new PerformanceTracker_1.PerformanceTracker(this.agentId.id, this.memoryStore);
                         await this.performanceTracker.initialize();
-                        // Initialize learning engine for Q-learning
-                        // ARCHITECTURE (v2.2.0): LearningEngine uses SwarmMemoryManager for ALL persistence
-                        // All data (experiences, patterns, Q-values) goes to unified .agentic-qe/memory.db
-                        // No direct database dependency - memoryStore handles all coordination
                         this.learningEngine = new LearningEngine_1.LearningEngine(this.agentId.id, this.memoryStore, this.learningConfig);
                         await this.learningEngine.initialize();
-                        // Phase 2 (B1.2): Create learning strategy adapter
-                        // Only set if not already injected via config
                         if (!this.strategies.learning) {
                             this.strategies.learning = (0, adapters_1.createLearningAdapter)(this.learningEngine);
                         }
                     }
-                    else if (this.enableLearning && !(this.memoryStore instanceof SwarmMemoryManager_1.SwarmMemoryManager)) {
-                        // Runtime check: Warn if learning is enabled but memoryStore doesn't support it
-                        // Note: Early warning was already emitted in constructor (Issue #137)
-                        console.warn(`[${this.agentId.id}] Learning enabled but memoryStore is not SwarmMemoryManager. ` +
-                            `Learning features will be disabled. Expected SwarmMemoryManager, got ${this.memoryStore.constructor.name}`);
+                    else if (this.enableLearning) {
+                        console.warn(`[${this.agentId.id}] Learning disabled: memoryStore is ${this.memoryStore.constructor.name}`);
                     }
-                    // Initialize agent-specific components
                     await this.initializeComponents();
-                    // Execute post-initialization hooks
                     await this.executeHook('post-initialization');
                     this.coordinator.emitEvent('agent.initialized', { agentId: this.agentId });
-                    // Report initialization to coordination system
                     await this.coordinator.reportStatus('initialized', this.performanceMetrics);
                 }
             });
@@ -202,60 +104,39 @@ class BaseAgent extends events_1.EventEmitter {
             throw error;
         }
         finally {
-            // Release mutex lock - allow future initializations
             resolveMutex();
             this.initializationMutex = undefined;
         }
     }
-    /**
-     * Execute a task assignment with integrated verification hooks
-     */
     async executeTask(assignment) {
         const startTime = Date.now();
         try {
-            // Validate task assignment
             this.validateTaskAssignment(assignment);
             this.currentTask = assignment;
-            // Phase 2 (B1.2): Use lifecycle strategy for status transitions
             await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ACTIVE);
-            // Execute pre-task hooks with verification
             const preTaskData = { assignment };
             await this.onPreTask(preTaskData);
             await this.executeHook('pre-task', preTaskData);
-            // Broadcast task start
             await this.coordinator.broadcastMessage('task-start', assignment);
-            // Execute the actual task
             const result = await this.performTask(assignment.task);
-            // Execute post-task hooks with validation
             const postTaskData = { assignment, result };
             await this.onPostTask(postTaskData);
             await this.executeHook('post-task', postTaskData);
-            // Update performance metrics and store result
             this.updatePerformanceMetrics(startTime, true);
             await this.memoryService.storeTaskResult(assignment.id, result);
             this.currentTask = undefined;
-            // Phase 2 (B1.2): Use lifecycle strategy for status transitions
             await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.IDLE);
             return result;
         }
         catch (error) {
             this.updatePerformanceMetrics(startTime, false);
             this.currentTask = undefined;
-            // Phase 2 (B1.2): Use lifecycle strategy for error transition
-            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ERROR, `Task execution failed: ${error}`);
-            // Execute error hooks
-            const errorData = {
-                assignment,
-                error: error
-            };
-            await this.onTaskError(errorData);
-            await this.executeHook('task-error', errorData);
+            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ERROR, `Task failed: ${error}`);
+            await this.onTaskError({ assignment, error: error });
+            await this.executeHook('task-error', { assignment, error });
             throw error;
         }
     }
-    /**
-     * Terminate the agent gracefully
-     */
     async terminate() {
         try {
             await this.lifecycleManager.terminate({
@@ -277,17 +158,9 @@ class BaseAgent extends events_1.EventEmitter {
             throw error;
         }
     }
-    /**
-     * Get agent ID
-     */
-    getAgentId() {
-        return this.agentId;
-    }
-    /**
-     * Get current agent status and metrics
-     */
+    // === Getters ===
+    getAgentId() { return this.agentId; }
     getStatus() {
-        // Phase 2 (B1.2): Use lifecycle strategy instead of direct manager call
         return {
             agentId: this.agentId,
             status: this.strategies.lifecycle.getStatus(),
@@ -296,29 +169,25 @@ class BaseAgent extends events_1.EventEmitter {
             performanceMetrics: { ...this.performanceMetrics }
         };
     }
-    // ============================================================================
-    // Event-Driven Coordination (Race Condition Elimination)
-    // ============================================================================
-    /**
-     * Wait for agent to reach a specific status with timeout
-     * Replaces: setTimeout(() => { expect(agent.status).toBe('ready') }, 5000)
-     * Use: await agent.waitForStatus('ready')
-     */
+    hasCapability(name) { return this.capabilities.has(name); }
+    getCapability(name) { return this.capabilities.get(name); }
+    getCapabilities() { return Array.from(this.capabilities.values()); }
+    getStrategies() { return this.strategies; }
+    getLifecycleStrategy() { return this.strategies.lifecycle; }
+    getMemoryStrategy() { return this.strategies.memory; }
+    getLearningStrategy() { return this.strategies.learning; }
+    getCoordinationStrategy() { return this.strategies.coordination; }
+    // === Event-Driven Coordination ===
     async waitForStatus(status, timeout = 10000) {
-        // Phase 2 (B1.2): Use lifecycle strategy for status waiting
-        // Strategy provides waitForStatus implementation
         if (typeof this.strategies.lifecycle.waitForStatus === 'function') {
             return this.strategies.lifecycle.waitForStatus(status, timeout);
         }
-        // Fallback to event-based implementation
         return new Promise((resolve, reject) => {
-            // Already at target status
-            if (this.strategies.lifecycle.getStatus() === status) {
+            if (this.strategies.lifecycle.getStatus() === status)
                 return resolve();
-            }
             const timer = setTimeout(() => {
                 this.removeListener('status-changed', listener);
-                reject(new Error(`Agent ${this.agentId.id} did not reach status '${status}' within ${timeout}ms`));
+                reject(new Error(`Agent did not reach status '${status}' within ${timeout}ms`));
             }, timeout);
             const listener = (newStatus) => {
                 if (newStatus === status) {
@@ -330,146 +199,41 @@ class BaseAgent extends events_1.EventEmitter {
             this.on('status-changed', listener);
         });
     }
-    /**
-     * Wait for agent to be ready (initialized and idle)
-     * Replaces: await new Promise(resolve => setTimeout(resolve, 5000))
-     * Use: await agent.waitForReady()
-     */
     async waitForReady(timeout = 10000) {
-        // Phase 2 (B1.2): Use lifecycle strategy
-        // Strategy provides waitForReady implementation
         if (typeof this.strategies.lifecycle.waitForReady === 'function') {
             return this.strategies.lifecycle.waitForReady(timeout);
         }
-        // Fallback to waitForStatus-based implementation
-        const currentStatus = this.strategies.lifecycle.getStatus();
-        if (currentStatus === types_1.AgentStatus.IDLE || currentStatus === types_1.AgentStatus.ACTIVE) {
-            return; // Already ready
-        }
+        const status = this.strategies.lifecycle.getStatus();
+        if (status === types_1.AgentStatus.IDLE || status === types_1.AgentStatus.ACTIVE)
+            return;
         return this.waitForStatus(types_1.AgentStatus.IDLE, timeout);
     }
-    /**
-     * Wait for a specific event to be emitted
-     * Generic event waiter for custom coordination
-     */
     async waitForEvent(eventName, timeout = 10000) {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.removeListener(eventName, listener);
                 reject(new Error(`Event '${eventName}' not received within ${timeout}ms`));
             }, timeout);
-            const listener = (data) => {
-                clearTimeout(timer);
-                this.removeListener(eventName, listener);
-                resolve(data);
-            };
+            const listener = (data) => { clearTimeout(timer); this.removeListener(eventName, listener); resolve(data); };
             this.once(eventName, listener);
         });
     }
-    /**
-     * Emit status change events for event-driven coordination
-     * Called by lifecycle manager when status changes
-     */
-    emitStatusChange(newStatus) {
-        this.emit('status-changed', newStatus);
-        this.coordinator.emitEvent('agent.status-changed', {
-            agentId: this.agentId,
-            status: newStatus,
-            timestamp: Date.now()
-        });
-    }
-    /**
-     * Check if agent has a specific capability
-     */
-    hasCapability(capabilityName) {
-        return this.capabilities.has(capabilityName);
-    }
-    /**
-     * Get capability details
-     */
-    getCapability(capabilityName) {
-        return this.capabilities.get(capabilityName);
-    }
-    /**
-     * Get all capabilities
-     */
-    getCapabilities() {
-        return Array.from(this.capabilities.values());
-    }
-    /**
-     * Get strategies (Phase 2 B1.2)
-     * Lifecycle and memory strategies are always available (adapter or custom)
-     */
-    getStrategies() {
-        return this.strategies;
-    }
-    /**
-     * Get the lifecycle strategy
-     */
-    getLifecycleStrategy() {
-        return this.strategies.lifecycle;
-    }
-    /**
-     * Get the memory strategy
-     */
-    getMemoryStrategy() {
-        return this.strategies.memory;
-    }
-    /**
-     * Get the learning strategy (if enabled)
-     */
-    getLearningStrategy() {
-        return this.strategies.learning;
-    }
-    /**
-     * Get the coordination strategy
-     */
-    getCoordinationStrategy() {
-        return this.strategies.coordination;
-    }
-    /**
-     * Register a new capability dynamically
-     */
-    registerCapability(capability) {
-        this.capabilities.set(capability.name, capability);
-        this.emitEvent('capability.registered', {
-            agentId: this.agentId,
-            capability: capability.name
-        });
-    }
-    /**
-     * Register multiple capabilities at once
-     */
-    registerCapabilities(capabilities) {
-        for (const capability of capabilities) {
-            this.registerCapability(capability);
-        }
-    }
-    /**
-     * Get Q-learning strategy recommendation
-     */
+    // === Learning Interface ===
     async recommendStrategy(taskState) {
         if (!this.learningEngine?.isEnabled())
             return null;
         try {
             return await this.learningEngine.recommendStrategy(taskState);
         }
-        catch (error) {
-            console.error(`Strategy recommendation failed:`, error);
+        catch {
             return null;
         }
     }
-    /**
-     * Get learned patterns from Q-learning
-     */
     async getLearnedPatterns() {
         if (!this.learningEngine)
             return [];
         return await this.learningEngine.getPatterns();
     }
-    /**
-     * Get learning engine status
-     */
     async getLearningStatus() {
         if (!this.learningEngine)
             return null;
@@ -481,51 +245,17 @@ class BaseAgent extends events_1.EventEmitter {
             patterns: Array.isArray(patterns) ? patterns.length : 0
         };
     }
-    /**
-     * @deprecated v2.2.0 - AgentDB is deprecated. Use SwarmMemoryManager instead.
-     * Stub method for backward compatibility - will be removed in v3.0.0.
-     */
-    async initializeAgentDB(_config) {
-        console.warn(`[${this.agentId.id}] AgentDB is DEPRECATED and will be removed in v3.0.0`);
-    }
-    /**
-     * @deprecated v2.2.0 - Use learning strategy instead.
-     */
-    async getAgentDBStatus() {
-        return null;
-    }
-    /**
-     * @deprecated v2.2.0 - Returns false, AgentDB removed.
-     */
-    hasAgentDB() {
-        return false;
-    }
-    /**
-     * Start the agent (idempotent - safe to call multiple times)
-     */
+    // === Start/Stop (FleetManager compatibility) ===
     async start() {
-        const currentStatus = this.lifecycleManager.getStatus();
-        // If already active or idle, no need to initialize again
-        if (currentStatus === types_1.AgentStatus.ACTIVE || currentStatus === types_1.AgentStatus.IDLE) {
-            console.info(`[${this.agentId.id}] Agent already started (status: ${currentStatus})`);
+        const status = this.lifecycleManager.getStatus();
+        if (status === types_1.AgentStatus.ACTIVE || status === types_1.AgentStatus.IDLE)
             return;
-        }
-        // Otherwise, initialize the agent
         await this.initialize();
     }
-    /**
-     * Stop the agent (alias for terminate)
-     * Added for FleetManager compatibility
-     */
-    async stop() {
-        await this.terminate();
-    }
-    /**
-     * Assign a task to the agent
-     */
+    async stop() { await this.terminate(); }
     async assignTask(task) {
         const assignment = {
-            id: `task-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`,
+            id: (0, utils_1.generateTaskId)(),
             task,
             agentId: this.agentId.id,
             assignedAt: new Date(),
@@ -533,259 +263,160 @@ class BaseAgent extends events_1.EventEmitter {
         };
         await this.executeTask(assignment);
     }
-    // ============================================================================
-    // Event System
-    // ============================================================================
-    /**
-     * Register an event handler
-     */
+    // === Deprecated (Remove in v3.0.0) ===
+    /** @deprecated v2.2.0 - AgentDB removed. Use SwarmMemoryManager. */
+    async initializeAgentDB(_config) {
+        console.warn(`[${this.agentId.id}] AgentDB is DEPRECATED`);
+    }
+    /** @deprecated v2.2.0 */
+    async getAgentDBStatus() { return null; }
+    /** @deprecated v2.2.0 */
+    hasAgentDB() { return false; }
+    // === Protected Methods ===
+    registerCapability(capability) {
+        this.capabilities.set(capability.name, capability);
+        this.emitEvent('capability.registered', { agentId: this.agentId, capability: capability.name });
+    }
+    registerCapabilities(capabilities) {
+        capabilities.forEach(cap => this.registerCapability(cap));
+    }
     registerEventHandler(handler) {
         this.coordinator.registerEventHandler(handler);
     }
-    /**
-     * Emit an event
-     */
     emitEvent(type, data, priority = 'medium') {
         const event = {
-            id: this.generateEventId(),
-            type,
-            source: this.agentId,
-            data,
-            timestamp: new Date(),
-            priority,
-            scope: 'global'
+            id: (0, utils_1.generateEventId)(), type, source: this.agentId, data,
+            timestamp: new Date(), priority, scope: 'global'
         };
         this.eventBus.emit(type, event);
     }
-    /**
-     * Broadcast message to other agents
-     * Uses AgentDB if enabled, falls back to EventBus
-     */
+    emitStatusChange(newStatus) {
+        this.emit('status-changed', newStatus);
+        this.coordinator.emitEvent('agent.status-changed', { agentId: this.agentId, status: newStatus, timestamp: Date.now() });
+    }
     async broadcastMessage(type, payload) {
-        // Use EventBus for now (AgentDB sync handles distributed state)
         const message = {
-            id: this.generateMessageId(),
-            from: this.agentId,
+            id: (0, utils_1.generateMessageId)(), from: this.agentId,
             to: { id: 'broadcast', type: 'all', created: new Date() },
-            type: type,
-            payload,
-            timestamp: new Date(),
-            priority: 'medium'
+            type: type, payload, timestamp: new Date(), priority: 'medium'
         };
         this.eventBus.emit('agent.message', message);
     }
-    // ============================================================================
-    // Memory Operations (Phase 2 B1.2 - delegated to strategy)
-    // ============================================================================
-    /**
-     * Store data in memory with automatic namespacing
-     * Phase 2 (B1.2): Delegates to memory strategy with aqe/{agentType}/{key} namespace
-     */
+    // === Memory Operations (delegated to strategy) ===
     async storeMemory(key, value, ttl) {
-        // Phase 2 (B1.2): Use memory strategy with local namespace
-        const memoryStrategy = this.strategies.memory;
-        if (memoryStrategy instanceof adapters_1.MemoryServiceAdapter) {
-            await memoryStrategy.storeLocal(key, value, ttl);
+        const strategy = this.strategies.memory;
+        if (strategy instanceof adapters_1.MemoryServiceAdapter) {
+            await strategy.storeLocal(key, value, ttl);
         }
         else {
-            // Fallback for custom strategies
-            await memoryStrategy.store(key, value, { ttl, namespace: this.agentId.type });
+            await strategy.store(key, value, { ttl, namespace: this.agentId.type });
         }
     }
-    /**
-     * Retrieve data from memory
-     * Phase 2 (B1.2): Delegates to memory strategy with aqe/{agentType}/{key} namespace
-     */
     async retrieveMemory(key) {
-        // Phase 2 (B1.2): Use memory strategy with local namespace
-        const memoryStrategy = this.strategies.memory;
-        if (memoryStrategy instanceof adapters_1.MemoryServiceAdapter) {
-            return await memoryStrategy.retrieveLocal(key);
-        }
-        else {
-            // Fallback for custom strategies - must handle namespace manually
-            return await memoryStrategy.retrieve(`aqe/${this.agentId.type}/${key}`);
+        const strategy = this.strategies.memory;
+        if (strategy instanceof adapters_1.MemoryServiceAdapter) {
+            return await strategy.retrieveLocal(key);
         }
+        return await strategy.retrieve(`aqe/${this.agentId.type}/${key}`);
     }
-    /**
-     * Store shared data accessible by other agents
-     * Phase 2 (B1.2): Delegates to memory strategy with aqe/shared/{agentType}/{key} namespace
-     */
     async storeSharedMemory(key, value, ttl) {
-        // Phase 2 (B1.2): Use memory strategy with shared namespace
-        const memoryStrategy = this.strategies.memory;
-        if (memoryStrategy instanceof adapters_1.MemoryServiceAdapter) {
-            await memoryStrategy.storeSharedLocal(key, value, ttl);
+        const strategy = this.strategies.memory;
+        if (strategy instanceof adapters_1.MemoryServiceAdapter) {
+            await strategy.storeSharedLocal(key, value, ttl);
         }
         else {
-            // Fallback for custom strategies
-            await memoryStrategy.storeShared(this.agentId.type, key, value, { ttl });
+            await strategy.storeShared(this.agentId.type, key, value, { ttl });
         }
     }
-    /**
-     * Retrieve shared data from other agents
-     * Phase 2 (B1.2): Delegates to memory strategy with aqe/shared/{agentType}/{key} namespace
-     */
     async retrieveSharedMemory(agentType, key) {
-        // Phase 2 (B1.2): Use memory strategy for shared retrieval
         return await this.strategies.memory.retrieveShared(agentType, key);
     }
-    // ============================================================================
-    // Lifecycle Hooks
-    // ============================================================================
-    /**
-     * Pre-task hook - called before task execution
-     * Delegates to lifecycle strategy for pre-task processing
-     */
+    // === Lifecycle Hooks ===
     async onPreTask(data) {
         this.taskStartTime = Date.now();
-        // Delegate to lifecycle strategy if available
-        if (this.strategies.lifecycle.onPreTask) {
+        if (this.strategies.lifecycle.onPreTask)
             await this.strategies.lifecycle.onPreTask(data);
+        const result = await this.hookManager.executePreTaskVerification({ task: data.assignment.task.type, context: data.context });
+        if (!result.passed) {
+            throw new Error(`Pre-task verification failed: score ${result.score}`);
         }
-        // Run verification checks
-        const verificationResult = await this.hookManager.executePreTaskVerification({
-            task: data.assignment.task.type,
-            context: data.context
-        });
-        if (!verificationResult.passed) {
-            throw new Error(`Pre-task verification failed with score ${verificationResult.score}. ` +
-                `Checks: ${verificationResult.checks.join(', ')}`);
-        }
-        this.emitEvent('hook.pre-task.completed', {
-            agentId: this.agentId,
-            result: verificationResult
-        });
+        this.emitEvent('hook.pre-task.completed', { agentId: this.agentId, result });
     }
-    /**
-     * Post-task hook - called after task execution
-     * Delegates to lifecycle and learning strategies
-     */
     async onPostTask(data) {
         const executionTime = this.taskStartTime ? Date.now() - this.taskStartTime : 0;
-        // Run validation checks
-        const validationResult = await this.hookManager.executePostTaskValidation({
-            task: data.assignment.task.type,
-            result: data.result
-        });
-        if (!validationResult.valid) {
-            console.warn(`Post-task validation warning with accuracy ${validationResult.accuracy}. ` +
-                `Validations: ${validationResult.validations.join(', ')}`);
+        const result = await this.hookManager.executePostTaskValidation({ task: data.assignment.task.type, result: data.result });
+        if (!result.valid) {
+            console.warn(`Post-task validation warning: accuracy ${result.accuracy}`);
         }
-        // Delegate to lifecycle strategy
-        if (this.strategies.lifecycle.onPostTask) {
+        if (this.strategies.lifecycle.onPostTask)
             await this.strategies.lifecycle.onPostTask(data);
-        }
-        // Delegate learning to learning strategy (handles Q-learning, performance tracking)
         if (this.strategies.learning?.recordExecution) {
             await this.strategies.learning.recordExecution({
-                task: data.assignment.task,
-                result: data.result,
-                success: validationResult.valid,
-                duration: executionTime,
-                metadata: {
-                    taskId: data.assignment.id,
-                    accuracy: validationResult.accuracy,
-                    metrics: this.extractTaskMetrics(data.result)
-                }
+                task: data.assignment.task, result: data.result, success: result.valid,
+                duration: executionTime, metadata: { taskId: data.assignment.id, accuracy: result.accuracy, metrics: this.extractTaskMetrics(data.result) }
             });
         }
-        this.emitEvent('hook.post-task.completed', {
-            agentId: this.agentId,
-            result: validationResult
-        });
+        this.emitEvent('hook.post-task.completed', { agentId: this.agentId, result });
     }
-    /**
-     * Task error hook - called when task execution fails
-     * Delegates to lifecycle and learning strategies
-     */
     async onTaskError(data) {
         const executionTime = this.taskStartTime ? Date.now() - this.taskStartTime : 0;
-        // Store error in memory for analysis
         await this.storeMemory(`error:${data.assignment.id}`, {
             error: { message: data.error.message, name: data.error.name },
             assignment: { id: data.assignment.id, taskType: data.assignment.task.type },
-            timestamp: new Date(),
-            agentId: this.agentId.id
+            timestamp: new Date(), agentId: this.agentId.id
         });
-        // Delegate to lifecycle strategy
-        if (this.strategies.lifecycle.onTaskError) {
+        if (this.strategies.lifecycle.onTaskError)
             await this.strategies.lifecycle.onTaskError(data);
-        }
-        // Delegate error recording to learning strategy
         if (this.strategies.learning?.recordExecution) {
             await this.strategies.learning.recordExecution({
-                task: data.assignment.task,
-                error: data.error,
-                success: false,
-                duration: executionTime,
-                metadata: {
-                    taskId: data.assignment.id
-                }
+                task: data.assignment.task, error: data.error, success: false,
+                duration: executionTime, metadata: { taskId: data.assignment.id }
             });
         }
-        this.emitEvent('hook.task-error.completed', {
-            agentId: this.agentId,
-            error: data.error
-        }, 'high');
+        this.emitEvent('hook.task-error.completed', { agentId: this.agentId, error: data.error }, 'high');
     }
+    // === Private Helpers ===
     async executeHook(hookName, data) {
         try {
             const method = `on${hookName.charAt(0).toUpperCase()}${hookName.slice(1).replace(/-/g, '')}`;
-            if (typeof this[method] === 'function') {
+            if (typeof this[method] === 'function')
                 await this[method](data);
-            }
         }
         catch (error) {
-            console.error(`Hook ${hookName} failed for agent ${this.agentId.id}:`, error);
+            console.error(`Hook ${hookName} failed:`, error);
         }
     }
-    // ============================================================================
-    // Helper Methods
-    // ============================================================================
     setupEventHandlers() {
-        // Set up base event handlers that all agents should have
-        this.registerEventHandler({
-            eventType: 'fleet.shutdown',
-            handler: async () => {
-                await this.terminate();
-            }
-        });
+        this.registerEventHandler({ eventType: 'fleet.shutdown', handler: async () => { await this.terminate(); } });
         this.registerEventHandler({
             eventType: 'agent.ping',
             handler: async (event) => {
-                if (event.target?.id === this.agentId.id) {
+                if (event.target?.id === this.agentId.id)
                     this.emitEvent('agent.pong', { agentId: this.agentId });
-                }
             }
         });
     }
     setupLifecycleHooks() {
-        // Setup default lifecycle behavior
-        // Phase 2 (B1.2): Use lifecycle strategy for error transition
         this.on('error', async (error) => {
-            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ERROR, `Error event: ${error}`);
+            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ERROR, `Error: ${error}`);
             this.emitEvent('agent.error', { agentId: this.agentId, error });
         });
     }
     validateTaskAssignment(assignment) {
-        if (!assignment || !assignment.task) {
+        if (!assignment?.task)
             throw new Error('Invalid task assignment');
-        }
-        // Check if agent has required capabilities
-        const requiredCapabilities = assignment.task.requirements?.capabilities || [];
-        for (const capability of requiredCapabilities) {
-            if (!this.hasCapability(capability)) {
-                throw new Error(`Agent ${this.agentId.id} missing required capability: ${capability}`);
-            }
+        const required = assignment.task.requirements?.capabilities || [];
+        for (const cap of required) {
+            if (!this.hasCapability(cap))
+                throw new Error(`Missing capability: ${cap}`);
         }
     }
     updatePerformanceMetrics(startTime, success) {
-        const executionTime = Date.now() - startTime;
+        const time = Date.now() - startTime;
         if (success) {
             this.performanceMetrics.tasksCompleted++;
             this.performanceMetrics.averageExecutionTime =
-                (this.performanceMetrics.averageExecutionTime * (this.performanceMetrics.tasksCompleted - 1) + executionTime) /
+                (this.performanceMetrics.averageExecutionTime * (this.performanceMetrics.tasksCompleted - 1) + time) /
                     this.performanceMetrics.tasksCompleted;
         }
         else {
@@ -793,47 +424,18 @@ class BaseAgent extends events_1.EventEmitter {
         }
         this.performanceMetrics.lastActivity = new Date();
     }
-    /**
-     * Extract metrics from task result for learning
-     * Override in subclasses to provide agent-specific metrics
-     */
     extractTaskMetrics(result) {
         const metrics = {};
-        // Extract common metrics if available
         if (result && typeof result === 'object') {
-            if (typeof result.coverage === 'number') {
-                metrics.coverage = result.coverage;
-            }
-            if (typeof result.testsGenerated === 'number') {
-                metrics.testsGenerated = result.testsGenerated;
-            }
-            if (typeof result.issuesFound === 'number') {
-                metrics.issuesFound = result.issuesFound;
-            }
-            if (typeof result.confidenceScore === 'number') {
-                metrics.confidenceScore = result.confidenceScore;
-            }
-            if (typeof result.qualityScore === 'number') {
-                metrics.qualityScore = result.qualityScore;
-            }
+            ['coverage', 'testsGenerated', 'issuesFound', 'confidenceScore', 'qualityScore'].forEach(key => {
+                if (typeof result[key] === 'number')
+                    metrics[key] = result[key];
+            });
         }
         return metrics;
     }
-    // State management delegated to memoryService (used in initialize/terminate)
     async saveState() {
-        await this.memoryService.saveState({
-            performanceMetrics: this.performanceMetrics,
-            timestamp: new Date()
-        });
-    }
-    generateAgentId(type) {
-        return `${type}-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`;
-    }
-    generateEventId() {
-        return `event-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`;
-    }
-    generateMessageId() {
-        return `msg-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`;
+        await this.memoryService.saveState({ performanceMetrics: this.performanceMetrics, timestamp: new Date() });
     }
 }
 exports.BaseAgent = BaseAgent;