agentic-qe 3.6.7 → 3.6.9

package/v3/dist/domains/code-intelligence/coordinator.js

@@ -8,6 +8,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { err } from '../../shared/types';
+import { toError } from '../../shared/error-utils.js';
 import { CodeIntelligenceEvents, createEvent, } from '../../shared/events/domain-events';
 import { ProductFactorsBridgeService, } from './services/product-factors-bridge';
 import { KnowledgeGraphService, } from './services/knowledge-graph';
@@ -22,14 +23,12 @@ import { createPersistentSONAEngine, } from '../../integrations/ruvector/sona-pe
 import { createMetricCollector, } from './services/metric-collector/index.js';
 // V3 Integration: Hypergraph Engine for code intelligence (GOAP Action 7)
 import { createHypergraphEngine, } from '../../integrations/ruvector/hypergraph-engine.js';
-// ============================================================================
-// MinCut & Consensus Mixin Imports (ADR-047, MM-001)
-// ============================================================================
-import { createMinCutAwareMixin, } from '../../coordination/mixins/mincut-aware-domain';
-import { createConsensusEnabledMixin, } from '../../coordination/mixins/consensus-enabled-domain';
-// ADR-058: Governance-aware mixin for MemoryWriteGate integration
-import { createGovernanceAwareMixin, } from '../../coordination/mixins/governance-aware-domain.js';
-import { createDomainFinding, } from '../../coordination/consensus/domain-findings';
+// CQ-002: Base domain coordinator
+import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
+// CQ-004: Extracted modules
+import * as GNNHelpers from './coordinator-gnn.js';
+import * as HypergraphHelpers from './coordinator-hypergraph.js';
+import * as ConsensusHelpers from './coordinator-consensus.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 120000, // 2 minutes
@@ -52,20 +51,15 @@ const DEFAULT_CONFIG = {
     consensusMinModels: 2,
 };
 /**
- * Code Intelligence Coordinator
- * Orchestrates code intelligence workflows and coordinates with agents
+ * CQ-002: Extends BaseDomainCoordinator
  */
-export class CodeIntelligenceCoordinator {
-    eventBus;
+export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
-    config;
     knowledgeGraph;
     semanticAnalyzer;
     impactAnalyzer;
     fileReader;
-    workflows = new Map();
-    initialized = false;
     // V3: GNN and SONA integrations
     gnnIndex;
     sonaEngine;
@@ -77,38 +71,13 @@ export class CodeIntelligenceCoordinator {
     hypergraphDb;
     // V3: Product Factors Bridge for cross-domain C4 access
     productFactorsBridge;
-    // MinCut topology awareness mixin (ADR-047)
-    minCutMixin;
-    // Consensus verification mixin (MM-001)
-    consensusMixin;
-    // Domain identifier for mixin initialization
-    domainName = 'code-intelligence';
-    // ADR-058: Governance mixin for MemoryWriteGate integration
-    governanceMixin;
     constructor(eventBus, memory, agentCoordinator, config = {}) {
-        this.eventBus = eventBus;
-        this.memory = memory;
-        this.agentCoordinator = agentCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Initialize MinCut-aware mixin (ADR-047)
-        this.minCutMixin = createMinCutAwareMixin(this.domainName, {
-            enableMinCutAwareness: this.config.enableMinCutAwareness,
-            topologyHealthThreshold: this.config.topologyHealthThreshold,
-            pauseOnCriticalTopology: this.config.pauseOnCriticalTopology,
-        });
-        // Initialize Consensus-enabled mixin (MM-001)
-        this.consensusMixin = createConsensusEnabledMixin({
-            enableConsensus: this.config.enableConsensus,
-            consensusThreshold: this.config.consensusThreshold,
+        const fullConfig = { ...DEFAULT_CONFIG, ...config };
+        super(eventBus, 'code-intelligence', fullConfig, {
             verifyFindingTypes: ['code-pattern-detection', 'impact-analysis', 'dependency-mapping'],
-            strategy: this.config.consensusStrategy,
-            minModels: this.config.consensusMinModels,
-            modelTimeout: 60000,
-            verifySeverities: ['critical', 'high'],
-            enableLogging: false,
         });
-        // ADR-058: Initialize governance mixin for MemoryWriteGate integration
-        this.governanceMixin = createGovernanceAwareMixin(this.domainName);
+        this.memory = memory;
+        this.agentCoordinator = agentCoordinator;
         this.knowledgeGraph = new KnowledgeGraphService(memory);
         this.semanticAnalyzer = new SemanticAnalyzerService(memory);
         this.impactAnalyzer = new ImpactAnalyzerService(memory, this.knowledgeGraph);
@@ -118,12 +87,14 @@ export class CodeIntelligenceCoordinator {
             publishEvents: this.config.publishEvents,
         });
     }
+    // ==========================================================================
+    // BaseDomainCoordinator Template Methods
+    // ==========================================================================
     /**
      * Initialize the coordinator
+     * CQ-002: Domain-specific initialization
      */
-    async initialize() {
-        if (this.initialized)
-            return;
+    async onInitialize() {
         // Subscribe to relevant events
         this.subscribeToEvents();
         // Load any persisted workflow state
@@ -146,18 +117,6 @@ export class CodeIntelligenceCoordinator {
         }
         // V3: Initialize Product Factors Bridge
         await this.productFactorsBridge.initialize();
-        // Initialize Consensus engine if enabled (MM-001)
-        if (this.config.enableConsensus) {
-            try {
-                await this.consensusMixin.initializeConsensus();
-                console.log(`[${this.domainName}] Consensus engine initialized`);
-            }
-            catch (error) {
-                console.error(`[${this.domainName}] Failed to initialize consensus engine:`, error);
-                console.warn(`[${this.domainName}] Continuing without consensus verification`);
-            }
-        }
-        this.initialized = true;
     }
     /**
      * Initialize V3 Hypergraph Engine for code intelligence (GOAP Action 7)
@@ -241,21 +200,11 @@ export class CodeIntelligenceCoordinator {
     }
     /**
      * Dispose and cleanup
+     * CQ-002: Domain-specific disposal
      */
-    async dispose() {
-        // Dispose Consensus engine (MM-001)
-        try {
-            await this.consensusMixin.disposeConsensus();
-        }
-        catch (error) {
-            console.error(`[${this.domainName}] Error disposing consensus engine:`, error);
-        }
-        // Dispose MinCut mixin (ADR-047)
-        this.minCutMixin.dispose();
+    async onDispose() {
         // Save workflow state
         await this.saveWorkflowState();
-        // Clear active workflows
-        this.workflows.clear();
         // Clean up GNN index
         if (this.gnnIndex) {
             QEGNNIndexFactory.closeInstance('code-intelligence');
@@ -283,13 +232,12 @@ export class CodeIntelligenceCoordinator {
         this.hypergraph = undefined;
         // Dispose Product Factors Bridge
         await this.productFactorsBridge.dispose();
-        this.initialized = false;
     }
     /**
-     * Get active workflow statuses
+     * Get active workflow statuses (typed override)
      */
     getActiveWorkflows() {
-        return Array.from(this.workflows.values()).filter((w) => w.status === 'running' || w.status === 'pending');
+        return super.getActiveWorkflows();
     }
     // ============================================================================
     // CodeIntelligenceAPI Implementation
@@ -359,7 +307,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -411,7 +359,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -473,7 +421,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -496,7 +444,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -519,7 +467,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -531,140 +479,19 @@ export class CodeIntelligenceCoordinator {
      * Index code embeddings in GNN for fast similarity search
      */
     async indexCodeEmbeddings(paths) {
-        if (!this.gnnIndex || !this.rlInitialized) {
+        if (!this.gnnIndex || !this.rlInitialized)
             return;
-        }
-        try {
-            // Generate embeddings for each code file
-            for (const path of paths) {
-                try {
-                    const result = await this.fileReader.readFile(path);
-                    if (result.success && result.value) {
-                        // Create embedding from code content
-                        const embedding = await this.generateCodeEmbedding(path, result.value);
-                        // Add to GNN index
-                        const embeddingObj = {
-                            vector: embedding,
-                            dimension: 384,
-                            namespace: 'code',
-                            text: result.value.slice(0, 1000), // First 1000 chars for context
-                            timestamp: Date.now(),
-                            quantization: 'none',
-                            metadata: { path },
-                        };
-                        this.gnnIndex.addEmbedding(embeddingObj);
-                    }
-                }
-                catch (error) {
-                    console.error(`Failed to index ${path}:`, error);
-                }
-            }
-            console.log(`[GNN] Indexed ${paths.length} code embeddings`);
-        }
-        catch (error) {
-            console.error('Failed to index code embeddings:', error);
-        }
+        await GNNHelpers.indexCodeEmbeddings(this.gnnIndex, this.fileReader, paths);
     }
-    /**
-     * Generate code embedding using semantic features
-     */
-    async generateCodeEmbedding(path, content) {
-        // Simple embedding based on code features
-        const features = [];
-        // File type feature
-        const ext = path.split('.').pop();
-        const typeHash = this.hashCode(ext || '');
-        features.push((typeHash % 1000) / 1000);
-        // Content length feature
-        features.push(Math.min(1, content.length / 10000));
-        // Function/class count
-        const functionMatches = content.match(/function\s+\w+/g) || [];
-        const classMatches = content.match(/class\s+\w+/g) || [];
-        features.push(Math.min(1, (functionMatches.length + classMatches.length) / 50));
-        // Import/require count
-        const importMatches = content.match(/import\s+.*from|require\s*\(/g) || [];
-        features.push(Math.min(1, importMatches.length / 20));
-        // Complexity indicators
-        const loopMatches = content.match(/for\s*\(|while\s*\(/g) || [];
-        const ifMatches = content.match(/if\s*\(/g) || [];
-        features.push(Math.min(1, (loopMatches.length + ifMatches.length) / 30));
-        // Comment density
-        const commentMatches = content.match(/\/\/.*|\/\*[\s\S]*?\*\//g) || [];
-        features.push(Math.min(1, commentMatches.length / 50));
-        // Fill with hashed content features
-        const contentHash = this.hashCode(content.slice(0, 500));
-        for (let i = features.length; i < 384; i++) {
-            features.push(((contentHash * (i + 1)) % 10000) / 10000);
-        }
-        return features.slice(0, 384);
-    }
-    /**
-     * Search code with GNN for enhanced similarity
-     */
     async searchCodeWithGNN(request) {
-        if (!this.gnnIndex || !this.rlInitialized) {
+        if (!this.gnnIndex || !this.rlInitialized)
             return [];
-        }
-        try {
-            // Create query embedding
-            const queryEmbedding = await this.generateCodeEmbedding('query', request.query);
-            const queryIEmbedding = {
-                vector: queryEmbedding,
-                dimension: 384,
-                namespace: 'code',
-                text: request.query,
-                timestamp: Date.now(),
-                quantization: 'none',
-            };
-            // Search in GNN index
-            const results = this.gnnIndex.search(queryIEmbedding, {
-                limit: 10,
-                namespace: 'code',
-            });
-            return results.map((r) => ({
-                file: r.metadata?.path ?? `file-${r.id}`,
-                similarity: 1 - r.distance,
-            }));
-        }
-        catch (error) {
-            console.error('Failed to search with GNN:', error);
-            return [];
-        }
+        return GNNHelpers.searchCodeWithGNN(this.gnnIndex, request.query);
     }
-    /**
-     * Enhance impact analysis with GNN semantic similarity
-     */
     async enhanceImpactAnalysisWithGNN(request) {
-        if (!this.gnnIndex || !this.rlInitialized) {
+        if (!this.gnnIndex || !this.rlInitialized)
             return;
-        }
-        try {
-            // Find semantically similar files to changed files
-            for (const changedFile of request.changedFiles) {
-                const result = await this.fileReader.readFile(changedFile);
-                if (result.success && result.value) {
-                    const embedding = await this.generateCodeEmbedding(changedFile, result.value);
-                    const embeddingObj = {
-                        vector: embedding,
-                        dimension: 384,
-                        namespace: 'code',
-                        text: result.value.slice(0, 1000),
-                        timestamp: Date.now(),
-                        quantization: 'none',
-                        metadata: { path: changedFile },
-                    };
-                    // Search for similar files
-                    const similar = this.gnnIndex.search(embeddingObj, {
-                        limit: 5,
-                        namespace: 'code',
-                    });
-                    console.log(`[GNN] Found ${similar.length} semantically similar files to ${changedFile}`);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to enhance impact analysis:', error);
-        }
+        await GNNHelpers.enhanceImpactAnalysisWithGNN(this.gnnIndex, this.fileReader, request);
     }
     // ============================================================================
     // V3: SONA Integration for Code Pattern Learning
@@ -749,49 +576,10 @@ export class CodeIntelligenceCoordinator {
      * Merge search results from semantic search and GNN
      */
     mergeSearchResults(semanticResults, gnnResults) {
-        const scoreMap = new Map();
-        const resultMap = new Map();
-        // Add semantic results
-        for (const result of semanticResults) {
-            scoreMap.set(result.file, result.score);
-            resultMap.set(result.file, result);
-        }
-        // Merge GNN results (weighted average)
-        for (const gnnResult of gnnResults) {
-            const existingScore = scoreMap.get(gnnResult.file);
-            if (existingScore !== undefined) {
-                scoreMap.set(gnnResult.file, (existingScore + gnnResult.similarity) / 2);
-            }
-            else {
-                // Create a new SearchResult for GNN-only results
-                scoreMap.set(gnnResult.file, gnnResult.similarity * 0.8);
-                resultMap.set(gnnResult.file, {
-                    file: gnnResult.file,
-                    snippet: '',
-                    score: gnnResult.similarity * 0.8,
-                    highlights: [],
-                });
-            }
-        }
-        // Update scores and sort
-        return Array.from(resultMap.values())
-            .map(result => ({
-            ...result,
-            score: scoreMap.get(result.file) ?? result.score,
-        }))
-            .sort((a, b) => b.score - a.score)
-            .slice(0, 20); // Top 20 results
+        return GNNHelpers.mergeSearchResults(semanticResults, gnnResults);
     }
-    /**
-     * Simple hash function for strings
-     */
     hashCode(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) - hash) + str.charCodeAt(i);
-            hash = hash | 0;
-        }
-        return Math.abs(hash);
+        return GNNHelpers.hashCode(str);
     }
     // ============================================================================
     // Agent Spawning Methods
@@ -875,52 +663,6 @@ export class CodeIntelligenceCoordinator {
         await this.eventBus.publish(event);
     }
     // ============================================================================
-    // Workflow Management
-    // ============================================================================
-    startWorkflow(id, type) {
-        // Check workflow limit
-        const activeWorkflows = this.getActiveWorkflows();
-        if (activeWorkflows.length >= this.config.maxConcurrentWorkflows) {
-            throw new Error(`Maximum concurrent workflows (${this.config.maxConcurrentWorkflows}) reached`);
-        }
-        this.workflows.set(id, {
-            id,
-            type,
-            status: 'running',
-            startedAt: new Date(),
-            agentIds: [],
-            progress: 0,
-        });
-    }
-    completeWorkflow(id) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.status = 'completed';
-            workflow.completedAt = new Date();
-            workflow.progress = 100;
-        }
-    }
-    failWorkflow(id, error) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.status = 'failed';
-            workflow.completedAt = new Date();
-            workflow.error = error;
-        }
-    }
-    addAgentToWorkflow(workflowId, agentId) {
-        const workflow = this.workflows.get(workflowId);
-        if (workflow) {
-            workflow.agentIds.push(agentId);
-        }
-    }
-    updateWorkflowProgress(id, progress) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.progress = Math.min(100, Math.max(0, progress));
-        }
-    }
-    // ============================================================================
     // Event Handling
     // ============================================================================
     subscribeToEvents() {
@@ -1038,7 +780,7 @@ export class CodeIntelligenceCoordinator {
             return result;
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             this.failWorkflow(workflowId, errorObj.message);
             return err(errorObj);
         }
@@ -1108,7 +850,7 @@ export class CodeIntelligenceCoordinator {
             return { success: true, value: metrics };
         }
         catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const errorObj = toError(error);
             console.error('[CodeIntelligence] Failed to collect metrics:', errorObj.message);
             return err(errorObj);
         }
@@ -1187,28 +929,7 @@ export class CodeIntelligenceCoordinator {
         if (!this.hypergraph) {
             return err(new Error('Hypergraph is not enabled or not initialized'));
         }
-        try {
-            const untestedFunctions = await this.hypergraph.findUntestedFunctions();
-            console.log(`[CodeIntelligence] Found ${untestedFunctions.length} untested functions via hypergraph`);
-            // Publish event
-            if (this.config.publishEvents) {
-                const event = createEvent('code-intelligence.UntestedFunctionsFound', 'code-intelligence', {
-                    count: untestedFunctions.length,
-                    functions: untestedFunctions.slice(0, 10).map((f) => ({
-                        name: f.name,
-                        file: f.filePath,
-                        complexity: f.complexity,
-                    })),
-                });
-                await this.eventBus.publish(event);
-            }
-            return { success: true, value: untestedFunctions };
-        }
-        catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            console.error('[CodeIntelligence] Failed to find untested functions:', errorObj.message);
-            return err(errorObj);
-        }
+        return HypergraphHelpers.findUntestedFunctions(this.hypergraph, this.eventBus, this.config.publishEvents);
     }
     /**
      * Find impacted tests using hypergraph traversal
@@ -1223,32 +944,7 @@ export class CodeIntelligenceCoordinator {
         if (!this.hypergraph) {
             return err(new Error('Hypergraph is not enabled or not initialized'));
         }
-        if (changedFiles.length === 0) {
-            return { success: true, value: [] };
-        }
-        try {
-            const impactedTests = await this.hypergraph.findImpactedTests(changedFiles);
-            console.log(`[CodeIntelligence] Found ${impactedTests.length} impacted tests for ` +
-                `${changedFiles.length} changed files via hypergraph`);
-            // Publish event
-            if (this.config.publishEvents) {
-                const event = createEvent('code-intelligence.ImpactedTestsFound', 'code-intelligence', {
-                    changedFiles,
-                    testCount: impactedTests.length,
-                    tests: impactedTests.slice(0, 10).map((t) => ({
-                        name: t.name,
-                        file: t.filePath,
-                    })),
-                });
-                await this.eventBus.publish(event);
-            }
-            return { success: true, value: impactedTests };
-        }
-        catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            console.error('[CodeIntelligence] Failed to find impacted tests:', errorObj.message);
-            return err(errorObj);
-        }
+        return HypergraphHelpers.findImpactedTestsFromHypergraph(this.hypergraph, changedFiles, this.eventBus, this.config.publishEvents);
     }
     /**
      * Find coverage gaps using hypergraph analysis
@@ -1263,31 +959,7 @@ export class CodeIntelligenceCoordinator {
         if (!this.hypergraph) {
             return err(new Error('Hypergraph is not enabled or not initialized'));
         }
-        try {
-            const coverageGaps = await this.hypergraph.findCoverageGaps(maxCoverage);
-            console.log(`[CodeIntelligence] Found ${coverageGaps.length} coverage gaps ` +
-                `(functions with <=${maxCoverage}% coverage) via hypergraph`);
-            // Publish event
-            if (this.config.publishEvents) {
-                const event = createEvent('code-intelligence.CoverageGapsFound', 'code-intelligence', {
-                    maxCoverage,
-                    gapCount: coverageGaps.length,
-                    gaps: coverageGaps.slice(0, 10).map((g) => ({
-                        name: g.name,
-                        file: g.filePath,
-                        coverage: g.coverage,
-                        complexity: g.complexity,
-                    })),
-                });
-                await this.eventBus.publish(event);
-            }
-            return { success: true, value: coverageGaps };
-        }
-        catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            console.error('[CodeIntelligence] Failed to find coverage gaps:', errorObj.message);
-            return err(errorObj);
-        }
+        return HypergraphHelpers.findCoverageGapsFromHypergraph(this.hypergraph, maxCoverage, this.eventBus, this.config.publishEvents);
     }
     /**
      * Build hypergraph from code index result
@@ -1303,37 +975,7 @@ export class CodeIntelligenceCoordinator {
         if (!this.hypergraph) {
             return err(new Error('Hypergraph is not enabled or not initialized'));
         }
-        try {
-            console.log(`[CodeIntelligence] Building hypergraph from ${indexResult.files.length} indexed files`);
-            const buildResult = await this.hypergraph.buildFromIndexResult(indexResult);
-            console.log(`[CodeIntelligence] Hypergraph built: ` +
-                `${buildResult.nodesCreated} nodes created, ` +
-                `${buildResult.nodesUpdated} nodes updated, ` +
-                `${buildResult.edgesCreated} edges created ` +
-                `(${buildResult.durationMs}ms)`);
-            // Store build result in memory
-            await this.memory.set(`hypergraph:build:latest`, {
-                timestamp: new Date().toISOString(),
-                ...buildResult,
-            }, { namespace: 'code-intelligence', persist: true });
-            // Publish event
-            if (this.config.publishEvents) {
-                const event = createEvent('code-intelligence.HypergraphBuilt', 'code-intelligence', {
-                    nodesCreated: buildResult.nodesCreated,
-                    nodesUpdated: buildResult.nodesUpdated,
-                    edgesCreated: buildResult.edgesCreated,
-                    durationMs: buildResult.durationMs,
-                    errorCount: buildResult.errors.length,
-                });
-                await this.eventBus.publish(event);
-            }
-            return { success: true, value: buildResult };
-        }
-        catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            console.error('[CodeIntelligence] Failed to build hypergraph:', errorObj.message);
-            return err(errorObj);
-        }
+        return HypergraphHelpers.buildHypergraphFromIndex(this.hypergraph, indexResult, this.memory, this.eventBus, this.config.publishEvents);
     }
     /**
      * Get the Hypergraph Engine for direct access (advanced usage)
@@ -1351,75 +993,11 @@ export class CodeIntelligenceCoordinator {
         if (!this.hypergraph) {
             return baseAnalysis;
         }
-        try {
-            // Find additional impacted tests using hypergraph
-            const hypergraphTests = await this.hypergraph.findImpactedTests(request.changedFiles);
-            // Merge with existing impacted tests (deduplicate)
-            const allTests = new Set([
-                ...baseAnalysis.impactedTests,
-                ...hypergraphTests.map((t) => t.filePath || t.name),
-            ]);
-            // Update risk level if hypergraph found more impacted tests
-            let newRiskLevel = baseAnalysis.riskLevel;
-            if (hypergraphTests.length > baseAnalysis.impactedTests.length) {
-                // Hypergraph found additional tests - might indicate higher risk
-                const totalImpact = baseAnalysis.directImpact.length + baseAnalysis.transitiveImpact.length;
-                if (totalImpact > 10 && allTests.size > 20) {
-                    newRiskLevel = 'critical';
-                }
-                else if (totalImpact > 5 && allTests.size > 10) {
-                    newRiskLevel = 'high';
-                }
-            }
-            // Add recommendation about hypergraph-discovered tests
-            const newRecommendations = [...baseAnalysis.recommendations];
-            if (hypergraphTests.length > 0) {
-                newRecommendations.push(`Hypergraph analysis found ${hypergraphTests.length} additional test(s) to run`);
-            }
-            return {
-                ...baseAnalysis,
-                impactedTests: Array.from(allTests),
-                riskLevel: newRiskLevel,
-                recommendations: newRecommendations,
-            };
-        }
-        catch (error) {
-            console.error('[CodeIntelligence] Failed to enhance impact with hypergraph:', error);
-            return baseAnalysis;
-        }
+        return HypergraphHelpers.enhanceImpactWithHypergraph(this.hypergraph, request, baseAnalysis);
     }
     // ============================================================================
-    // MinCut Integration Methods (ADR-047)
+    // Domain-Specific Consensus Methods (MM-001)
     // ============================================================================
-    /**
-     * Set the MinCut bridge for topology awareness
-     */
-    setMinCutBridge(bridge) {
-        this.minCutMixin.setMinCutBridge(bridge);
-        console.log(`[${this.domainName}] MinCut bridge connected for topology awareness`);
-    }
-    /**
-     * Check if topology is healthy
-     */
-    isTopologyHealthy() {
-        return this.minCutMixin.isTopologyHealthy();
-    }
-    // ============================================================================
-    // Consensus Integration Methods (MM-001)
-    // ============================================================================
-    /**
-     * Check if consensus engine is available
-     */
-    isConsensusAvailable() {
-        return this.consensusMixin.isConsensusAvailable?.() ?? false;
-    }
-    /**
-     * Get consensus statistics
-     * Per MM-001: Returns metrics about consensus verification
-     */
-    getConsensusStats() {
-        return this.consensusMixin.getConsensusStats();
-    }
     /**
      * Verify a code pattern detection using multi-model consensus
      * Per MM-001: High-stakes code intelligence decisions require verification
@@ -1429,110 +1007,13 @@ export class CodeIntelligenceCoordinator {
      * @returns true if the pattern is verified or doesn't require consensus
      */
     async verifyCodePatternDetection(pattern, confidence) {
-        const finding = createDomainFinding({
-            id: uuidv4(),
-            type: 'code-pattern-detection',
-            confidence,
-            description: `Verify code pattern: ${pattern.name} (${pattern.type}) at ${pattern.location}`,
-            payload: pattern,
-            detectedBy: 'code-intelligence-coordinator',
-            severity: confidence > 0.9 ? 'high' : 'medium',
-        });
-        if (this.consensusMixin.requiresConsensus(finding)) {
-            const result = await this.consensusMixin.verifyFinding(finding);
-            if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Code pattern '${pattern.name}' verified by consensus`);
-                return true;
-            }
-            console.warn(`[${this.domainName}] Code pattern '${pattern.name}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
-            return false;
-        }
-        return true; // No consensus needed
+        return ConsensusHelpers.verifyCodePatternDetection(pattern, confidence, this.consensusMixin, this.domainName);
     }
-    /**
-     * Verify an impact analysis using multi-model consensus
-     * Per MM-001: Impact analysis decisions can have significant deployment impact
-     *
-     * @param impact - The impact analysis to verify
-     * @param confidence - Initial confidence in the analysis
-     * @returns true if the analysis is verified or doesn't require consensus
-     */
     async verifyImpactAnalysis(impact, confidence) {
-        const finding = createDomainFinding({
-            id: uuidv4(),
-            type: 'impact-analysis',
-            confidence,
-            description: `Verify impact analysis: ${impact.changedFiles.length} files, risk=${impact.riskLevel}, ${impact.impactedTests.length} tests`,
-            payload: impact,
-            detectedBy: 'code-intelligence-coordinator',
-            severity: impact.riskLevel === 'critical' || impact.riskLevel === 'high' ? 'high' : 'medium',
-        });
-        if (this.consensusMixin.requiresConsensus(finding)) {
-            const result = await this.consensusMixin.verifyFinding(finding);
-            if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Impact analysis verified by consensus (risk=${impact.riskLevel})`);
-                return true;
-            }
-            console.warn(`[${this.domainName}] Impact analysis NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
-            return false;
-        }
-        return true; // No consensus needed
+        return ConsensusHelpers.verifyImpactAnalysis(impact, confidence, this.consensusMixin, this.domainName);
     }
-    /**
-     * Verify a dependency mapping using multi-model consensus
-     * Per MM-001: Dependency analysis can affect downstream decisions
-     *
-     * @param dependency - The dependency mapping to verify
-     * @param confidence - Initial confidence in the mapping
-     * @returns true if the mapping is verified or doesn't require consensus
-     */
     async verifyDependencyMapping(dependency, confidence) {
-        const finding = createDomainFinding({
-            id: uuidv4(),
-            type: 'dependency-mapping',
-            confidence,
-            description: `Verify dependency: ${dependency.source} -> ${dependency.targets.length} targets (${dependency.type})`,
-            payload: dependency,
-            detectedBy: 'code-intelligence-coordinator',
-            severity: confidence > 0.85 ? 'high' : 'medium',
-        });
-        if (this.consensusMixin.requiresConsensus(finding)) {
-            const result = await this.consensusMixin.verifyFinding(finding);
-            if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Dependency mapping verified by consensus`);
-                return true;
-            }
-            console.warn(`[${this.domainName}] Dependency mapping NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
-            return false;
-        }
-        return true; // No consensus needed
-    }
-    // ============================================================================
-    // Topology Routing Methods (ADR-047)
-    // ============================================================================
-    /**
-     * Get weak vertices belonging to this domain
-     * Per ADR-047: Identifies agents that are single points of failure
-     */
-    getDomainWeakVertices() {
-        return this.minCutMixin.getDomainWeakVertices();
-    }
-    /**
-     * Check if this domain is a weak point in the topology
-     * Per ADR-047: Returns true if any weak vertex belongs to code-intelligence domain
-     */
-    isDomainWeakPoint() {
-        return this.minCutMixin.isDomainWeakPoint();
-    }
-    /**
-     * Get topology-based routing excluding weak domains
-     * Per ADR-047: Filters out domains that are currently weak points
-     *
-     * @param targetDomains - List of potential target domains
-     * @returns Filtered list of healthy domains for routing
-     */
-    getTopologyBasedRouting(targetDomains) {
-        return this.minCutMixin.getTopologyBasedRouting(targetDomains);
+        return ConsensusHelpers.verifyDependencyMapping(dependency, confidence, this.consensusMixin, this.domainName);
     }
 }
 //# sourceMappingURL=coordinator.js.map