agentic-qe 3.3.2 → 3.3.3

package/v3/dist/domains/quality-assessment/coordinator.js

@@ -6,6 +6,10 @@
  * - ActorCritic RL: Quality gate threshold tuning
  * - QESONA: Quality pattern learning
  * - QEFlashAttention: Similarity computations for quality reports
+ *
+ * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
+ * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
+ * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../shared/types';
@@ -19,6 +23,11 @@ import { createPersistentSONAEngine } from '../../integrations/ruvector/sona-per
 import { createQEFlashAttention, } from '../../integrations/ruvector/wrappers';
 // V3 Integration: ClaimVerifier for report verification (Phase 4)
 import { createClaimVerifierService, } from '../../agents/claim-verifier/index.js';
+// V3 Integration: MinCut Awareness (ADR-047)
+import { createMinCutAwareMixin, } from '../../coordination/mixins/mincut-aware-domain';
+// V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+import { createConsensusEnabledMixin, } from '../../coordination/mixins/consensus-enabled-domain';
+import { createDomainFinding, } from '../../coordination/consensus/domain-findings';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 60000,
@@ -29,6 +38,14 @@ const DEFAULT_CONFIG = {
     enableFlashAttention: true,
     // V3: ClaimVerifier enabled by default
     enableClaimVerification: true,
+    // V3: MinCut Awareness enabled by default
+    enableMinCutAwareness: true,
+    topologyHealthThreshold: 0.5,
+    // V3: Consensus enabled by default for quality decisions
+    enableConsensus: true,
+    consensusThreshold: 0.7,
+    consensusMinModels: 2,
+    borderlineMargin: 0.05, // 5% margin for borderline detection
 };
 /**
  * Quality Assessment Coordinator
@@ -38,6 +55,10 @@ const DEFAULT_CONFIG = {
  * - ActorCritic RL: Quality gate threshold tuning
  * - QESONA: Quality pattern learning
  * - QEFlashAttention: Similarity computations for quality reports
+ *
+ * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
+ * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
+ * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
  */
 export class QualityAssessmentCoordinator {
     eventBus;
@@ -55,6 +76,10 @@ export class QualityAssessmentCoordinator {
     flashAttention;
     // V3 Integration: ClaimVerifier for report verification
     claimVerifier;
+    // V3 Integration: MinCut Awareness (ADR-047)
+    minCutMixin;
+    // V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+    consensusMixin;
     // Quality domain name for SONA
     domain = 'quality-assessment';
     // Cache of recent dream insights for quality assessment enhancement
@@ -67,10 +92,36 @@ export class QualityAssessmentCoordinator {
         this.qualityGate = new QualityGateService(memory);
         this.qualityAnalyzer = new QualityAnalyzerService(memory);
         this.deploymentAdvisor = new DeploymentAdvisorService(memory);
+        // V3 Integration: Initialize MinCut Awareness Mixin (ADR-047)
+        this.minCutMixin = createMinCutAwareMixin(this.domain, {
+            enableMinCutAwareness: this.config.enableMinCutAwareness,
+            topologyHealthThreshold: this.config.topologyHealthThreshold,
+            pauseOnCriticalTopology: false, // Quality assessment continues even in degraded topology
+            monitoredDomains: [], // Monitor all domains
+        });
+        // V3 Integration: Initialize Consensus Mixin (CONSENSUS-MIXIN-001)
+        // Configured for quality-assessment specific finding types
+        this.consensusMixin = createConsensusEnabledMixin({
+            enableConsensus: this.config.enableConsensus,
+            consensusThreshold: this.config.consensusThreshold,
+            minModels: this.config.consensusMinModels,
+            // Quality-specific finding types that require consensus
+            verifyFindingTypes: [
+                'gate-verdict', // Pass/fail quality gate decisions
+                'tech-debt-classification', // Critical vs acceptable tech debt
+                'release-readiness', // Go/no-go deployment decisions
+                'risk-scoring', // High-risk deployment detection
+            ],
+            strategy: 'weighted',
+            modelTimeout: 60000,
+            verifySeverities: ['critical', 'high'],
+            enableLogging: false,
+        });
     }
     /**
      * Initialize the coordinator
      * Sets up Ruvector integrations: ActorCritic, QESONA, QEFlashAttention
+     * V3: Also initializes MinCut awareness and Consensus verification
      */
     async initialize() {
         if (this.initialized)
@@ -96,6 +147,10 @@ export class QualityAssessmentCoordinator {
             if (this.config.enableClaimVerification) {
                 await this.initializeClaimVerifier();
             }
+            // V3 Integration: Initialize Consensus Engine (CONSENSUS-MIXIN-001)
+            if (this.config.enableConsensus) {
+                await this.initializeConsensus();
+            }
             this.initialized = true;
         }
         catch (error) {
@@ -103,8 +158,25 @@ export class QualityAssessmentCoordinator {
             throw new Error(errorMsg);
         }
     }
+    /**
+     * V3 Integration: Initialize the consensus engine for multi-model verification
+     * @private
+     */
+    async initializeConsensus() {
+        try {
+            // The mixin handles provider registration and engine creation
+            await this.consensusMixin.initializeConsensus();
+            console.log('[quality-assessment] Consensus engine initialized for quality gate decisions');
+        }
+        catch (error) {
+            // Log and continue - consensus is enhancement, not critical
+            console.warn('[quality-assessment] Failed to initialize consensus engine:', error);
+            console.warn('[quality-assessment] Continuing without multi-model consensus verification');
+        }
+    }
     /**
      * Dispose and cleanup
+     * V3: Also disposes MinCut mixin and Consensus engine
      */
     async dispose() {
         await this.saveWorkflowState();
@@ -115,6 +187,10 @@ export class QualityAssessmentCoordinator {
             await this.qesona.close();
             this.qesona = undefined;
         }
+        // V3 Integration: Dispose MinCut mixin (ADR-047)
+        this.minCutMixin.dispose();
+        // V3 Integration: Dispose Consensus engine (CONSENSUS-MIXIN-001)
+        await this.consensusMixin.disposeConsensus();
         this.workflows.clear();
         this.initialized = false;
     }
@@ -125,16 +201,90 @@ export class QualityAssessmentCoordinator {
         return Array.from(this.workflows.values()).filter((w) => w.status === 'running' || w.status === 'pending');
     }
     // ============================================================================
+    // V3 Integration: MinCut Awareness (ADR-047)
+    // ============================================================================
+    /**
+     * Set the MinCut bridge for topology awareness
+     * Uses dependency injection pattern for testability
+     *
+     * @param bridge - The QueenMinCutBridge instance
+     */
+    setMinCutBridge(bridge) {
+        this.minCutMixin.setMinCutBridge(bridge);
+    }
+    /**
+     * Check if the overall topology is healthy
+     * Returns true if status is not 'critical'
+     */
+    isTopologyHealthy() {
+        return this.minCutMixin.isTopologyHealthy();
+    }
+    /**
+     * Get domains that are healthy for routing
+     * Filters out weak domains from routing candidates
+     */
+    getHealthyRoutingDomains() {
+        return this.minCutMixin.getHealthyRoutingDomains();
+    }
+    /**
+     * Check if this domain itself is a weak point in the topology
+     */
+    isDomainWeakPoint() {
+        return this.minCutMixin.isDomainWeakPoint();
+    }
+    /**
+     * Get weak vertices belonging to this domain
+     * Per ADR-047: Identifies agents that are single points of failure
+     */
+    getDomainWeakVertices() {
+        return this.minCutMixin.getDomainWeakVertices();
+    }
+    /**
+     * Get topology-aware routing for cross-domain coordination
+     * Per ADR-047: Routes to healthy domains, avoiding weak points
+     */
+    getTopologyBasedRouting(targetDomains) {
+        return this.minCutMixin.getTopologyBasedRouting(targetDomains);
+    }
+    // ============================================================================
+    // V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+    // ============================================================================
+    /**
+     * Get consensus statistics
+     */
+    getConsensusStats() {
+        return this.consensusMixin.getConsensusStats();
+    }
+    /**
+     * Check if consensus verification is available
+     */
+    isConsensusAvailable() {
+        return this.consensusMixin.isConsensusAvailable();
+    }
+    // ============================================================================
     // QualityAssessmentAPI Implementation
     // ============================================================================
     /**
      * Evaluate a quality gate
      * Uses Actor-Critic RL for intelligent threshold tuning when enabled
+     * V3: Uses consensus verification for borderline gate decisions
      */
     async evaluateGate(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'gate-evaluation');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Quality gate evaluation paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Quality gate evaluation paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health before proceeding (ADR-047)
+            // Apply stricter thresholds when topology is degraded
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded - applying stricter thresholds for quality gate');
+                // Continue evaluation but with heightened caution - quality gates are critical
+            }
             // Spawn quality gate agent if available
             const agentResult = await this.spawnQualityGateAgent(workflowId, request);
             if (agentResult.success) {
@@ -161,22 +311,31 @@ export class QualityAssessmentCoordinator {
                 this.failWorkflow(workflowId, 'Evaluation failed');
                 return result;
             }
+            // V3 Integration: Use consensus for borderline cases (CONSENSUS-MIXIN-001)
+            // Borderline cases are pass/fail decisions where metrics are close to thresholds
+            let finalResult = result.value;
+            if (this.config.enableConsensus && this.isBorderlineGateResult(request.metrics, request.thresholds, result.value)) {
+                const consensusResult = await this.verifyGateVerdictWithConsensus(effectiveRequest, result.value);
+                if (consensusResult) {
+                    finalResult = consensusResult;
+                }
+            }
             // Success path
             this.completeWorkflow(workflowId);
             // Store quality pattern in SONA if enabled
             if (this.config.enableSONAPatternLearning && this.qesona) {
-                await this.storeQualityPattern(effectiveRequest, result.value);
+                await this.storeQualityPattern(effectiveRequest, finalResult);
             }
             // Train Actor-Critic with the result
             if (this.config.enableRLThresholdTuning && this.actorCritic) {
-                await this.trainActorCritic(effectiveRequest, result.value);
+                await this.trainActorCritic(effectiveRequest, finalResult);
             }
             // Publish event
             if (this.config.publishEvents) {
-                await this.publishQualityGateEvaluated(result.value);
+                await this.publishQualityGateEvaluated(finalResult);
             }
             // V3: Verify claims before returning (Phase 4)
-            const verifiedResult = await this.verifyGateResultClaims(result.value);
+            const verifiedResult = await this.verifyGateResultClaims(finalResult);
             return ok(verifiedResult);
         }
         catch (error) {
@@ -184,14 +343,118 @@ export class QualityAssessmentCoordinator {
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * V3 Integration: Check if a gate result is a borderline case
+     * A borderline case is when any metric is within the configured margin of its threshold
+     *
+     * @param metrics - The quality metrics being evaluated
+     * @param thresholds - The threshold configuration
+     * @param result - The gate result
+     * @returns true if this is a borderline case requiring consensus
+     */
+    isBorderlineGateResult(metrics, thresholds, result) {
+        const margin = this.config.borderlineMargin;
+        // Check each metric against its threshold
+        const metricsToCheck = [
+            { metricKey: 'coverage', thresholdKey: 'coverage', isMin: true },
+            { metricKey: 'testsPassing', thresholdKey: 'testsPassing', isMin: true },
+            { metricKey: 'criticalBugs', thresholdKey: 'criticalBugs', isMin: false },
+            { metricKey: 'codeSmells', thresholdKey: 'codeSmells', isMin: false },
+            { metricKey: 'securityVulnerabilities', thresholdKey: 'securityVulnerabilities', isMin: false },
+            { metricKey: 'technicalDebt', thresholdKey: 'technicalDebt', isMin: false },
+            { metricKey: 'duplications', thresholdKey: 'duplications', isMin: false },
+        ];
+        for (const { metricKey, thresholdKey, isMin } of metricsToCheck) {
+            const metricValue = metrics[metricKey];
+            const thresholdConfig = thresholds[thresholdKey];
+            if (thresholdConfig === undefined)
+                continue;
+            const threshold = isMin
+                ? thresholdConfig.min
+                : thresholdConfig.max;
+            if (threshold === undefined || threshold === 0)
+                continue;
+            // Calculate relative distance from threshold
+            const relativeDistance = Math.abs(metricValue - threshold) / threshold;
+            // If any metric is within margin of threshold, it's borderline
+            if (relativeDistance < margin) {
+                console.log(`[quality-assessment] Borderline detected: ${metricKey}=${metricValue} (threshold=${threshold}, distance=${(relativeDistance * 100).toFixed(1)}%)`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * V3 Integration: Verify a gate verdict with multi-model consensus
+     *
+     * @param request - The gate evaluation request
+     * @param initialResult - The initial gate result
+     * @returns The potentially modified result with consensus verification, or null if consensus unavailable
+     */
+    async verifyGateVerdictWithConsensus(request, initialResult) {
+        // Create a domain finding for the gate verdict
+        const finding = createDomainFinding({
+            id: `gate-verdict-${uuidv4()}`,
+            type: 'gate-verdict',
+            confidence: initialResult.overallScore / 100,
+            description: `Quality gate '${request.gateName}' verdict: ${initialResult.passed ? 'PASSED' : 'FAILED'} (borderline case)`,
+            payload: {
+                metrics: request.metrics,
+                thresholds: request.thresholds,
+                initialResult,
+            },
+            detectedBy: 'quality-assessment-coordinator',
+            severity: initialResult.passed ? 'medium' : 'high',
+        });
+        // Check if this finding requires consensus
+        if (!this.consensusMixin.requiresConsensus(finding)) {
+            return null;
+        }
+        try {
+            const consensusResult = await this.consensusMixin.verifyFinding(finding);
+            if (!consensusResult.success) {
+                console.warn('[quality-assessment] Consensus verification failed:', consensusResult.error);
+                return null;
+            }
+            const consensus = consensusResult.value;
+            console.log(`[quality-assessment] Consensus for gate '${request.gateName}': ` +
+                `verdict=${consensus.verdict}, confidence=${(consensus.confidence * 100).toFixed(1)}%`);
+            // Return result with consensus information
+            return {
+                ...initialResult,
+                // Add consensus metadata (extends GateResult)
+                consensusVerified: true,
+                consensusConfidence: consensus.confidence,
+                consensusVerdict: consensus.verdict,
+            };
+        }
+        catch (error) {
+            console.error('[quality-assessment] Consensus verification error:', error);
+            return null;
+        }
+    }
     /**
      * Analyze code quality
      * Uses QEFlashAttention for similarity-based recommendations when enabled
+     * V3: Includes topology-aware behavior based on MinCut health
      */
     async analyzeQuality(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'quality-analysis');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Quality analysis paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Quality analysis paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health and adjust behavior (ADR-047)
+            const topologyHealthy = this.isTopologyHealthy();
+            if (!topologyHealthy) {
+                console.warn('[quality-assessment] Topology degraded during quality analysis');
+                // Could adjust analysis depth or timeouts in degraded state
+                // For now, we proceed but could be extended to reduce analysis scope
+            }
             // Spawn quality analyzer agent
             const agentResult = await this.spawnQualityAnalyzerAgent(workflowId, request);
             if (agentResult.success) {
@@ -236,11 +499,22 @@ export class QualityAssessmentCoordinator {
     }
     /**
      * Get deployment recommendation
+     * V3: Uses consensus verification for high-risk deployment decisions
      */
     async getDeploymentAdvice(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'deployment-advice');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Deployment advice paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Deployment advice paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health (ADR-047)
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded during deployment advice generation');
+            }
             // Spawn deployment advisor agent
             const agentResult = await this.spawnDeploymentAdvisorAgent(workflowId, request);
             if (agentResult.success) {
@@ -256,19 +530,83 @@ export class QualityAssessmentCoordinator {
                 this.failWorkflow(workflowId, 'Evaluation failed');
                 return result;
             }
+            // V3 Integration: Use consensus for high-risk deployment decisions (CONSENSUS-MIXIN-001)
+            let finalAdvice = result.value;
+            if (this.config.enableConsensus && this.isHighRiskDeployment(request, result.value)) {
+                const consensusAdvice = await this.verifyDeploymentAdviceWithConsensus(request, result.value);
+                if (consensusAdvice) {
+                    finalAdvice = consensusAdvice;
+                }
+            }
             // Success path
             this.completeWorkflow(workflowId);
             // Publish deployment decision event
             if (this.config.publishEvents) {
-                await this.publishDeploymentDecision(result.value, request.releaseCandidate);
+                await this.publishDeploymentDecision(finalAdvice, request.releaseCandidate);
             }
-            return result;
+            return ok(finalAdvice);
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * V3 Integration: Check if a deployment is high-risk
+     * High-risk deployments include blocked deployments or low risk tolerance with warnings
+     */
+    isHighRiskDeployment(request, advice) {
+        // Blocked deployments are always high-risk
+        if (advice.decision === 'blocked') {
+            return true;
+        }
+        // Warning with low risk tolerance is high-risk
+        if (advice.decision === 'warning' && request.riskTolerance === 'low') {
+            return true;
+        }
+        // High risk score (>0.7) with any decision is high-risk
+        if (advice.riskScore > 0.7) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * V3 Integration: Verify deployment advice with multi-model consensus
+     */
+    async verifyDeploymentAdviceWithConsensus(request, initialAdvice) {
+        const finding = createDomainFinding({
+            id: `release-readiness-${uuidv4()}`,
+            type: 'release-readiness',
+            confidence: initialAdvice.confidence,
+            description: `Release readiness for '${request.releaseCandidate}': ${initialAdvice.decision} (risk: ${(initialAdvice.riskScore * 100).toFixed(0)}%)`,
+            payload: { request, initialAdvice },
+            detectedBy: 'quality-assessment-coordinator',
+            severity: initialAdvice.decision === 'blocked' ? 'critical' : 'high',
+        });
+        if (!this.consensusMixin.requiresConsensus(finding)) {
+            return null;
+        }
+        try {
+            const consensusResult = await this.consensusMixin.verifyFinding(finding);
+            if (!consensusResult.success) {
+                console.warn('[quality-assessment] Consensus verification for deployment failed:', consensusResult.error);
+                return null;
+            }
+            const consensus = consensusResult.value;
+            console.log(`[quality-assessment] Consensus for deployment '${request.releaseCandidate}': ` +
+                `verdict=${consensus.verdict}, confidence=${(consensus.confidence * 100).toFixed(1)}%`);
+            return {
+                ...initialAdvice,
+                consensusVerified: true,
+                consensusConfidence: consensus.confidence,
+                consensusVerdict: consensus.verdict,
+            };
+        }
+        catch (error) {
+            console.error('[quality-assessment] Consensus verification error:', error);
+            return null;
+        }
+    }
     /**
      * Analyze code complexity
      */
@@ -276,6 +614,16 @@ export class QualityAssessmentCoordinator {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'complexity-analysis');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Complexity analysis paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Complexity analysis paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health (ADR-047)
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded during complexity analysis');
+            }
             // Spawn complexity analyzer agent
             const agentResult = await this.spawnComplexityAnalyzerAgent(workflowId, request);
             if (agentResult.success) {