agentic-qe 2.3.5 → 2.5.0

package/dist/agents/BaseAgent.js

@@ -8,84 +8,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseAgentFactory = exports.BaseAgent = void 0;
 const events_1 = require("events");
 const SecureRandom_js_1 = require("../utils/SecureRandom.js");
-const EmbeddingGenerator_js_1 = require("../utils/EmbeddingGenerator.js");
 const types_1 = require("../types");
 const hooks_1 = require("../core/hooks");
 const MemoryStoreAdapter_1 = require("../adapters/MemoryStoreAdapter");
 const PerformanceTracker_1 = require("../learning/PerformanceTracker");
 const SwarmMemoryManager_1 = require("../core/memory/SwarmMemoryManager");
 const LearningEngine_1 = require("../learning/LearningEngine");
-const AgentDBManager_1 = require("../core/memory/AgentDBManager");
 const AgentLifecycleManager_1 = require("./lifecycle/AgentLifecycleManager");
 const AgentCoordinator_1 = require("./coordination/AgentCoordinator");
 const AgentMemoryService_1 = require("./memory/AgentMemoryService");
-const ExperienceCapture_1 = require("../learning/capture/ExperienceCapture");
+const adapters_1 = require("./adapters");
 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.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.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; // Changed: Default to true for all agents
+        this.enableLearning = config.enableLearning ?? true;
         this.learningConfig = config.learningConfig;
-        // DEPRECATED (v2.2.0): AgentDB configuration
-        // All persistence now goes through SwarmMemoryManager to .agentic-qe/memory.db
-        // AgentDB is kept for backward compatibility but should NOT be used for new code.
-        // LearningEngine handles all learning/pattern storage via memoryStore.
-        if (config.agentDBConfig) {
-            console.warn(`[${config.type}] AgentDB is DEPRECATED. All persistence should use SwarmMemoryManager (memory.db). ` +
-                `AgentDB will be removed in v3.0.0.`);
-            this.agentDBConfig = config.agentDBConfig;
-        }
-        else if (config.agentDBPath || config.enableQUICSync) {
-            console.warn(`[${config.type}] AgentDB paths are DEPRECATED. All persistence now uses memory.db via SwarmMemoryManager.`);
-            // Do NOT create agentDBConfig by default - let memoryStore handle everything
-            // Only create if explicitly requested with a custom path
-            if (config.agentDBPath) {
-                this.agentDBConfig = {
-                    dbPath: config.agentDBPath, // Use explicit path only, no default
-                    enableQUICSync: config.enableQUICSync || false,
-                    syncPort: config.syncPort || 4433,
-                    syncPeers: config.syncPeers || [],
-                    enableLearning: config.enableLearning || false,
-                    enableReasoning: true,
-                    cacheSize: 1000,
-                    quantizationType: config.quantizationType || 'scalar',
-                };
-            }
-        }
-        // Initialize verification hook manager with type-safe adapter
-        // MemoryStoreAdapter bridges MemoryStore interface to SwarmMemoryManager
-        // Provides runtime validation and clear error messages for incompatible implementations
+        // Initialize service classes
         const memoryAdapter = new MemoryStoreAdapter_1.MemoryStoreAdapter(this.memoryStore);
         this.hookManager = new hooks_1.VerificationHookManager(memoryAdapter);
-        // Initialize integrated service classes
         this.lifecycleManager = new AgentLifecycleManager_1.AgentLifecycleManager(this.agentId);
-        this.coordinator = new AgentCoordinator_1.AgentCoordinator({
-            agentId: this.agentId,
-            eventBus: this.eventBus,
-            memoryStore: this.memoryStore
-        });
-        this.memoryService = new AgentMemoryService_1.AgentMemoryService({
-            agentId: this.agentId,
-            memoryStore: this.memoryStore
-        });
-        // Connect lifecycle manager to event emitter for event-driven coordination
-        this.lifecycleManager.setStatusChangeCallback((status) => {
-            this.emitStatusChange(status);
-        });
+        this.coordinator = new AgentCoordinator_1.AgentCoordinator({ agentId: this.agentId, eventBus: this.eventBus, memoryStore: this.memoryStore });
+        this.memoryService = new AgentMemoryService_1.AgentMemoryService({ agentId: this.agentId, memoryStore: this.memoryStore });
+        // Initialize strategies (B1.2)
+        this.strategies = {
+            lifecycle: config.lifecycleStrategy ?? (0, adapters_1.createLifecycleAdapter)(this.lifecycleManager),
+            memory: config.memoryStrategy ?? (0, adapters_1.createMemoryAdapter)(this.memoryService, this.memoryStore, this.agentId),
+            learning: config.learningStrategy,
+            coordination: config.coordinationStrategy ?? (0, adapters_1.createCoordinationAdapter)(this.eventBus, this.agentId),
+        };
+        this.lifecycleManager.setStatusChangeCallback((status) => this.emitStatusChange(status));
         this.setupEventHandlers();
         this.setupLifecycleHooks();
     }
@@ -101,6 +58,11 @@ class BaseAgent extends events_1.EventEmitter {
         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})`);
+            }
             return;
         }
         // Guard: Skip if already initialized (ACTIVE or IDLE)
@@ -142,16 +104,17 @@ class BaseAgent extends events_1.EventEmitter {
                         // 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
                         console.warn(`[${this.agentId.id}] Learning enabled but memoryStore is not SwarmMemoryManager. ` +
                             `Learning features will be disabled. Expected SwarmMemoryManager, got ${this.memoryStore.constructor.name}`);
                     }
-                    // Initialize AgentDB if configured
-                    if (this.agentDBConfig) {
-                        await this.initializeAgentDB(this.agentDBConfig);
-                    }
                     // Initialize agent-specific components
                     await this.initializeComponents();
                     // Execute post-initialization hooks
@@ -182,7 +145,8 @@ class BaseAgent extends events_1.EventEmitter {
             // Validate task assignment
             this.validateTaskAssignment(assignment);
             this.currentTask = assignment;
-            this.lifecycleManager.markActive();
+            // 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);
@@ -195,41 +159,19 @@ class BaseAgent extends events_1.EventEmitter {
             const postTaskData = { assignment, result };
             await this.onPostTask(postTaskData);
             await this.executeHook('post-task', postTaskData);
-            // Update performance metrics
-            const duration = Date.now() - startTime;
+            // Update performance metrics and store result
             this.updatePerformanceMetrics(startTime, true);
-            // Capture experience for learning (Nightly-Learner integration)
-            await this.captureExperience({
-                taskId: assignment.id,
-                taskType: assignment.task.type || 'general',
-                input: assignment.task.payload || {},
-                output: result,
-                duration,
-                success: true,
-                metrics: this.extractTaskMetrics(result),
-            });
-            // Store task completion in memory
             await this.memoryService.storeTaskResult(assignment.id, result);
             this.currentTask = undefined;
-            this.lifecycleManager.markIdle();
+            // Phase 2 (B1.2): Use lifecycle strategy for status transitions
+            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.IDLE);
             return result;
         }
         catch (error) {
-            const duration = Date.now() - startTime;
             this.updatePerformanceMetrics(startTime, false);
-            // Capture failed experience for learning
-            await this.captureExperience({
-                taskId: assignment.id,
-                taskType: assignment.task.type || 'general',
-                input: assignment.task.payload || {},
-                output: {},
-                duration,
-                success: false,
-                error: error,
-                metrics: {},
-            });
             this.currentTask = undefined;
-            this.lifecycleManager.markError(`Task execution failed: ${error}`);
+            // 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,
@@ -245,49 +187,39 @@ class BaseAgent extends events_1.EventEmitter {
      */
     async terminate() {
         try {
-            // Use lifecycle manager's terminate method instead of manual status setting
             await this.lifecycleManager.terminate({
                 onPreTermination: async () => {
                     await this.executeHook('pre-termination');
-                    // Flush learning data before termination
-                    if (this.learningEngine && this.learningEngine.isEnabled()) {
-                        // ARCHITECTURE (v2.2.0): LearningEngine persists to unified memory.db
-                        // All data goes through SwarmMemoryManager to .agentic-qe/memory.db
-                        // No explicit flush needed - memoryStore handles persistence automatically
-                        console.info(`[${this.agentId.id}] Learning data persisted via SwarmMemoryManager (memory.db)`);
-                    }
-                    // Close AgentDB if enabled
-                    if (this.agentDB) {
-                        await this.agentDB.close();
-                        this.agentDB = undefined;
-                    }
-                    // Save current state
                     await this.saveState();
-                    // Clean up agent-specific resources
                     await this.cleanup();
-                    // Remove all event handlers from EventBus using coordinator
                     this.coordinator.clearAllHandlers();
                 },
                 onPostTermination: async () => {
                     await this.executeHook('post-termination');
                     this.emitEvent('agent.terminated', { agentId: this.agentId });
-                    // Remove all listeners from this agent (EventEmitter)
                     this.removeAllListeners();
                 }
             });
         }
         catch (error) {
-            this.lifecycleManager.transitionTo(types_1.AgentStatus.ERROR, `Termination failed: ${error}`);
+            await this.strategies.lifecycle.transitionTo(types_1.AgentStatus.ERROR, `Termination failed: ${error}`);
             throw error;
         }
     }
+    /**
+     * Get agent ID
+     */
+    getAgentId() {
+        return this.agentId;
+    }
     /**
      * Get current agent status and metrics
      */
     getStatus() {
+        // Phase 2 (B1.2): Use lifecycle strategy instead of direct manager call
         return {
             agentId: this.agentId,
-            status: this.lifecycleManager.getStatus(),
+            status: this.strategies.lifecycle.getStatus(),
             currentTask: this.currentTask?.id,
             capabilities: Array.from(this.capabilities.keys()),
             performanceMetrics: { ...this.performanceMetrics }
@@ -302,9 +234,15 @@ class BaseAgent extends events_1.EventEmitter {
      * Use: await agent.waitForStatus('ready')
      */
     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.lifecycleManager.getStatus() === status) {
+            if (this.strategies.lifecycle.getStatus() === status) {
                 return resolve();
             }
             const timer = setTimeout(() => {
@@ -327,7 +265,13 @@ class BaseAgent extends events_1.EventEmitter {
      * Use: await agent.waitForReady()
      */
     async waitForReady(timeout = 10000) {
-        const currentStatus = this.lifecycleManager.getStatus();
+        // 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
         }
@@ -381,6 +325,37 @@ class BaseAgent extends events_1.EventEmitter {
     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
      */
@@ -436,74 +411,23 @@ class BaseAgent extends events_1.EventEmitter {
         };
     }
     /**
-     * Initialize AgentDB integration for distributed coordination
-     *
-     * @deprecated v2.2.0 - AgentDB is deprecated. All persistence now goes through
-     * SwarmMemoryManager to the unified .agentic-qe/memory.db database.
-     * Use memoryStore methods instead. This method will be removed in v3.0.0.
-     *
-     * @param config AgentDB configuration
+     * @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) {
-        if (this.agentDB) {
-            console.warn(`[${this.agentId.id}] AgentDB already initialized`);
-            return;
-        }
-        try {
-            this.agentDB = (0, AgentDBManager_1.createAgentDBManager)(config);
-            await this.agentDB.initialize();
-            this.emitEvent('agent.agentdb.enabled', {
-                agentId: this.agentId,
-                config,
-            });
-            console.info(`[${this.agentId.id}] AgentDB integration enabled`, {
-                quicSync: config.enableQUICSync || false,
-                learning: config.enableLearning || false,
-                reasoning: config.enableReasoning || false,
-            });
-        }
-        catch (error) {
-            console.error(`[${this.agentId.id}] Failed to initialize AgentDB:`, error);
-            throw error;
-        }
+    async initializeAgentDB(_config) {
+        console.warn(`[${this.agentId.id}] AgentDB is DEPRECATED and will be removed in v3.0.0`);
     }
     /**
-     * Get AgentDB integration status
+     * @deprecated v2.2.0 - Use learning strategy instead.
      */
     async getAgentDBStatus() {
-        if (!this.agentDB)
-            return null;
-        try {
-            const stats = await this.agentDB.getStats();
-            return {
-                enabled: true,
-                stats,
-            };
-        }
-        catch (error) {
-            return {
-                enabled: true,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
+        return null;
     }
     /**
-     * Check if AgentDB integration is available
+     * @deprecated v2.2.0 - Returns false, AgentDB removed.
      */
     hasAgentDB() {
-        return this.agentDB !== undefined;
-    }
-    /**
-     * Check if AgentDB is using a real adapter (vs mock)
-     * @returns true if using real AgentDB, false if mock
-     */
-    isRealAgentDB() {
-        if (!this.agentDB)
-            return false;
-        // Check adapter type or test mode flags
-        const isTestMode = process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID !== undefined;
-        const useMock = process.env.AQE_USE_MOCK_AGENTDB === 'true';
-        return !isTestMode && !useMock;
+        return false;
     }
     /**
      * Start the agent (idempotent - safe to call multiple times)
@@ -580,407 +504,159 @@ class BaseAgent extends events_1.EventEmitter {
         this.eventBus.emit('agent.message', message);
     }
     // ============================================================================
-    // Memory Operations
+    // 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
      */
     async storeMemory(key, value, ttl) {
-        if (!this.memoryStore) {
-            console.warn(`[WARN] Memory store not available for ${this.agentId.id}`);
-            return;
+        // 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);
+        }
+        else {
+            // Fallback for custom strategies
+            await memoryStrategy.store(key, value, { ttl, namespace: this.agentId.type });
         }
-        // Standardized namespace: aqe/{agentType}/{key}
-        const namespacedKey = `aqe/${this.agentId.type}/${key}`;
-        await this.memoryStore.store(namespacedKey, value, ttl);
     }
     /**
      * Retrieve data from memory
+     * Phase 2 (B1.2): Delegates to memory strategy with aqe/{agentType}/{key} namespace
      */
     async retrieveMemory(key) {
-        if (!this.memoryStore) {
-            console.warn(`[WARN] Memory store not available for ${this.agentId.id}`);
-            return null;
+        // 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}`);
         }
-        // Standardized namespace: aqe/{agentType}/{key}
-        const namespacedKey = `aqe/${this.agentId.type}/${key}`;
-        return await this.memoryStore.retrieve(namespacedKey);
     }
     /**
      * 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) {
-        if (!this.memoryStore) {
-            console.warn(`[WARN] Memory store not available for ${this.agentId.id}`);
-            return;
+        // 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);
+        }
+        else {
+            // Fallback for custom strategies
+            await memoryStrategy.storeShared(this.agentId.type, key, value, { ttl });
         }
-        // Standardized namespace: aqe/shared/{agentType}/{key}
-        const sharedKey = `aqe/shared/${this.agentId.type}/${key}`;
-        await this.memoryStore.store(sharedKey, 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) {
-        if (!this.memoryStore) {
-            console.warn(`[WARN] Memory store not available for ${this.agentId.id}`);
-            return null;
-        }
-        // Standardized namespace: aqe/shared/{agentType}/{key}
-        const sharedKey = `aqe/shared/${agentType}/${key}`;
-        return await this.memoryStore.retrieve(sharedKey);
+        // 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
-     * Runs verification checks using VerificationHookManager
-     * Integrates AgentDB for context loading via vector search
-     * @param data Pre-task hook data including task assignment
+     * Delegates to lifecycle strategy for pre-task processing
      */
     async onPreTask(data) {
-        try {
-            // Track task start time for PerformanceTracker
-            this.taskStartTime = Date.now();
-            // ACTUAL AgentDB Integration: Load context from vector search
-            if (this.agentDB) {
-                try {
-                    const searchStart = Date.now();
-                    // Generate query embedding from task
-                    const taskQuery = JSON.stringify({
-                        type: data.assignment.task.type,
-                        description: data.assignment.task.description || '',
-                        requirements: data.assignment.task.requirements || {}
-                    });
-                    // Generate embedding using consolidated utility
-                    const queryEmbedding = (0, EmbeddingGenerator_js_1.generateEmbedding)(taskQuery);
-                    // Retrieve relevant context from AgentDB
-                    const retrievalResult = await this.agentDB.retrieve(queryEmbedding, {
-                        domain: `agent:${this.agentId.type}:tasks`,
-                        k: 5,
-                        useMMR: true,
-                        synthesizeContext: true,
-                        minConfidence: 0.6,
-                        metric: 'cosine'
-                    });
-                    const searchTime = Date.now() - searchStart;
-                    const isReal = this.isRealAgentDB();
-                    const adapterType = isReal ? 'real AgentDB' : 'mock adapter';
-                    // Enrich context with retrieved patterns
-                    if (retrievalResult.memories.length > 0) {
-                        const enrichedContext = {
-                            ...data.context,
-                            agentDBContext: retrievalResult.context,
-                            relevantPatterns: retrievalResult.patterns || [],
-                            similarTasks: retrievalResult.memories.map((m) => {
-                                const patternData = JSON.parse(m.pattern_data);
-                                return {
-                                    taskType: patternData.taskType,
-                                    success: patternData.success,
-                                    accuracy: patternData.accuracy,
-                                    executionTime: patternData.executionTime,
-                                    similarity: m.similarity,
-                                    confidence: m.confidence
-                                };
-                            })
-                        };
-                        data.context = enrichedContext;
-                        console.info(`[${this.agentId.id}] Loaded ${retrievalResult.memories.length} patterns from ${adapterType} ` +
-                            `(${searchTime}ms, ${retrievalResult.metadata.cacheHit ? 'cache hit' : 'cache miss'})`);
-                        // Log top similar task
-                        if (retrievalResult.memories.length > 0 && isReal) {
-                            const topMatch = retrievalResult.memories[0];
-                            console.info(`[${this.agentId.id}] 🎯 Top match: similarity=${topMatch.similarity.toFixed(3)}, ` +
-                                `confidence=${topMatch.confidence.toFixed(3)}`);
-                        }
-                    }
-                    else {
-                        console.info(`[${this.agentId.id}] No relevant patterns found in ${adapterType} (${searchTime}ms)`);
-                    }
-                }
-                catch (agentDBError) {
-                    console.warn(`[${this.agentId.id}] AgentDB retrieval failed:`, agentDBError);
-                    // Don't fail task if AgentDB retrieval fails
-                }
-            }
-            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
-            });
-        }
-        catch (error) {
-            console.error(`Pre-task hook failed for agent ${this.agentId.id}:`, error);
-            throw error;
+        this.taskStartTime = Date.now();
+        // Delegate to lifecycle strategy if available
+        if (this.strategies.lifecycle.onPreTask) {
+            await this.strategies.lifecycle.onPreTask(data);
+        }
+        // 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
+        });
     }
     /**
      * Post-task hook - called after task execution
-     * Runs validation checks using VerificationHookManager
-     * Integrates AgentDB for pattern storage and neural training
-     * @param data Post-task hook data including result
+     * Delegates to lifecycle and learning strategies
      */
     async onPostTask(data) {
-        try {
-            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(', ')}`);
-            }
-            // ACTUAL AgentDB Integration: Store execution patterns for future learning
-            if (this.agentDB) {
-                try {
-                    const startTime = Date.now();
-                    const executionTime = this.taskStartTime ? Date.now() - this.taskStartTime : 0;
-                    // Create pattern data
-                    const patternData = {
-                        taskType: data.assignment.task.type,
-                        taskDescription: data.assignment.task.description || '',
-                        result: {
-                            success: validationResult.valid,
-                            accuracy: validationResult.accuracy,
-                            executionTime,
-                            validations: validationResult.validations
-                        },
-                        context: data.assignment.task.context || {},
-                        timestamp: Date.now()
-                    };
-                    // Generate embedding using consolidated utility
-                    const embedding = (0, EmbeddingGenerator_js_1.generateEmbedding)(JSON.stringify(patternData));
-                    // Store pattern in AgentDB
-                    const pattern = {
-                        id: `${this.agentId.id}-task-${data.assignment.id}`,
-                        type: 'experience',
-                        domain: `agent:${this.agentId.type}:tasks`,
-                        pattern_data: JSON.stringify({
-                            taskType: patternData.taskType,
-                            taskDescription: patternData.taskDescription,
-                            success: patternData.result.success,
-                            accuracy: patternData.result.accuracy,
-                            executionTime: patternData.result.executionTime,
-                            timestamp: patternData.timestamp
-                        }),
-                        confidence: validationResult.valid ? validationResult.accuracy : 0.5,
-                        usage_count: 1,
-                        success_count: validationResult.valid ? 1 : 0,
-                        created_at: Date.now(),
-                        last_used: Date.now()
-                    };
-                    const patternId = await this.agentDB.store(pattern);
-                    const storeTime = Date.now() - startTime;
-                    const isReal = this.isRealAgentDB();
-                    const adapterType = isReal ? 'AgentDB' : 'mock adapter';
-                    console.info(`[${this.agentId.id}] Stored pattern in ${adapterType}: ${patternId} (${storeTime}ms)`);
-                    // ACTUAL Neural training integration if learning is enabled
-                    if (this.agentDBConfig?.enableLearning) {
-                        try {
-                            // Trigger incremental training every N patterns
-                            const stats = await this.agentDB.getStats();
-                            if (stats.totalPatterns && stats.totalPatterns % 100 === 0) {
-                                console.info(`[${this.agentId.id}] 🧠 Triggering ACTUAL neural training (${stats.totalPatterns} patterns)`);
-                                const trainingStart = Date.now();
-                                const trainingMetrics = await this.agentDB.train({
-                                    epochs: 10,
-                                    batchSize: 32,
-                                    validationSplit: 0.2
-                                });
-                                const trainingTime = Date.now() - trainingStart;
-                                console.info(`[${this.agentId.id}] ✅ Neural training COMPLETE: ` +
-                                    `loss=${trainingMetrics.loss.toFixed(4)}, ` +
-                                    `duration=${trainingTime}ms (${trainingMetrics.epochs} epochs)`);
-                            }
-                        }
-                        catch (trainingError) {
-                            console.warn(`[${this.agentId.id}] Neural training failed:`, trainingError);
-                        }
-                    }
-                    // ACTUAL QUIC sync if enabled (automatic via AgentDB)
-                    if (this.agentDBConfig?.enableQUICSync) {
-                        console.info(`[${this.agentId.id}] 🚀 QUIC sync active (<1ms to ${this.agentDBConfig.syncPeers?.length || 0} peers)`);
-                    }
-                }
-                catch (agentDBError) {
-                    console.warn(`[${this.agentId.id}] AgentDB operation failed:`, agentDBError);
-                    // Don't fail task if AgentDB operations fail
-                }
-            }
-            // Q-learning integration: Learn from task execution
-            if (this.learningEngine && this.learningEngine.isEnabled()) {
-                try {
-                    const learningOutcome = await this.learningEngine.learnFromExecution(data.assignment.task, data.result);
-                    // Log learning progress
-                    if (learningOutcome.improved) {
-                        console.info(`[Learning] Agent ${this.agentId.id} improved by ${learningOutcome.improvementRate.toFixed(2)}%`);
-                    }
-                }
-                catch (learningError) {
-                    console.error(`Learning engine error:`, learningError);
-                    // Don't fail task due to learning errors
-                }
-            }
-            // Record performance snapshot if PerformanceTracker is enabled
-            if (this.performanceTracker && this.taskStartTime) {
-                const executionTime = Date.now() - this.taskStartTime;
-                const successRate = this.performanceMetrics.tasksCompleted /
-                    Math.max(1, this.performanceMetrics.tasksCompleted + this.performanceMetrics.errorCount);
-                await this.performanceTracker.recordSnapshot({
-                    metrics: {
-                        tasksCompleted: this.performanceMetrics.tasksCompleted,
-                        successRate: Math.min(1.0, Math.max(0.0, successRate || 1.0)),
-                        averageExecutionTime: this.performanceMetrics.averageExecutionTime,
-                        errorRate: this.performanceMetrics.errorCount /
-                            Math.max(1, this.performanceMetrics.tasksCompleted + this.performanceMetrics.errorCount),
-                        userSatisfaction: validationResult.valid ? 0.9 : 0.5,
-                        resourceEfficiency: executionTime < 10000 ? 0.9 : 0.7 // Simple heuristic
-                    },
-                    trends: [] // Empty trends array for new snapshot
-                });
-            }
-            // Capture experience for Dream Engine (Nightly-Learner Phase 2)
-            // This enables real agent execution data to flow into the concept graph
-            try {
-                const executionTime = this.taskStartTime ? Date.now() - this.taskStartTime : 0;
-                const experienceCapture = await ExperienceCapture_1.ExperienceCapture.getSharedInstance();
-                const executionEvent = {
-                    agentId: this.agentId.id,
-                    agentType: this.agentId.type,
+        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(', ')}`);
+        }
+        // Delegate to lifecycle strategy
+        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,
-                    taskType: data.assignment.task.type,
-                    input: data.assignment.task.payload || {},
-                    output: data.result || {},
-                    duration: executionTime,
-                    success: validationResult.valid,
-                    metrics: {
-                        quality_score: validationResult.valid ? 0.85 : 0.3,
-                        coverage_delta: 0, // Can be enhanced with actual coverage data
-                    },
-                    timestamp: new Date(),
-                };
-                await experienceCapture.captureExecution(executionEvent);
-            }
-            catch (captureError) {
-                // Don't fail task due to experience capture errors
-                console.warn(`[${this.agentId.id}] Experience capture failed:`, captureError);
-            }
-            this.emitEvent('hook.post-task.completed', {
-                agentId: this.agentId,
-                result: validationResult
+                    accuracy: validationResult.accuracy,
+                    metrics: this.extractTaskMetrics(data.result)
+                }
             });
         }
-        catch (error) {
-            console.error(`Post-task hook failed for agent ${this.agentId.id}:`, error);
-            // Don't throw - allow task to complete even if validation has issues
-        }
+        this.emitEvent('hook.post-task.completed', {
+            agentId: this.agentId,
+            result: validationResult
+        });
     }
     /**
      * Task error hook - called when task execution fails
-     * Handles error recovery and reporting
-     * Integrates AgentDB for error pattern analysis
-     * @param data Error hook data including error details
+     * Delegates to lifecycle and learning strategies
      */
     async onTaskError(data) {
-        try {
-            // Log error details
-            console.error(`Task error for agent ${this.agentId.id}:`, {
-                taskId: data.assignment.id,
-                taskType: data.assignment.task.type,
-                error: data.error.message,
-                stack: data.error.stack
-            });
-            // Store error in memory for analysis
-            await this.storeMemory(`error:${data.assignment.id}`, {
-                error: {
-                    message: data.error.message,
-                    stack: data.error.stack,
-                    name: data.error.name
-                },
-                assignment: {
-                    id: data.assignment.id,
-                    taskType: data.assignment.task.type
-                },
-                timestamp: new Date(),
-                agentId: this.agentId.id
-            });
-            // ACTUAL AgentDB Integration: Store error patterns for failure analysis
-            if (this.agentDB) {
-                try {
-                    const storeStart = Date.now();
-                    const errorPattern = {
-                        taskType: data.assignment.task.type,
-                        errorType: data.error.name,
-                        errorMessage: data.error.message,
-                        errorStack: data.error.stack?.split('\n').slice(0, 5).join('\n'), // Truncate stack
-                        context: data.assignment.task.context || {},
-                        timestamp: Date.now()
-                    };
-                    // Generate embedding for error pattern
-                    const embedding = (0, EmbeddingGenerator_js_1.generateEmbedding)(JSON.stringify(errorPattern));
-                    // Store error pattern in AgentDB for failure analysis
-                    const pattern = {
-                        id: `${this.agentId.id}-error-${data.assignment.id}`,
-                        type: 'error',
-                        domain: `agent:${this.agentId.type}:errors`,
-                        pattern_data: JSON.stringify({
-                            taskType: errorPattern.taskType,
-                            errorType: errorPattern.errorType,
-                            errorMessage: errorPattern.errorMessage,
-                            timestamp: errorPattern.timestamp
-                        }),
-                        confidence: 0.8, // Errors are high-confidence negative patterns
-                        usage_count: 1,
-                        success_count: 0, // Errors are failures
-                        created_at: Date.now(),
-                        last_used: Date.now()
-                    };
-                    const errorPatternId = await this.agentDB.store(pattern);
-                    const storeTime = Date.now() - storeStart;
-                    const isReal = this.isRealAgentDB();
-                    const adapterType = isReal ? 'AgentDB' : 'mock adapter';
-                    console.info(`[${this.agentId.id}] Stored error pattern in ${adapterType}: ${errorPatternId} ` +
-                        `(${storeTime}ms, for failure analysis)`);
-                }
-                catch (agentDBError) {
-                    console.warn(`[${this.agentId.id}] AgentDB error storage failed:`, agentDBError);
+        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
+        });
+        // Delegate to lifecycle strategy
+        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
                 }
-            }
-            // Record failure in PerformanceTracker if enabled
-            if (this.performanceTracker && this.taskStartTime) {
-                const _executionTime = Date.now() - this.taskStartTime;
-                const successRate = this.performanceMetrics.tasksCompleted /
-                    Math.max(1, this.performanceMetrics.tasksCompleted + this.performanceMetrics.errorCount);
-                await this.performanceTracker.recordSnapshot({
-                    metrics: {
-                        tasksCompleted: this.performanceMetrics.tasksCompleted,
-                        successRate: Math.min(1.0, Math.max(0.0, successRate)),
-                        averageExecutionTime: this.performanceMetrics.averageExecutionTime,
-                        errorRate: (this.performanceMetrics.errorCount + 1) /
-                            Math.max(1, this.performanceMetrics.tasksCompleted + this.performanceMetrics.errorCount + 1),
-                        userSatisfaction: 0.3, // Low satisfaction on error
-                        resourceEfficiency: 0.5
-                    },
-                    trends: [] // Empty trends array for error snapshot
-                });
-            }
-            this.emitEvent('hook.task-error.completed', {
-                agentId: this.agentId,
-                error: data.error
-            }, 'high');
-        }
-        catch (error) {
-            console.error(`Task error hook failed for agent ${this.agentId.id}:`, error);
-            // Swallow this error to prevent recursive error handling
+            });
         }
+        this.emitEvent('hook.task-error.completed', {
+            agentId: this.agentId,
+            error: data.error
+        }, 'high');
     }
     async executeHook(hookName, data) {
         try {
@@ -1015,8 +691,9 @@ class BaseAgent extends events_1.EventEmitter {
     }
     setupLifecycleHooks() {
         // Setup default lifecycle behavior
-        this.on('error', (error) => {
-            this.lifecycleManager.transitionTo(types_1.AgentStatus.ERROR, `Error event: ${error}`);
+        // 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}`);
             this.emitEvent('agent.error', { agentId: this.agentId, error });
         });
     }
@@ -1045,43 +722,6 @@ class BaseAgent extends events_1.EventEmitter {
         }
         this.performanceMetrics.lastActivity = new Date();
     }
-    /**
-     * Capture execution experience for Nightly-Learner system
-     * Automatically sends task execution data to ExperienceCapture singleton
-     */
-    async captureExperience(data) {
-        try {
-            // Get the shared ExperienceCapture instance
-            const capture = await ExperienceCapture_1.ExperienceCapture.getSharedInstance();
-            // Build the execution event
-            const event = {
-                agentId: this.agentId.id,
-                agentType: this.agentId.type,
-                taskId: data.taskId,
-                taskType: data.taskType,
-                input: data.input,
-                output: data.output,
-                duration: data.duration,
-                success: data.success,
-                error: data.error,
-                metrics: data.metrics,
-                timestamp: new Date(),
-            };
-            // Capture the execution
-            await capture.captureExecution(event);
-            // Emit event for monitoring
-            this.emit('experience:captured', {
-                agentId: this.agentId.id,
-                taskId: data.taskId,
-                success: data.success,
-                duration: data.duration,
-            });
-        }
-        catch (error) {
-            // Don't let capture failures affect task execution
-            console.warn(`[${this.agentId.id}] Failed to capture experience:`, error);
-        }
-    }
     /**
      * Extract metrics from task result for learning
      * Override in subclasses to provide agent-specific metrics
@@ -1108,48 +748,12 @@ class BaseAgent extends events_1.EventEmitter {
         }
         return metrics;
     }
-    async storeTaskResult(taskId, result) {
-        await this.storeMemory(`task:${taskId}:result`, {
-            result,
-            timestamp: new Date(),
-            agentId: this.agentId.id
-        });
-    }
-    async restoreState() {
-        try {
-            const state = await this.retrieveMemory('state');
-            if (state) {
-                this.performanceMetrics = { ...this.performanceMetrics, ...state.performanceMetrics };
-            }
-        }
-        catch (error) {
-            // State restoration is optional
-            console.warn(`Could not restore state for agent ${this.agentId.id}:`, error);
-        }
-    }
+    // State management delegated to memoryService (used in initialize/terminate)
     async saveState() {
-        try {
-            await this.storeMemory('state', {
-                performanceMetrics: this.performanceMetrics,
-                timestamp: new Date()
-            });
-        }
-        catch (error) {
-            console.error(`Could not save state for agent ${this.agentId.id}:`, error);
-        }
-    }
-    async reportStatus(status) {
-        try {
-            await this.storeSharedMemory('status', {
-                agentId: this.agentId.id,
-                status,
-                timestamp: new Date(),
-                metrics: this.performanceMetrics
-            });
-        }
-        catch (error) {
-            console.warn(`Could not report status for agent ${this.agentId.id}:`, error);
-        }
+        await this.memoryService.saveState({
+            performanceMetrics: this.performanceMetrics,
+            timestamp: new Date()
+        });
     }
     generateAgentId(type) {
         return `${type}-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`;