agentic-qe 2.5.8 → 2.5.9

package/dist/agents/CoverageAnalyzerAgent.d.ts

@@ -1,16 +1,14 @@
 /**
  * CoverageAnalyzerAgent - O(log n) coverage optimization and gap analysis
  * Phase 2 (v1.1.0) - Enhanced with Learning Capabilities
+ * Phase 0.5 (v2.5.9) - Migrated to BaseAgent for RuVector integration
  *
  * Implements sublinear algorithms from SPARC Phase 2 Section 3 with continuous
  * improvement through reinforcement learning and performance tracking.
  */
-import { EventEmitter } from 'events';
-import { AgentId, AgentStatus, TaskSpec, TestSuite, CoverageReport, MemoryStore } from '../types';
-export interface CoverageAnalyzerConfig {
-    id: AgentId;
-    memoryStore?: MemoryStore;
-    enableLearning?: boolean;
+import { TestSuite, CoverageReport, QETask } from '../types';
+import { BaseAgent, BaseAgentConfig } from './BaseAgent';
+export interface CoverageAnalyzerConfig extends BaseAgentConfig {
     enablePatterns?: boolean;
     targetImprovement?: number;
     improvementPeriodDays?: number;
@@ -68,35 +66,34 @@ export interface CoverageOptimizationResult {
         patternsApplied: number;
     };
 }
-export declare class CoverageAnalyzerAgent extends EventEmitter {
-    private id;
-    private status;
-    private memoryStore?;
-    private logger;
+export declare class CoverageAnalyzerAgent extends BaseAgent {
     private sublinearCore;
     private coverageEngine;
     private gapDetector;
-    private learningEngine?;
-    private performanceTracker?;
     private improvementLoop?;
     private reasoningBank?;
     private experienceCapture?;
     private cachedPatterns;
     private agentDB?;
-    private config;
+    private coverageConfig;
+    private coverageLogger;
     constructor(config: CoverageAnalyzerConfig);
-    constructor(id: AgentId, memoryStore?: MemoryStore);
-    private initializeLearning;
-    initialize(): Promise<void>;
-    executeTask(task: TaskSpec): Promise<CoverageOptimizationResult>;
-    terminate(): Promise<void>;
-    getStatus(): {
-        agentId: AgentId;
-        status: AgentStatus;
-        capabilities: string[];
+    protected initializeComponents(): Promise<void>;
+    protected performTask(task: QETask): Promise<any>;
+    protected loadKnowledge(): Promise<void>;
+    protected cleanup(): Promise<void>;
+    /**
+     * Get coverage-specific status including optimization metrics
+     */
+    getCoverageStatus(): {
         performance: any;
         learning?: any;
+        ruvector: {
+            enabled: boolean;
+            cacheHitRate: number;
+        };
     };
+    private getAgentIdStr;
     /**
      * Optimize coverage using sublinear algorithms with learning enhancement
      * Based on SPARC Phase 2 Algorithm: OptimizeCoverageSublinear

package/dist/agents/CoverageAnalyzerAgent.d.ts.map

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

package/dist/agents/CoverageAnalyzerAgent.js

@@ -2,156 +2,101 @@
 /**
  * CoverageAnalyzerAgent - O(log n) coverage optimization and gap analysis
  * Phase 2 (v1.1.0) - Enhanced with Learning Capabilities
+ * Phase 0.5 (v2.5.9) - Migrated to BaseAgent for RuVector integration
  *
  * Implements sublinear algorithms from SPARC Phase 2 Section 3 with continuous
  * improvement through reinforcement learning and performance tracking.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoverageAnalyzerAgent = void 0;
-const events_1 = require("events");
 const SecureRandom_js_1 = require("../utils/SecureRandom.js");
-const types_1 = require("../types");
-const LearningEngine_1 = require("../learning/LearningEngine");
-const PerformanceTracker_1 = require("../learning/PerformanceTracker");
+const BaseAgent_1 = require("./BaseAgent");
 const ImprovementLoop_1 = require("../learning/ImprovementLoop");
 const QEReasoningBank_1 = require("../reasoning/QEReasoningBank");
 const Logger_1 = require("../utils/Logger");
 const ExperienceCapture_1 = require("../learning/capture/ExperienceCapture");
 // ============================================================================
-// Main Agent Class
+// Main Agent Class - Now extends BaseAgent for RuVector integration
 // ============================================================================
-class CoverageAnalyzerAgent extends events_1.EventEmitter {
-    constructor(configOrId, memoryStore) {
-        super();
-        this.status = types_1.AgentStatus.INITIALIZING;
+class CoverageAnalyzerAgent extends BaseAgent_1.BaseAgent {
+    constructor(config) {
+        super(config);
         // Cached patterns for confidence boosting
         this.cachedPatterns = [];
-        // Handle both constructor signatures
-        if (typeof configOrId === 'object' && 'id' in configOrId && !('id' in configOrId && typeof configOrId.id === 'string')) {
-            // It's a CoverageAnalyzerConfig
-            this.config = configOrId;
-            this.id = this.config.id;
-            this.memoryStore = this.config.memoryStore;
-        }
-        else {
-            // It's an AgentId (backward compatibility)
-            this.id = configOrId;
-            this.memoryStore = memoryStore;
-            this.config = {
-                id: configOrId,
-                memoryStore,
-                enableLearning: true,
-                enablePatterns: true,
-                targetImprovement: 0.20,
-                improvementPeriodDays: 30
-            };
-        }
-        this.logger = Logger_1.Logger.getInstance();
+        this.coverageLogger = Logger_1.Logger.getInstance();
+        this.coverageConfig = {
+            enablePatterns: config.enablePatterns !== false,
+            targetImprovement: config.targetImprovement || 0.20,
+            improvementPeriodDays: config.improvementPeriodDays || 30,
+        };
         // Initialize core engines
         this.sublinearCore = new SublinearOptimizer();
         this.coverageEngine = new CoverageEngine();
         this.gapDetector = new GapDetector();
-        // Initialize learning components if enabled
-        this.initializeLearning();
-    }
-    // ============================================================================
-    // Learning Initialization
-    // ============================================================================
-    initializeLearning() {
-        if (this.config.enableLearning !== false && this.memoryStore) {
-            const agentIdStr = typeof this.id === 'string' ? this.id : this.id.id;
-            const memoryManager = this.memoryStore;
-            this.learningEngine = new LearningEngine_1.LearningEngine(agentIdStr, memoryManager);
-            this.performanceTracker = new PerformanceTracker_1.PerformanceTracker(agentIdStr, memoryManager);
-            this.improvementLoop = new ImprovementLoop_1.ImprovementLoop(agentIdStr, memoryManager, this.learningEngine, this.performanceTracker);
-        }
-        if (this.config.enablePatterns !== false) {
+        // Initialize reasoning bank if patterns enabled
+        if (this.coverageConfig.enablePatterns) {
             this.reasoningBank = new QEReasoningBank_1.QEReasoningBank();
         }
     }
     // ============================================================================
-    // Agent Lifecycle
+    // BaseAgent Abstract Method Implementations
     // ============================================================================
-    async initialize() {
-        try {
-            this.status = types_1.AgentStatus.INITIALIZING;
-            // Initialize optimization engines
-            await this.sublinearCore.initialize();
-            await this.coverageEngine.initialize();
-            await this.gapDetector.initialize();
-            // Initialize learning components
-            if (this.learningEngine) {
-                await this.learningEngine.initialize();
-            }
-            if (this.performanceTracker) {
-                await this.performanceTracker.initialize();
-            }
-            if (this.improvementLoop) {
-                await this.improvementLoop.initialize();
-            }
-            // Load historical coverage patterns
-            await this.loadCoveragePatterns();
-            // Load learned gap detection patterns
-            await this.loadGapPatterns();
-            // Initialize ExperienceCapture for Nightly-Learner integration
-            this.experienceCapture = await ExperienceCapture_1.ExperienceCapture.getSharedInstance();
-            this.logger?.info('[CoverageAnalyzer] ExperienceCapture initialized for Nightly-Learner');
-            // Load and cache patterns for confidence boosting at task start
-            await this.loadAndCachePatternsForConfidence();
-            // Store initialization state
-            if (this.memoryStore) {
-                await this.memoryStore.set('coverage-analyzer-initialized', true, 'agents');
-            }
-            this.status = types_1.AgentStatus.IDLE;
-            this.emit('agent.initialized', { agentId: this.id });
-            this.logger?.info(`CoverageAnalyzerAgent initialized with learning: ${!!this.learningEngine}, patterns cached: ${this.cachedPatterns.length}`);
-        }
-        catch (error) {
-            this.status = types_1.AgentStatus.ERROR;
-            this.emit('agent.error', { agentId: this.id, error });
-            throw error;
-        }
-    }
-    async executeTask(task) {
+    async initializeComponents() {
+        // Initialize optimization engines
+        await this.sublinearCore.initialize();
+        await this.coverageEngine.initialize();
+        await this.gapDetector.initialize();
+        // Initialize improvement loop if learning is enabled
+        if (this.learningEngine && this.performanceTracker) {
+            this.improvementLoop = new ImprovementLoop_1.ImprovementLoop(this.getAgentIdStr(), this.memoryStore, this.learningEngine, this.performanceTracker);
+            await this.improvementLoop.initialize();
+        }
+        // Initialize ExperienceCapture for Nightly-Learner integration
+        this.experienceCapture = await ExperienceCapture_1.ExperienceCapture.getSharedInstance();
+        this.coverageLogger?.info('[CoverageAnalyzer] ExperienceCapture initialized for Nightly-Learner');
+        // Load historical patterns
+        await this.loadCoveragePatterns();
+        await this.loadGapPatterns();
+        await this.loadAndCachePatternsForConfidence();
+    }
+    async performTask(task) {
         const request = task.payload;
         return await this.optimizeCoverageSublinear(request);
     }
-    async terminate() {
-        try {
-            this.status = types_1.AgentStatus.STOPPING;
-            // Save learned patterns
-            await this.saveCoveragePatterns();
-            await this.saveGapPatterns();
-            // Stop improvement loop if running
-            if (this.improvementLoop?.isActive()) {
-                await this.improvementLoop.stop();
-            }
-            // Cleanup resources
-            await this.sublinearCore.cleanup();
-            await this.coverageEngine.cleanup();
-            await this.gapDetector.cleanup();
-            this.status = types_1.AgentStatus.STOPPED;
-            this.emit('agent.terminated', { agentId: this.id });
-        }
-        catch (error) {
-            this.status = types_1.AgentStatus.ERROR;
-            throw error;
-        }
+    async loadKnowledge() {
+        // Load coverage-specific knowledge
+        await this.loadCoveragePatterns();
+        await this.loadGapPatterns();
     }
-    getStatus() {
+    async cleanup() {
+        // Save learned patterns
+        await this.saveCoveragePatterns();
+        await this.saveGapPatterns();
+        // Stop improvement loop if running
+        if (this.improvementLoop?.isActive()) {
+            await this.improvementLoop.stop();
+        }
+        // Cleanup engines
+        await this.sublinearCore.cleanup();
+        await this.coverageEngine.cleanup();
+        await this.gapDetector.cleanup();
+    }
+    // ============================================================================
+    // Public Methods - Coverage-specific
+    // ============================================================================
+    /**
+     * Get coverage-specific status including optimization metrics
+     */
+    getCoverageStatus() {
         const status = {
-            agentId: this.id,
-            status: this.status,
-            capabilities: [
-                'coverage-optimization',
-                'gap-detection',
-                'sublinear-analysis',
-                'learning-enabled'
-            ],
             performance: {
                 optimizationsCompleted: this.sublinearCore.getOptimizationCount(),
                 averageOptimizationTime: this.sublinearCore.getAverageTime(),
                 lastOptimizationRatio: this.sublinearCore.getLastOptimizationRatio()
+            },
+            ruvector: {
+                enabled: this.hasRuVectorCache(),
+                cacheHitRate: this.getCacheHitRate()
             }
         };
         if (this.learningEngine && this.performanceTracker) {
@@ -165,6 +110,14 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
         }
         return status;
     }
+    // Helper to get agent ID string
+    getAgentIdStr() {
+        const agentId = super.getAgentId();
+        return typeof agentId === 'string' ? agentId : agentId.id;
+    }
+    // ============================================================================
+    // Agent Lifecycle (handled by BaseAgent)
+    // ============================================================================
     // ============================================================================
     // Core Coverage Optimization - SPARC Algorithm 3.1 + Learning
     // ============================================================================
@@ -175,7 +128,6 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
     async optimizeCoverageSublinear(request) {
         const startTime = Date.now();
         try {
-            this.status = types_1.AgentStatus.ACTIVE;
             // Get learned strategy recommendation if available
             let strategy = 'johnson-lindenstrauss-sublinear';
             if (this.learningEngine) {
@@ -189,7 +141,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                 });
                 if (recommendation.confidence > 0.7) {
                     strategy = recommendation.strategy;
-                    this.logger?.info(`Using learned strategy: ${strategy} (confidence: ${recommendation.confidence})`);
+                    this.coverageLogger?.info(`Using learned strategy: ${strategy} (confidence: ${recommendation.confidence})`);
                 }
             }
             // Phase 1: Build Coverage Matrix
@@ -243,11 +195,9 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
             };
             // Track performance and learn from execution
             await this.trackAndLearn(request, result, executionTime);
-            this.status = types_1.AgentStatus.IDLE;
             return result;
         }
         catch (error) {
-            this.status = types_1.AgentStatus.ERROR;
             // Learn from failure if learning is enabled
             if (this.learningEngine) {
                 await this.learningEngine.learnFromExecution({ id: 'coverage-optimization', type: 'coverage-analysis' }, { success: false, error: error.message });
@@ -308,24 +258,24 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                 if (result.memories.length > 0) {
                     // Calculate likelihood from historical gap patterns
                     const avgLikelihood = result.memories.reduce((sum, m) => sum + m.confidence, 0) / result.memories.length;
-                    this.logger?.debug(`[CoverageAnalyzer] ✅ AgentDB HNSW search: ${(avgLikelihood * 100).toFixed(1)}% likelihood ` +
+                    this.coverageLogger?.debug(`[CoverageAnalyzer] ✅ AgentDB HNSW search: ${(avgLikelihood * 100).toFixed(1)}% likelihood ` +
                         `(${searchTime}ms, ${result.memories.length} patterns, ` +
                         `${result.metadata.cacheHit ? 'cache hit' : 'cache miss'})`);
                     // Log top match details
                     if (result.memories.length > 0) {
                         const topMatch = result.memories[0];
                         const gapData = JSON.parse(topMatch.pattern_data);
-                        this.logger?.debug(`[CoverageAnalyzer] 🎯 Top gap match: ${gapData.location} ` +
+                        this.coverageLogger?.debug(`[CoverageAnalyzer] 🎯 Top gap match: ${gapData.location} ` +
                             `(similarity=${topMatch.similarity.toFixed(3)}, confidence=${topMatch.confidence.toFixed(3)})`);
                     }
                     return avgLikelihood;
                 }
                 else {
-                    this.logger?.debug(`[CoverageAnalyzer] No gap patterns found in AgentDB (${searchTime}ms)`);
+                    this.coverageLogger?.debug(`[CoverageAnalyzer] No gap patterns found in AgentDB (${searchTime}ms)`);
                 }
             }
             catch (error) {
-                this.logger?.warn('[CoverageAnalyzer] AgentDB gap prediction failed, using fallback:', error);
+                this.coverageLogger?.warn('[CoverageAnalyzer] AgentDB gap prediction failed, using fallback:', error);
             }
         }
         // Fallback to learning engine
@@ -373,15 +323,15 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
             // Check improvement status
             const improvement = await this.performanceTracker.calculateImprovement();
             if (improvement.targetAchieved) {
-                this.logger?.info(`🎯 20% improvement target achieved! Current: ${improvement.improvementRate.toFixed(2)}%`);
+                this.coverageLogger?.info(`🎯 20% improvement target achieved! Current: ${improvement.improvementRate.toFixed(2)}%`);
             }
             else {
-                this.logger?.debug(`Progress: ${improvement.improvementRate.toFixed(2)}% / 20% target`);
+                this.coverageLogger?.debug(`Progress: ${improvement.improvementRate.toFixed(2)}% / 20% target`);
             }
             // Add learning metrics to result
             result.learningMetrics = {
                 improvementRate: improvement.improvementRate,
-                confidence: (improvement.daysElapsed / (this.config.improvementPeriodDays || 30)),
+                confidence: (improvement.daysElapsed / (this.coverageConfig.improvementPeriodDays || 30)),
                 patternsApplied: this.learningEngine ? (await this.learningEngine.getPatterns()).length : 0
             };
         }
@@ -409,7 +359,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
         // Run improvement cycle if needed
         if (this.improvementLoop && !this.improvementLoop.isActive()) {
             // Run in background
-            this.improvementLoop.runImprovementCycle().catch(error => this.logger?.warn('Improvement cycle failed', error));
+            this.improvementLoop.runImprovementCycle().catch(error => this.coverageLogger?.warn('Improvement cycle failed', error));
         }
         // Store optimization results for future learning
         await this.storeOptimizationResults(request, result.optimization, executionTime);
@@ -445,19 +395,19 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                         last_used: Date.now()
                     });
                     storedCount++;
-                    this.logger?.debug(`[CoverageAnalyzer] ✅ Stored gap pattern ${gapId} in AgentDB`);
+                    this.coverageLogger?.debug(`[CoverageAnalyzer] ✅ Stored gap pattern ${gapId} in AgentDB`);
                 }
                 const storeTime = Date.now() - startTime;
-                this.logger?.info(`[CoverageAnalyzer] ✅ ACTUALLY stored ${storedCount} gap patterns in AgentDB ` +
+                this.coverageLogger?.info(`[CoverageAnalyzer] ✅ ACTUALLY stored ${storedCount} gap patterns in AgentDB ` +
                     `(${storeTime}ms, avg ${(storeTime / storedCount).toFixed(1)}ms/pattern, QUIC sync active)`);
                 // Report QUIC sync status
                 const agentDBConfig = this.agentDBConfig;
                 if (agentDBConfig?.enableQUICSync) {
-                    this.logger?.info(`[CoverageAnalyzer] 🚀 Gap patterns synced via QUIC to ${agentDBConfig.syncPeers?.length || 0} peers (<1ms latency)`);
+                    this.coverageLogger?.info(`[CoverageAnalyzer] 🚀 Gap patterns synced via QUIC to ${agentDBConfig.syncPeers?.length || 0} peers (<1ms latency)`);
                 }
             }
             catch (error) {
-                this.logger?.warn('[CoverageAnalyzer] AgentDB gap storage failed:', error);
+                this.coverageLogger?.warn('[CoverageAnalyzer] AgentDB gap storage failed:', error);
             }
         }
         // Also store in ReasoningBank for compatibility
@@ -494,10 +444,10 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
             return;
         try {
             const gapPatterns = await this.reasoningBank.searchByTags(['coverage-gap']);
-            this.logger?.info(`Loaded ${gapPatterns.length} gap patterns from ReasoningBank`);
+            this.coverageLogger?.info(`Loaded ${gapPatterns.length} gap patterns from ReasoningBank`);
         }
         catch (error) {
-            this.logger?.warn('No gap patterns found in ReasoningBank');
+            this.coverageLogger?.warn('No gap patterns found in ReasoningBank');
         }
     }
     /**
@@ -507,7 +457,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
         if (!this.reasoningBank)
             return;
         const stats = await this.reasoningBank.getStatistics();
-        this.logger?.info(`Saved ${stats.totalPatterns} patterns to ReasoningBank`);
+        this.coverageLogger?.info(`Saved ${stats.totalPatterns} patterns to ReasoningBank`);
     }
     /**
      * AgentDB Helper: Create gap query embedding for vector search
@@ -824,7 +774,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                     confidence: p.confidence,
                     successRate: p.successRate
                 }));
-                this.logger?.info(`[CoverageAnalyzer] Cached ${this.cachedPatterns.length} patterns from LearningEngine`);
+                this.coverageLogger?.info(`[CoverageAnalyzer] Cached ${this.cachedPatterns.length} patterns from LearningEngine`);
             }
             // Also load from memoryStore if available
             if (this.memoryStore) {
@@ -833,7 +783,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                     const dbPatterns = await smm.queryPatternsByConfidence(0.5); // High confidence only
                     const coveragePatterns = dbPatterns.filter((p) => p.pattern?.includes('coverage') || p.metadata?.agent_type === 'coverage-analyzer');
                     if (coveragePatterns.length > 0) {
-                        this.logger?.info(`[CoverageAnalyzer] Found ${coveragePatterns.length} historical coverage patterns in DB`);
+                        this.coverageLogger?.info(`[CoverageAnalyzer] Found ${coveragePatterns.length} historical coverage patterns in DB`);
                         // Merge with existing patterns
                         for (const p of coveragePatterns) {
                             if (!this.cachedPatterns.find(cp => cp.pattern === p.pattern)) {
@@ -847,10 +797,10 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                     }
                 }
             }
-            this.logger?.info(`[CoverageAnalyzer] Total cached patterns for confidence boost: ${this.cachedPatterns.length}`);
+            this.coverageLogger?.info(`[CoverageAnalyzer] Total cached patterns for confidence boost: ${this.cachedPatterns.length}`);
         }
         catch (error) {
-            this.logger?.warn('[CoverageAnalyzer] Failed to load patterns for confidence', error);
+            this.coverageLogger?.warn('[CoverageAnalyzer] Failed to load patterns for confidence', error);
         }
     }
     /**
@@ -870,7 +820,7 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
         const totalWeight = relevantPatterns.reduce((sum, p) => sum + p.successRate, 0);
         const weightedConfidence = relevantPatterns.reduce((sum, p) => sum + p.confidence * p.successRate, 0);
         const boost = totalWeight > 0 ? (weightedConfidence / totalWeight) * 0.3 : 0; // Max 30% boost
-        this.logger?.debug(`[CoverageAnalyzer] Confidence boost from ${relevantPatterns.length} patterns: ${(boost * 100).toFixed(1)}%`);
+        this.coverageLogger?.debug(`[CoverageAnalyzer] Confidence boost from ${relevantPatterns.length} patterns: ${(boost * 100).toFixed(1)}%`);
         return boost;
     }
     /**
@@ -882,8 +832,8 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
             return; // ExperienceCapture not initialized
         }
         try {
-            const agentIdStr = typeof this.id === 'string' ? this.id : this.id.id;
-            const agentType = typeof this.id === 'object' && 'type' in this.id ? this.id.type : 'coverage-analyzer';
+            const agentIdStr = this.getAgentIdStr();
+            const agentType = 'coverage-analyzer';
             const event = {
                 agentId: agentIdStr,
                 agentType: agentType,
@@ -917,12 +867,12 @@ class CoverageAnalyzerAgent extends events_1.EventEmitter {
                 timestamp: new Date()
             };
             await this.experienceCapture.captureExecution(event);
-            this.logger?.debug(`[CoverageAnalyzer] Captured experience for Nightly-Learner: ${success ? 'success' : 'failure'}`);
+            this.coverageLogger?.debug(`[CoverageAnalyzer] Captured experience for Nightly-Learner: ${success ? 'success' : 'failure'}`);
             this.emit('experience:captured', { agentId: agentIdStr, success, duration });
         }
         catch (captureError) {
             // Don't fail the main operation if capture fails
-            this.logger?.warn('[CoverageAnalyzer] Failed to capture experience:', captureError);
+            this.coverageLogger?.warn('[CoverageAnalyzer] Failed to capture experience:', captureError);
         }
     }
     /**