agentic-qe 3.8.4 → 3.8.5

package/dist/domains/code-intelligence/services/product-factors-bridge.js

@@ -11,6 +11,7 @@
  *
  * Event-driven architecture following V3 patterns.
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import * as path from 'path';
 import * as fs from 'fs/promises';
@@ -88,6 +89,7 @@ const EXTERNAL_SYSTEM_PATTERNS = {
  *
  * Bridges code-intelligence C4 capabilities with product-factors-assessor.
  */
+const logger = LoggerFactory.create('code-intelligence/product-factors-bridge');
 export class ProductFactorsBridgeService {
     eventBus;
     memory;
@@ -130,14 +132,14 @@ export class ProductFactorsBridgeService {
     }
     async handleKnowledgeGraphUpdated(event) {
         // Invalidate relevant caches when knowledge graph is updated
-        console.log('[ProductFactorsBridge] Knowledge graph updated, considering cache invalidation');
+        logger.info('[ProductFactorsBridge] Knowledge graph updated, considering cache invalidation');
         // Note: We don't have project path in this event, so we rely on hash-based invalidation
     }
     async handleImpactAnalysisCompleted(event) {
         // Track impacted files for potential cache invalidation
         const payload = event.payload;
         if (payload.changedFiles && payload.changedFiles.length > 0) {
-            console.log(`[ProductFactorsBridge] Impact analysis detected ${payload.changedFiles.length} changed files`);
+            logger.info(`[ProductFactorsBridge] Impact analysis detected ${payload.changedFiles.length} changed files`);
         }
     }
     // ==========================================================================
@@ -150,7 +152,7 @@ export class ProductFactorsBridgeService {
             // Check cache first
             const cached = await this.getCachedDiagrams(request.projectPath);
             if (cached) {
-                console.log(`[ProductFactorsBridge] Returning cached C4 diagrams for ${request.projectPath}`);
+                logger.info(`[ProductFactorsBridge] Returning cached C4 diagrams for ${request.projectPath}`);
                 return ok(cached);
             }
             // Generate new diagrams
@@ -369,7 +371,7 @@ export class ProductFactorsBridgeService {
             }
         }
         catch (error) {
-            console.error('[ProductFactorsBridge] External system detection failed:', error);
+            logger.error('External system detection failed', error instanceof Error ? error : undefined);
         }
         return systems;
     }
@@ -435,7 +437,7 @@ export class ProductFactorsBridgeService {
             }
         }
         catch (error) {
-            console.error('[ProductFactorsBridge] Component analysis failed:', error);
+            logger.error('Component analysis failed:', error instanceof Error ? error : undefined);
         }
         return { components, relationships };
     }
@@ -473,7 +475,7 @@ export class ProductFactorsBridgeService {
             }
             catch (error) {
                 // Non-critical: permission errors when scanning directories
-                console.debug('[ProductFactorsBridge] Directory scan error:', error instanceof Error ? error.message : error);
+                logger.debug('Directory scan error:');
             }
         };
         await scan(dir, 0);
@@ -573,7 +575,7 @@ export class ProductFactorsBridgeService {
             }
         }
         catch (error) {
-            console.error('[ProductFactorsBridge] Coupling analysis failed:', error);
+            logger.error('Coupling analysis failed:', error instanceof Error ? error : undefined);
         }
         return couplingInfo;
     }

package/dist/domains/contract-testing/coordinator.d.ts

@@ -41,12 +41,6 @@ export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
     enableQESONA: boolean;
 }
 type ContractWorkflowType = 'verify' | 'compare' | 'import' | 'export';
-/**
- * Contract Testing Coordinator
- * Orchestrates contract testing workflows and coordinates with agents
- *
- * CQ-002: Extends BaseDomainCoordinator
- */
 export declare class ContractTestingCoordinator extends BaseDomainCoordinator<CoordinatorConfig, ContractWorkflowType> implements IContractTestingCoordinator {
     private readonly memory;
     private readonly agentCoordinator;

package/dist/domains/contract-testing/coordinator.js

@@ -4,6 +4,7 @@
  *
  * CQ-002: Extends BaseDomainCoordinator for lifecycle deduplication
  */
+import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../shared/types/index.js';
 import { toError, toErrorMessage } from '../../shared/error-utils.js';
@@ -52,6 +53,7 @@ const DEFAULT_CONFIG = {
  *
  * CQ-002: Extends BaseDomainCoordinator
  */
+const logger = LoggerFactory.create('contract-testing');
 export class ContractTestingCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -91,10 +93,10 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                     hiddenLayers: [64, 64],
                 });
                 // First call to predict will initialize the algorithm
-                console.log('[contract-testing] SARSA algorithm created successfully');
+                logger.info('SARSA algorithm created successfully');
             }
             catch (error) {
-                console.error('[contract-testing] Failed to create SARSA:', error);
+                logger.error('Failed to create SARSA:', error instanceof Error ? error : undefined);
                 throw new Error(`SARSA creation failed: ${toErrorMessage(error)}`);
             }
         }
@@ -108,12 +110,12 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                     maxPatterns: 5000,
                     minConfidence: 0.6,
                 });
-                console.log('[contract-testing] PersistentSONAEngine initialized successfully');
+                logger.info('PersistentSONAEngine initialized successfully');
             }
             catch (error) {
                 // Log and continue - SONA is enhancement, not critical
-                console.error('[contract-testing] Failed to initialize PersistentSONAEngine:', error);
-                console.warn('[contract-testing] Continuing without SONA pattern persistence');
+                logger.error('Failed to initialize PersistentSONAEngine:', error instanceof Error ? error : undefined);
+                logger.warn('Continuing without SONA pattern persistence');
                 this.qesona = undefined;
             }
         }
@@ -188,7 +190,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'verify');
             // ADR-047: Check topology health before expensive operations
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative verification strategy`);
+                logger.warn(`Topology degraded, using conservative verification strategy`);
                 // Continue with reduced parallelism when topology is unhealthy
             }
             // ADR-047: Check if operations should be paused due to critical topology
@@ -220,7 +222,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                 const prioritizationResult = await this.prioritizeContracts(contracts, prioritizationContext);
                 if (prioritizationResult.success) {
                     contracts = prioritizationResult.value.orderedContracts;
-                    console.log(`[contract-testing] Using ${prioritizationResult.value.strategy} strategy for contract verification order (confidence: ${prioritizationResult.value.confidence.toFixed(2)})`);
+                    logger.info(`[contract-testing] Using ${prioritizationResult.value.strategy} strategy for contract verification order (confidence: ${prioritizationResult.value.confidence.toFixed(2)})`);
                 }
             }
             // Spawn verification agent
@@ -282,7 +284,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'compare');
             // ADR-047: Check topology health before expensive operations
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative pre-release check`);
+                logger.warn(`Topology degraded, using conservative pre-release check`);
             }
             // ADR-047: Check if operations should be paused due to critical topology
             if (this.minCutMixin.shouldPauseOperations()) {
@@ -596,14 +598,14 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
                 // YAML support would require a YAML parser
                 // For now, log a warning and return null
-                console.warn('YAML contract files not yet supported:', path.value);
+                logger.warn('YAML contract files not yet supported:');
                 return null;
             }
             // Try parsing as JSON anyway
             return safeJsonParse(content);
         }
         catch (error) {
-            console.error(`Failed to parse contract from ${path.value}:`, toErrorMessage(error));
+            logger.error(`Failed to parse contract from ${path.value}: ${toErrorMessage(error)}`);
             return null;
         }
     }
@@ -611,7 +613,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
         // Read file content using FileReader
         const result = await this.fileReader.readFile(path.value);
         if (!result.success) {
-            console.error(`Failed to read file ${path.value}:`, result.error);
+            logger.error(`Failed to read file ${path.value}:`, result.error);
             return null;
         }
         return result.value;
@@ -894,7 +896,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                 nextState: state,
                 done: true,
             });
-            console.log(`[contract-testing] SARSA prioritized ${contracts.length} contracts using ${strategy} strategy (confidence: ${prediction.confidence.toFixed(2)})`);
+            logger.info(`[contract-testing] SARSA prioritized ${contracts.length} contracts using ${strategy} strategy (confidence: ${prediction.confidence.toFixed(2)})`);
             return ok({
                 orderedContracts: prioritized,
                 strategy,
@@ -902,7 +904,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             });
         }
         catch (error) {
-            console.error('[contract-testing] SARSA prioritization failed:', error);
+            logger.error('SARSA prioritization failed:', error instanceof Error ? error : undefined);
             // Return original contracts on error (graceful degradation)
             return ok({
                 orderedContracts: contracts,
@@ -971,10 +973,10 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                 provider: contract.provider.name,
                 version: contract.version.toString(),
             });
-            console.log(`[contract-testing] Stored pattern for contract ${contract.id} (success: ${validationSuccess}, quality: ${quality.toFixed(2)})`);
+            logger.info(`Stored pattern for contract ${contract.id} (success: ${validationSuccess}, quality: ${quality.toFixed(2)})`);
         }
         catch (error) {
-            console.error('[contract-testing] Failed to store contract pattern:', error);
+            logger.error('Failed to store contract pattern:', error instanceof Error ? error : undefined);
         }
     }
     /**
@@ -1008,7 +1010,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             if (adaptation.success && adaptation.pattern) {
                 const shouldValidate = adaptation.pattern.outcome.success;
                 const strategy = adaptation.pattern.action.type;
-                console.log(`[contract-testing] QESONA adapted pattern for ${contract.id}: shouldValidate=${shouldValidate}, confidence=${adaptation.similarity.toFixed(2)}`);
+                logger.info(`[contract-testing] QESONA adapted pattern for ${contract.id}: shouldValidate=${shouldValidate}, confidence=${adaptation.similarity.toFixed(2)}`);
                 return {
                     shouldValidate,
                     confidence: adaptation.similarity,
@@ -1022,7 +1024,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             };
         }
         catch (error) {
-            console.error('[contract-testing] QESONA pattern adaptation failed:', error);
+            logger.error('QESONA pattern adaptation failed:', error instanceof Error ? error : undefined);
             return {
                 shouldValidate: true,
                 confidence: 0.5,
@@ -1084,10 +1086,10 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Contract violation verified by consensus`);
+                logger.info(`Contract violation verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Contract violation NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Contract violation NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed
@@ -1108,10 +1110,10 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Breaking change at '${change.path}' verified by consensus`);
+                logger.info(`Breaking change at '${change.path}' verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Breaking change NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Breaking change NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed
@@ -1132,10 +1134,10 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Schema incompatibility verified by consensus`);
+                logger.info(`Schema incompatibility verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Schema incompatibility NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Schema incompatibility NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed

package/dist/domains/contract-testing/services/contract-validator.d.ts

@@ -28,10 +28,6 @@ export interface ContractValidatorDependencies {
     memory: MemoryBackend;
     llmRouter?: HybridRouter;
 }
-/**
- * Contract Validation Service Implementation
- * Validates API contracts against schemas and specifications
- */
 export declare class ContractValidatorService implements IContractValidationService {
     private readonly config;
     private readonly memory;

package/dist/domains/contract-testing/services/contract-validator.js

@@ -2,8 +2,9 @@
  * Agentic QE v3 - Contract Validator Service
  * Implements IContractValidationService for API contract validation (Pact-style)
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
-import { createSafeRegex } from '../../../mcp/security/validators/regex-safety-validator.js';
+import { createSafeRegex } from '../../../shared/security/regex-safety-validator.js';
 import { CONTRACT_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constants.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -20,6 +21,7 @@ const DEFAULT_CONFIG = {
  * Contract Validation Service Implementation
  * Validates API contracts against schemas and specifications
  */
+const logger = LoggerFactory.create('contract-testing/contract-validator');
 export class ContractValidatorService {
     config;
     memory;
@@ -80,7 +82,7 @@ Provide:
             return response.content;
         }
         catch (error) {
-            console.warn('[ContractValidatorService] LLM analysis failed:', error);
+            logger.warn('LLM analysis failed:');
             return null;
         }
     }

package/dist/domains/contract-testing/services/schema-validator.js

@@ -4,7 +4,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
-import { createSafeRegex } from '../../../mcp/security/validators/regex-safety-validator.js';
+import { createSafeRegex } from '../../../shared/security/regex-safety-validator.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 const DEFAULT_CONFIG = {

package/dist/domains/coverage-analysis/coordinator.js

@@ -3,6 +3,7 @@
  * Orchestrates coverage analysis workflow and domain events
  * Integrates Q-Learning for intelligent test prioritization
  */
+import { LoggerFactory } from '../../logging/index.js';
 import { ok, err } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
 import { createEvent, CoverageAnalysisEvents, } from '../../shared/events';
@@ -33,6 +34,7 @@ const DEFAULT_CONFIG = {
 // ============================================================================
 // Coordinator Implementation
 // ============================================================================
+const logger = LoggerFactory.create('coverage-analysis');
 export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
     memory;
     coverageAnalyzer;
@@ -160,7 +162,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
             }
         }
         catch (error) {
-            console.error('Failed to train Q-Learning model:', error);
+            logger.error('Failed to train Q-Learning model', error instanceof Error ? error : undefined);
         }
     }
     // ============================================================================
@@ -346,7 +348,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         try {
             // ADR-047: Check topology health before expensive analysis
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative analysis mode`);
+                logger.warn('Topology degraded, using conservative analysis mode');
             }
             // ADR-047: Check if operations should be paused due to critical topology
             if (this.minCutMixin.shouldPauseOperations()) {
@@ -372,7 +374,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         try {
             // ADR-047: Check topology health before gap detection
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative gap detection`);
+                logger.warn('Topology degraded, using conservative gap detection');
             }
             // ADR-047: Check if operations should be paused due to critical topology
             if (this.minCutMixin.shouldPauseOperations()) {
@@ -388,7 +390,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                         const confidence = Math.min(0.95, gap.riskScore / 10 + 0.3);
                         const isVerified = await this.verifyCoverageGap(gap, confidence);
                         if (!isVerified) {
-                            console.log(`[${this.domainName}] Coverage gap in '${gap.file}' not verified, skipping publication`);
+                            logger.info(`Coverage gap in '${gap.file}' not verified, skipping publication`);
                             continue;
                         }
                     }
@@ -428,7 +430,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                         factors: result.value.factors.map(f => ({ name: f.name, weight: f.contribution })),
                     }, Math.min(0.95, result.value.overallRisk / 10 + 0.5));
                     if (!isVerified) {
-                        console.warn(`[${this.domainName}] Risk zone '${result.value.file}' not verified, downgrading severity`);
+                        logger.warn(`Risk zone '${result.value.file}' not verified, downgrading severity`);
                         // Downgrade the risk level if not verified
                         return ok({
                             ...result.value,
@@ -785,10 +787,10 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Coverage gap in '${gap.file}' verified by consensus`);
+                logger.info(`Coverage gap in '${gap.file}' verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Coverage gap in '${gap.file}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Coverage gap in '${gap.file}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed
@@ -814,10 +816,10 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Risk zone '${zone.file}' classification verified by consensus`);
+                logger.info(`Risk zone '${zone.file}' classification verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Risk zone '${zone.file}' classification NOT verified`);
+            logger.warn(`Risk zone '${zone.file}' classification NOT verified`);
             return false;
         }
         return true; // No consensus needed
@@ -843,10 +845,10 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Quality regression verified by consensus`);
+                logger.info('Quality regression verified by consensus');
                 return true;
             }
-            console.warn(`[${this.domainName}] Quality regression NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Quality regression NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed

package/dist/domains/coverage-analysis/services/coverage-analyzer.js

@@ -4,6 +4,7 @@
  *
  * ADR-051: LLM-powered coverage analysis for intelligent gap detection
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -16,6 +17,7 @@ const DEFAULT_CONFIG = {
 // ============================================================================
 // Service Implementation
 // ============================================================================
+const logger = LoggerFactory.create('coverage-analysis/coverage-analyzer');
 export class CoverageAnalyzerService {
     static DEFAULT_THRESHOLD = 80;
     static VECTOR_DIMENSION = 384;
@@ -249,7 +251,7 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             return this.getDefaultInsights();
         }
         catch (error) {
-            console.warn('[CoverageAnalyzer] LLM analysis failed, using defaults:', error);
+            logger.warn('LLM analysis failed, using defaults');
             return this.getDefaultInsights();
         }
     }
@@ -303,7 +305,7 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             };
         }
         catch {
-            console.warn('[CoverageAnalyzer] Failed to parse LLM response as JSON');
+            logger.warn('Failed to parse LLM response as JSON');
             return this.getDefaultInsights();
         }
     }

package/dist/domains/coverage-analysis/services/gap-detector.js

@@ -4,6 +4,7 @@
  *
  * ADR-051: Added LLM-powered gap analysis for intelligent prioritization
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -16,6 +17,7 @@ const DEFAULT_CONFIG = {
 // ============================================================================
 // Service Implementation
 // ============================================================================
+const logger = LoggerFactory.create('coverage-analysis/gap-detector');
 export class GapDetectorService {
     static DEFAULT_MIN_COVERAGE = 80;
     static VECTOR_DIMENSION = 384;
@@ -122,7 +124,7 @@ Return JSON in this exact format:
             return err(new Error('Empty response from LLM'));
         }
         catch (error) {
-            console.warn('[GapDetector] LLM analysis failed:', error);
+            logger.warn('LLM analysis failed');
             return err(toError(error));
         }
     }

package/dist/domains/coverage-analysis/services/hnsw-index.d.ts

@@ -143,21 +143,6 @@ export interface HNSWIndexStats {
     /** Number of insert operations performed */
     insertOperations: number;
 }
-/**
- * HNSW Index implementation delegating to the unified HnswAdapter (ADR-071).
- *
- * This provides O(log n) approximate nearest neighbor search for coverage
- * gap detection. Internally uses HnswAdapter which wraps ProgressiveHnswBackend
- * with @ruvector/gnn differentiableSearch and brute-force cosine fallback.
- *
- * @example
- * ```typescript
- * const index = new HNSWIndex(memoryBackend);
- * await index.initialize();
- * await index.insert('file:src/main.ts', embedding, { filePath: 'src/main.ts', ... });
- * const similar = await index.search(queryEmbedding, 10);
- * ```
- */
 export declare class HNSWIndex implements IHNSWIndex {
     private readonly memory;
     private readonly config;

package/dist/domains/coverage-analysis/services/hnsw-index.js

@@ -18,6 +18,7 @@
  *
  * @module coverage-analysis/hnsw-index
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { HnswAdapter } from '../../../kernel/hnsw-adapter.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
 /**
@@ -50,6 +51,7 @@ export const DEFAULT_HNSW_CONFIG = {
  * const similar = await index.search(queryEmbedding, 10);
  * ```
  */
+const logger = LoggerFactory.create('coverage-analysis/hnsw-index');
 export class HNSWIndex {
     memory;
     config;
@@ -96,7 +98,7 @@ export class HNSWIndex {
             efSearch: this.config.efSearch,
             metric: adapterMetric,
         });
-        console.log(`[HNSWIndex] HnswAdapter initialized: dimension=${this.config.dimensions}, ` +
+        logger.info(`HnswAdapter initialized: dimension=${this.config.dimensions}, ` +
             `metric=${this.config.metric}, M=${this.config.M} (unified backend via ADR-071)`);
         this.initialized = true;
     }

package/dist/domains/coverage-analysis/services/sublinear-analyzer.d.ts

@@ -117,32 +117,6 @@ export interface SublinearAnalyzerStats {
     /** Performance vs linear scan improvement factor */
     performanceImprovement: number;
 }
-/**
- * Sublinear Coverage Analyzer
- *
- * Implements O(log n) coverage gap detection using HNSW vector indexing.
- * This is the core implementation for ADR-003 performance targets.
- *
- * Key features:
- * - O(log n) gap detection via HNSW approximate nearest neighbor search
- * - Dense coverage embeddings capture coverage patterns
- * - Batch indexing for efficient bulk operations
- * - Risk zone detection using vector similarity clustering
- * - <100ms target for 100k file codebases
- *
- * @example
- * ```typescript
- * const analyzer = new SublinearCoverageAnalyzer(memoryBackend);
- * await analyzer.initialize();
- * await analyzer.indexCoverageData(coverageData);
- *
- * // O(log n) gap detection
- * const gaps = await analyzer.findGapsSublinear({ maxLineCoverage: 60 });
- *
- * // Find similar patterns
- * const similar = await analyzer.findSimilarPatterns(gap, 5);
- * ```
- */
 export declare class SublinearCoverageAnalyzer implements ISublinearCoverageAnalyzer {
     private readonly memory;
     private readonly config;

package/dist/domains/coverage-analysis/services/sublinear-analyzer.js

@@ -16,6 +16,7 @@
  *
  * @module coverage-analysis/sublinear-analyzer
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types';
 import { createHNSWIndex, } from './hnsw-index';
 import { toError } from '../../../shared/error-utils.js';
@@ -61,6 +62,7 @@ export const DEFAULT_ANALYZER_CONFIG = {
  * const similar = await analyzer.findSimilarPatterns(gap, 5);
  * ```
  */
+const logger = LoggerFactory.create('coverage-analysis/sublinear-analyzer');
 export class SublinearCoverageAnalyzer {
     memory;
     config;
@@ -179,7 +181,7 @@ export class SublinearCoverageAnalyzer {
             const estimatedEffort = this.estimateEffort(totalUncoveredLines);
             // Verify performance target
             if (searchTimeMs > 100) {
-                console.warn(`Sublinear search took ${searchTimeMs.toFixed(2)}ms, ` +
+                logger.warn(`Sublinear search took ${searchTimeMs.toFixed(2)}ms, ` +
                     `exceeding 100ms target for ${this.fileCount} files`);
             }
             return ok({

package/dist/domains/defect-intelligence/coordinator.d.ts

@@ -48,15 +48,6 @@ export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
     consensusConfig?: Partial<ConsensusEnabledConfig>;
 }
 type DefectWorkflowType = 'predict' | 'analyze' | 'regression' | 'cluster' | 'learn';
-/**
- * Defect Intelligence Coordinator
- * Orchestrates defect analysis workflows and coordinates with agents
- *
- * V3 Integration:
- * - MinCut topology awareness for routing and health monitoring (ADR-047)
- * - Multi-model consensus for high-confidence predictions (MM-001)
- * - CQ-002: Extends BaseDomainCoordinator
- */
 export declare class DefectIntelligenceCoordinator extends BaseDomainCoordinator<CoordinatorConfig, DefectWorkflowType> implements IDefectIntelligenceCoordinator {
     private readonly memory;
     private readonly agentCoordinator;
@@ -71,7 +62,7 @@ export declare class DefectIntelligenceCoordinator extends BaseDomainCoordinator
     /**
      * Get weak vertices in this domain (for diagnostics)
      */
-    getDomainWeakVertices(): import("../..").WeakVertex[];
+    getDomainWeakVertices(): import("../../index.js").WeakVertex[];
     /**
      * Subscribe to topology health changes
      */