agentic-qe 3.6.7 → 3.6.9

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

@@ -10,26 +10,23 @@
  * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
  * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
  * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
+ *
+ * CQ-002: Extends BaseDomainCoordinator for lifecycle deduplication
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../shared/types';
+import { toError, toErrorMessage } from '../../shared/error-utils.js';
 import { QualityAssessmentEvents, LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events';
 import { QualityGateService, } from './services/quality-gate';
 import { QualityAnalyzerService, } from './services/quality-analyzer';
 import { DeploymentAdvisorService, } from './services/deployment-advisor';
-// Ruvector integrations
-import { ActorCriticAlgorithm } from '../../integrations/rl-suite/algorithms/actor-critic';
-import { createPersistentSONAEngine } from '../../integrations/ruvector/sona-persistence.js';
-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';
-// ADR-058: Governance-aware mixin for MemoryWriteGate integration
-import { createGovernanceAwareMixin, } from '../../coordination/mixins/governance-aware-domain.js';
+// CQ-004: Extracted modules
+import * as ReportHelpers from './coordinator-reports.js';
+import * as RLIntegration from './coordinator-rl-integration.js';
+import * as ClaimVerifierHelpers from './coordinator-claim-verifier.js';
+import * as GateEvalHelpers from './coordinator-gate-evaluation.js';
+// CQ-002: Base domain coordinator
+import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 60000,
@@ -43,9 +40,11 @@ const DEFAULT_CONFIG = {
     // V3: MinCut Awareness enabled by default
     enableMinCutAwareness: true,
     topologyHealthThreshold: 0.5,
+    pauseOnCriticalTopology: false,
     // V3: Consensus enabled by default for quality decisions
     enableConsensus: true,
     consensusThreshold: 0.7,
+    consensusStrategy: 'weighted',
     consensusMinModels: 2,
     borderlineMargin: 0.05, // 5% margin for borderline detection
 };
@@ -61,54 +60,28 @@ const DEFAULT_CONFIG = {
  * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
  * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
  * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
+ *
+ * CQ-002: Extends BaseDomainCoordinator
  */
-export class QualityAssessmentCoordinator {
-    eventBus;
+export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
-    config;
     qualityGate;
     qualityAnalyzer;
     deploymentAdvisor;
-    workflows = new Map();
-    initialized = false;
     // Ruvector integration instances
     actorCritic;
     qesona;
     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';
-    // ADR-058: Governance mixin for MemoryWriteGate integration
-    governanceMixin;
     // Cache of recent dream insights for quality assessment enhancement
     recentDreamInsights = [];
     constructor(eventBus, memory, agentCoordinator, config = {}) {
-        this.eventBus = eventBus;
-        this.memory = memory;
-        this.agentCoordinator = agentCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        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,
+        const fullConfig = { ...DEFAULT_CONFIG, ...config };
+        super(eventBus, 'quality-assessment', fullConfig, {
             // Quality-specific finding types that require consensus
             verifyFindingTypes: [
                 'gate-verdict', // Pass/fail quality gate decisions
@@ -116,22 +89,22 @@ export class QualityAssessmentCoordinator {
                 'release-readiness', // Go/no-go deployment decisions
                 'risk-scoring', // High-risk deployment detection
             ],
-            strategy: 'weighted',
-            modelTimeout: 60000,
-            verifySeverities: ['critical', 'high'],
-            enableLogging: false,
         });
-        // ADR-058: Initialize governance mixin for MemoryWriteGate integration
-        this.governanceMixin = createGovernanceAwareMixin(this.domain);
+        this.memory = memory;
+        this.agentCoordinator = agentCoordinator;
+        this.qualityGate = new QualityGateService(memory);
+        this.qualityAnalyzer = new QualityAnalyzerService(memory);
+        this.deploymentAdvisor = new DeploymentAdvisorService(memory);
     }
+    // ==========================================================================
+    // BaseDomainCoordinator Template Methods
+    // ==========================================================================
     /**
      * Initialize the coordinator
      * Sets up Ruvector integrations: ActorCritic, QESONA, QEFlashAttention
      * V3: Also initializes MinCut awareness and Consensus verification
      */
-    async initialize() {
-        if (this.initialized)
-            return;
+    async onInitialize() {
         try {
             // Subscribe to relevant events
             this.subscribeToEvents();
@@ -153,38 +126,17 @@ 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) {
-            const errorMsg = `Failed to initialize quality-assessment coordinator: ${error instanceof Error ? error.message : String(error)}`;
+            const errorMsg = `Failed to initialize quality-assessment coordinator: ${toErrorMessage(error)}`;
             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
+     * V3: Also disposes domain-specific resources
      */
-    async dispose() {
+    async onDispose() {
         await this.saveWorkflowState();
         // Dispose Flash Attention
         this.flashAttention?.dispose();
@@ -193,38 +145,16 @@ 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;
     }
     /**
-     * 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();
     }
     // ============================================================================
-    // V3 Integration: MinCut Awareness (ADR-047)
+    // V3 Integration: MinCut Awareness (ADR-047) — domain-specific extras
     // ============================================================================
-    /**
-     * 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
@@ -232,41 +162,6 @@ export class QualityAssessmentCoordinator {
     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
     // ============================================================================
@@ -346,7 +241,7 @@ export class QualityAssessmentCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -359,36 +254,7 @@ export class QualityAssessmentCoordinator {
      * @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;
+        return GateEvalHelpers.isBorderlineGateResult(metrics, thresholds, result, this.config.borderlineMargin);
     }
     /**
      * V3 Integration: Verify a gate verdict with multi-model consensus
@@ -398,46 +264,7 @@ export class QualityAssessmentCoordinator {
      * @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;
-        }
+        return GateEvalHelpers.verifyGateVerdictWithConsensus(request, initialResult, this.consensusMixin);
     }
     /**
      * Analyze code quality
@@ -500,7 +327,7 @@ export class QualityAssessmentCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -554,7 +381,7 @@ export class QualityAssessmentCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -562,56 +389,13 @@ export class QualityAssessmentCoordinator {
      * 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;
+        return GateEvalHelpers.isHighRiskDeployment(request, advice);
     }
     /**
      * 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;
-        }
+        return GateEvalHelpers.verifyDeploymentAdviceWithConsensus(request, initialAdvice, this.consensusMixin);
     }
     /**
      * Analyze code complexity
@@ -651,7 +435,7 @@ export class QualityAssessmentCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -660,80 +444,14 @@ export class QualityAssessmentCoordinator {
      * @returns Result containing the generated report content
      */
     async generateReport(options) {
-        try {
-            // Collect current quality metrics from memory or use defaults
-            const storedMetrics = await this.memory.get('quality-assessment:current-metrics');
-            const metrics = storedMetrics ?? {
-                coverage: 80,
-                testsPassing: 95,
-                criticalBugs: 0,
-                codeSmells: 5,
-                securityVulnerabilities: 0,
-                technicalDebt: 10,
-                duplications: 3,
-            };
-            // Build report content based on format
-            const reportData = {
-                timestamp: new Date().toISOString(),
-                metrics,
-                recommendations: options.includeRecommendations
-                    ? this.generateRecommendations(metrics)
-                    : undefined,
-            };
-            let content;
-            switch (options.format) {
-                case 'json':
-                    content = JSON.stringify(reportData, null, 2);
-                    break;
-                case 'html':
-                    content = this.formatAsHtml(reportData);
-                    break;
-                case 'markdown':
-                    content = this.formatAsMarkdown(reportData);
-                    break;
-                default:
-                    content = JSON.stringify(reportData, null, 2);
-            }
-            return ok({ content, format: options.format });
-        }
-        catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
-        }
+        return ReportHelpers.generateReport(this.memory, options);
     }
     /**
      * Get quality dashboard overview
      * @returns Result containing dashboard data
      */
     async getQualityDashboard() {
-        try {
-            const storedMetrics = await this.memory.get('quality-assessment:current-metrics');
-            const metrics = storedMetrics ?? {
-                coverage: 80,
-                testsPassing: 95,
-                criticalBugs: 0,
-                codeSmells: 5,
-                securityVulnerabilities: 0,
-                technicalDebt: 10,
-                duplications: 3,
-            };
-            // Calculate overall score (weighted average)
-            const overallScore = Math.round((metrics.coverage * 0.3) +
-                (metrics.testsPassing * 0.3) +
-                ((100 - Math.min(100, metrics.codeSmells)) * 0.2) +
-                ((100 - Math.min(100, metrics.securityVulnerabilities * 10)) * 0.2));
-            return ok({
-                overallScore,
-                metrics,
-                trends: {
-                    coverage: 0,
-                    quality: 0,
-                    security: 0,
-                },
-            });
-        }
-        catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
-        }
+        return ReportHelpers.getQualityDashboard(this.memory);
     }
     /**
      * Analyze project risks
@@ -741,71 +459,7 @@ export class QualityAssessmentCoordinator {
      * @returns Result containing identified risks
      */
     async analyzeRisks(options) {
-        try {
-            const storedMetrics = await this.memory.get('quality-assessment:current-metrics');
-            const metrics = storedMetrics ?? {
-                coverage: 80,
-                testsPassing: 95,
-                criticalBugs: 0,
-                codeSmells: 5,
-                securityVulnerabilities: 0,
-                technicalDebt: 10,
-                duplications: 3,
-            };
-            const risks = [];
-            // Check coverage risk
-            if (metrics.coverage < 50) {
-                risks.push({
-                    id: 'risk-coverage-critical',
-                    severity: 'critical',
-                    description: 'Code coverage is critically low',
-                    category: 'quality',
-                });
-            }
-            else if (metrics.coverage < 70) {
-                risks.push({
-                    id: 'risk-coverage-high',
-                    severity: 'high',
-                    description: 'Code coverage is below recommended threshold',
-                    category: 'quality',
-                });
-            }
-            // Check security risks
-            if (options.includeSecurityRisks && metrics.securityVulnerabilities > 0) {
-                risks.push({
-                    id: 'risk-security',
-                    severity: metrics.securityVulnerabilities > 5 ? 'critical' : 'high',
-                    description: `${metrics.securityVulnerabilities} security vulnerabilities detected`,
-                    category: 'security',
-                });
-            }
-            // Check technical debt
-            if (metrics.technicalDebt > 40) {
-                risks.push({
-                    id: 'risk-debt-critical',
-                    severity: 'high',
-                    description: 'Technical debt is critically high',
-                    category: 'maintainability',
-                });
-            }
-            // Determine overall risk level
-            const criticalCount = risks.filter((r) => r.severity === 'critical').length;
-            const highCount = risks.filter((r) => r.severity === 'high').length;
-            let overallRiskLevel = 'low';
-            if (criticalCount > 0) {
-                overallRiskLevel = 'critical';
-            }
-            else if (highCount > 1) {
-                overallRiskLevel = 'high';
-            }
-            else if (highCount > 0 || risks.length > 2) {
-                overallRiskLevel = 'medium';
-            }
-            return ok({ risks, overallRiskLevel });
-        }
-        catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
-        }
+        return ReportHelpers.analyzeRisks(this.memory, options);
     }
     /**
      * Evaluate a quality gate (simplified API)
@@ -813,29 +467,7 @@ export class QualityAssessmentCoordinator {
      * @returns Result containing gate evaluation
      */
     async evaluateQualityGate(options) {
-        // Build full metrics with defaults
-        const fullMetrics = {
-            coverage: options.metrics.coverage ?? 80,
-            testsPassing: options.metrics.testsPassing ?? 95,
-            criticalBugs: options.metrics.criticalBugs ?? 0,
-            codeSmells: options.metrics.codeSmells ?? 5,
-            securityVulnerabilities: options.metrics.securityVulnerabilities ?? 0,
-            technicalDebt: options.metrics.technicalDebt ?? 10,
-            duplications: options.metrics.duplications ?? 3,
-        };
-        // Build evaluation request
-        const request = {
-            gateName: options.gateId,
-            metrics: fullMetrics,
-            thresholds: {
-                coverage: { min: 70 },
-                testsPassing: { min: 90 },
-                criticalBugs: { max: 0 },
-                codeSmells: { max: 20 },
-                securityVulnerabilities: { max: 0 },
-            },
-        };
-        // Delegate to existing evaluateGate method
+        const request = ReportHelpers.buildFullGateRequest(options);
         const result = await this.evaluateGate(request);
         if (!result.success) {
             return err(result.error);
@@ -852,52 +484,7 @@ export class QualityAssessmentCoordinator {
      * @returns Result containing readiness assessment
      */
     async assessDeploymentReadiness(options) {
-        try {
-            const storedMetrics = await this.memory.get('quality-assessment:current-metrics');
-            const metrics = storedMetrics ?? {
-                coverage: 80,
-                testsPassing: 95,
-                criticalBugs: 0,
-                codeSmells: 5,
-                securityVulnerabilities: 0,
-                technicalDebt: 10,
-                duplications: 3,
-            };
-            const risks = [];
-            // Check for production-specific risks
-            if (options.environment === 'production') {
-                if (metrics.coverage < 70) {
-                    risks.push({
-                        id: 'risk-coverage',
-                        severity: 'high',
-                        description: 'Coverage below recommended threshold for production',
-                    });
-                }
-                if (metrics.securityVulnerabilities > 0) {
-                    risks.push({
-                        id: 'risk-security',
-                        severity: 'critical',
-                        description: 'Security vulnerabilities must be resolved before production deployment',
-                    });
-                }
-                if (metrics.criticalBugs > 0) {
-                    risks.push({
-                        id: 'risk-bugs',
-                        severity: 'critical',
-                        description: 'Critical bugs must be resolved before production deployment',
-                    });
-                }
-            }
-            // Calculate readiness score
-            const score = Math.round((metrics.coverage * 0.4) +
-                (metrics.testsPassing * 0.3) +
-                ((100 - Math.min(100, metrics.securityVulnerabilities * 20)) * 0.3));
-            const ready = risks.filter((r) => r.severity === 'critical').length === 0 && score >= 70;
-            return ok({ ready, risks, score });
-        }
-        catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
-        }
+        return ReportHelpers.assessDeploymentReadiness(this.memory, options);
     }
     /**
      * Analyze technical debt
@@ -905,64 +492,7 @@ export class QualityAssessmentCoordinator {
      * @returns Result containing debt analysis
      */
     async analyzeTechnicalDebt(options) {
-        try {
-            const storedMetrics = await this.memory.get('quality-assessment:current-metrics');
-            const metrics = storedMetrics ?? {
-                coverage: 80,
-                testsPassing: 95,
-                criticalBugs: 0,
-                codeSmells: 5,
-                securityVulnerabilities: 0,
-                technicalDebt: 10,
-                duplications: 3,
-            };
-            const items = [];
-            // Generate sample debt items based on metrics
-            if (metrics.duplications > 0) {
-                items.push({
-                    file: `${options.projectPath}/src/utils/helpers.ts`,
-                    type: 'duplication',
-                    effort: metrics.duplications * 30,
-                    description: 'Duplicated code blocks that should be refactored',
-                });
-            }
-            if (options.includeCodeSmells && metrics.codeSmells > 0) {
-                items.push({
-                    file: `${options.projectPath}/src/services/legacy.ts`,
-                    type: 'code-smell',
-                    effort: metrics.codeSmells * 15,
-                    description: 'Code smells that impact maintainability',
-                });
-            }
-            const totalDebt = metrics.technicalDebt;
-            const debtRatio = totalDebt / 100;
-            return ok({ totalDebt, items, debtRatio });
-        }
-        catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    generateRecommendations(metrics) {
-        const recommendations = [];
-        if (metrics.coverage < 80) {
-            recommendations.push('Increase test coverage to at least 80%');
-        }
-        if (metrics.codeSmells > 10) {
-            recommendations.push('Refactor complex code to improve maintainability');
-        }
-        if (metrics.technicalDebt > 20) {
-            recommendations.push('Allocate time to reduce technical debt');
-        }
-        if (metrics.securityVulnerabilities > 0) {
-            recommendations.push('Address security vulnerabilities urgently');
-        }
-        return recommendations;
-    }
-    formatAsHtml(data) {
-        return `<html><body><pre>${JSON.stringify(data, null, 2)}</pre></body></html>`;
-    }
-    formatAsMarkdown(data) {
-        return `# Quality Report\n\n\`\`\`json\n${JSON.stringify(data, null, 2)}\n\`\`\``;
+        return ReportHelpers.analyzeTechnicalDebt(this.memory, options);
     }
     // ============================================================================
     // Agent Spawning Methods
@@ -1064,45 +594,6 @@ export class QualityAssessmentCoordinator {
         await this.eventBus.publish(event);
     }
     // ============================================================================
-    // Workflow Management
-    // ============================================================================
-    startWorkflow(id, type) {
-        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);
-        }
-    }
-    // ============================================================================
     // Event Handling
     // ============================================================================
     subscribeToEvents() {
@@ -1223,31 +714,8 @@ export class QualityAssessmentCoordinator {
         }, { namespace: this.domain, ttl: 86400 * 7 } // 7 days
         );
     }
-    /**
-     * Encode a dream insight as feature vector for SONA pattern creation.
-     */
     encodeInsightAsFeatures(insight) {
-        const features = [];
-        // Encode insight type
-        const typeMap = {
-            pattern_merge: 0.2,
-            novel_association: 0.4,
-            optimization: 0.6,
-            gap_detection: 0.8,
-        };
-        features.push(typeMap[insight.type] || 0.5);
-        // Encode confidence and novelty
-        features.push(insight.confidenceScore);
-        features.push(insight.noveltyScore);
-        // Encode actionability
-        features.push(insight.actionable ? 1.0 : 0.0);
-        // Encode source concept count (normalized)
-        features.push(Math.min(1, insight.sourceConcepts.length / 10));
-        // Pad to consistent size
-        while (features.length < 384) {
-            features.push(0);
-        }
-        return features.slice(0, 384);
+        return RLIntegration.encodeInsightAsFeatures(insight);
     }
     async handleTestRunCompleted(event) {
         // Auto-evaluate quality gate after test run if enabled
@@ -1294,319 +762,38 @@ export class QualityAssessmentCoordinator {
      * Initialize Actor-Critic RL for quality gate threshold tuning
      */
     async initializeActorCritic() {
-        try {
-            this.actorCritic = new ActorCriticAlgorithm({
-                stateSize: 10, // Quality metrics feature size
-                actionSize: 4, // Threshold adjustment actions
-                actorHiddenLayers: [64, 64],
-                criticHiddenLayers: [64, 64],
-                actorLR: 0.0001,
-                criticLR: 0.001,
-                entropyCoeff: 0.01,
-            });
-            // ActorCriticAlgorithm initializes automatically on first predict/train call
-            // No need to call initialize() as it's protected
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize Actor-Critic RL: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        this.actorCritic = await RLIntegration.initializeActorCritic();
     }
-    /**
-     * Initialize PersistentSONAEngine for quality pattern learning (patterns survive restarts)
-     */
     async initializeQESONA() {
-        try {
-            this.qesona = await createPersistentSONAEngine({
-                domain: 'quality-assessment',
-                loadOnInit: true,
-                autoSaveInterval: 60000, // Save every minute
-                hiddenDim: 256,
-                embeddingDim: 384,
-                microLoraRank: 1,
-                baseLoraRank: 8,
-                minConfidence: 0.5,
-                maxPatterns: 5000,
-            });
-            console.log('[quality-assessment] PersistentSONAEngine initialized successfully');
-        }
-        catch (error) {
-            // Log and continue - SONA is enhancement, not critical
-            console.error('[quality-assessment] Failed to initialize PersistentSONAEngine:', error);
-            console.warn('[quality-assessment] Continuing without SONA pattern persistence');
-            this.qesona = undefined;
-        }
+        this.qesona = await RLIntegration.initializeQESONA();
     }
-    /**
-     * Initialize QEFlashAttention for similarity computations
-     */
     async initializeFlashAttention() {
-        try {
-            this.flashAttention = await createQEFlashAttention('pattern-adaptation', {
-                dim: 384,
-                strategy: 'flash',
-                blockSize: 32,
-            });
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize QEFlashAttention: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        this.flashAttention = await RLIntegration.initializeFlashAttention();
     }
-    /**
-     * Use Actor-Critic RL to predict optimal quality gate thresholds
-     */
     async tuneThresholdsWithRL(metrics) {
         if (!this.actorCritic)
             return null;
-        try {
-            // Create RL state from quality metrics
-            const state = {
-                id: `quality-state-${Date.now()}`,
-                features: [
-                    metrics.coverage / 100,
-                    metrics.testsPassing / 100,
-                    metrics.criticalBugs / 10,
-                    metrics.codeSmells / 50,
-                    metrics.securityVulnerabilities / 10,
-                    metrics.technicalDebt / 20,
-                    metrics.duplications / 20,
-                ],
-            };
-            // Get action from Actor-Critic
-            const prediction = await this.actorCritic.predict(state);
-            // Apply action to adjust thresholds
-            const baseThresholds = {
-                coverage: { min: 80 },
-                testsPassing: { min: 95 },
-                criticalBugs: { max: 0 },
-                codeSmells: { max: 20 },
-                securityVulnerabilities: { max: 0 },
-                technicalDebt: { max: 5 },
-                duplications: { max: 5 },
-            };
-            const tunedThresholds = this.applyActionToThresholds(baseThresholds, prediction.action);
-            return {
-                thresholds: tunedThresholds,
-                confidence: prediction.confidence,
-                reasoning: prediction.reasoning ?? '',
-            };
-        }
-        catch (error) {
-            console.error('RL threshold tuning failed:', error);
-            return null;
-        }
-    }
-    /**
-     * Apply RL action to threshold adjustments
-     */
-    applyActionToThresholds(thresholds, action) {
-        const adjusted = { ...thresholds };
-        if (action.type === 'adjust-threshold' && typeof action.value === 'number') {
-            const delta = action.value * 5; // Scale adjustment
-            // Adjust coverage threshold
-            if (adjusted.coverage?.min !== undefined) {
-                adjusted.coverage.min = Math.max(50, Math.min(100, adjusted.coverage.min + delta));
-            }
-            // Adjust code smells threshold
-            if (adjusted.codeSmells?.max !== undefined) {
-                adjusted.codeSmells.max = Math.max(0, Math.min(100, adjusted.codeSmells.max - delta));
-            }
-        }
-        return adjusted;
+        return RLIntegration.tuneThresholdsWithRL(this.actorCritic, metrics);
     }
-    /**
-     * Train Actor-Critic with quality gate evaluation results
-     */
     async trainActorCritic(request, result) {
         if (!this.actorCritic)
             return;
-        try {
-            // Create state from metrics
-            const state = {
-                id: `quality-state-${Date.now()}`,
-                features: [
-                    request.metrics.coverage / 100,
-                    request.metrics.testsPassing / 100,
-                    request.metrics.criticalBugs / 10,
-                    request.metrics.codeSmells / 50,
-                    request.metrics.securityVulnerabilities / 10,
-                    request.metrics.technicalDebt / 20,
-                    request.metrics.duplications / 20,
-                ],
-            };
-            // Define action as the threshold configuration used
-            const action = {
-                type: 'evaluate-gate',
-                value: result.overallScore,
-            };
-            // Create next state (same for now, could be next evaluation)
-            const nextState = { ...state };
-            // Calculate reward based on gate result
-            let reward = 0;
-            if (result.passed) {
-                reward += result.overallScore / 100;
-                // Bonus for high score
-                if (result.overallScore >= 90)
-                    reward += 0.5;
-                if (result.overallScore >= 95)
-                    reward += 0.5;
-            }
-            else {
-                reward -= 0.5;
-                // Penalty for failing critical checks
-                const criticalFailures = result.checks.filter(c => !c.passed && c.severity === 'critical').length;
-                reward -= criticalFailures * 0.2;
-            }
-            // Create experience
-            const experience = {
-                state,
-                action,
-                nextState,
-                reward: Math.max(-1, Math.min(1, reward)),
-                done: true,
-            };
-            // Train Actor-Critic (train() expects a single experience)
-            await this.actorCritic.train(experience);
-        }
-        catch (error) {
-            console.error('Actor-Critic training failed:', error);
-        }
+        await RLIntegration.trainActorCritic(this.actorCritic, request, result);
     }
-    /**
-     * Store quality gate pattern in SONA for learning
-     */
     async storeQualityPattern(request, result) {
         if (!this.qesona)
             return;
-        try {
-            const state = {
-                id: `quality-state-${Date.now()}`,
-                features: [
-                    request.metrics.coverage,
-                    request.metrics.testsPassing,
-                    request.metrics.criticalBugs,
-                    request.metrics.codeSmells,
-                    request.metrics.securityVulnerabilities,
-                    request.metrics.technicalDebt,
-                    request.metrics.duplications,
-                ],
-            };
-            const action = {
-                type: 'quality-gate-evaluation',
-                value: result.passed ? 1 : 0,
-            };
-            this.qesona.createPattern(state, action, {
-                reward: result.passed ? result.overallScore / 100 : -0.5,
-                success: result.passed,
-                quality: result.overallScore / 100,
-            }, 'quality-assessment', this.domain, {
-                gateName: request.gateName,
-                overallScore: result.overallScore,
-                failedChecks: result.failedChecks,
-            });
-        }
-        catch (error) {
-            console.error('Failed to store quality pattern in SONA:', error);
-        }
+        await RLIntegration.storeQualityPattern(this.qesona, request, result, this.domain);
     }
-    /**
-     * Store quality analysis pattern in SONA
-     */
     async storeQualityAnalysisPattern(request, report) {
         if (!this.qesona)
             return;
-        try {
-            const state = {
-                id: `quality-analysis-${Date.now()}`,
-                features: [
-                    report.score.overall,
-                    report.score.coverage,
-                    report.score.complexity,
-                    report.score.maintainability,
-                    report.metrics.length,
-                    request.sourceFiles.length,
-                ],
-            };
-            const action = {
-                type: 'quality-analysis',
-                value: report.score.overall,
-            };
-            this.qesona.createPattern(state, action, {
-                reward: report.score.overall / 100,
-                success: report.score.overall >= 70,
-                quality: report.score.overall / 100,
-            }, 'quality-assessment', this.domain, {
-                sourceFileCount: request.sourceFiles.length,
-                recommendationCount: report.recommendations.length,
-            });
-        }
-        catch (error) {
-            console.error('Failed to store quality analysis pattern in SONA:', error);
-        }
+        await RLIntegration.storeQualityAnalysisPattern(this.qesona, request, report, this.domain);
     }
-    /**
-     * Enhance quality report with similarity-based pattern matching using Flash Attention
-     */
     async enhanceWithSimilarityPatterns(report) {
         if (!this.flashAttention || !this.qesona)
             return null;
-        try {
-            // Create embedding from quality metrics
-            const metricsEmbedding = this.createMetricsEmbedding(report);
-            // Find similar historical patterns using SONA
-            const state = {
-                id: `similarity-search-${Date.now()}`,
-                features: [
-                    report.score.overall,
-                    report.score.coverage,
-                    report.score.complexity,
-                    report.score.maintainability,
-                ],
-            };
-            const adaptation = await this.qesona.adaptPattern(state, 'quality-assessment', this.domain);
-            if (!adaptation.success || !adaptation.pattern) {
-                return null;
-            }
-            // Add insights from similar patterns to recommendations
-            const additionalRecommendations = [];
-            if (adaptation.pattern.metadata) {
-                const meta = adaptation.pattern.metadata;
-                if (meta.similarIssues && meta.similarIssues.length > 0) {
-                    additionalRecommendations.push({
-                        type: 'improvement',
-                        title: 'Similar Quality Patterns Found',
-                        description: `Found ${adaptation.similarity.toFixed(0)}% similar historical patterns: ${meta.similarIssues.slice(0, 3).join(', ')}`,
-                        impact: 'medium',
-                        effort: 'low',
-                    });
-                }
-            }
-            return {
-                ...report,
-                recommendations: [...report.recommendations, ...additionalRecommendations],
-            };
-        }
-        catch (error) {
-            console.error('Failed to enhance with similarity patterns:', error);
-            return null;
-        }
-    }
-    /**
-     * Create embedding from quality metrics for similarity search
-     */
-    createMetricsEmbedding(report) {
-        const features = [
-            report.score.overall / 100,
-            report.score.coverage / 100,
-            report.score.complexity / 100,
-            report.score.maintainability / 100,
-            report.score.security / 100,
-            ...report.metrics.map(m => m.value / 100),
-        ];
-        // Pad to 384 dimensions
-        while (features.length < 384) {
-            features.push(0);
-        }
-        return new Float32Array(features.slice(0, 384));
+        return RLIntegration.enhanceWithSimilarityPatterns(report, this.flashAttention, this.qesona, this.domain);
     }
     // ============================================================================
     // V3 Integration: ClaimVerifier Methods (Phase 4)
@@ -1615,170 +802,19 @@ export class QualityAssessmentCoordinator {
      * Initialize ClaimVerifier for report verification
      */
     async initializeClaimVerifier() {
-        try {
-            const rootDir = this.config.claimVerifierRootDir || process.cwd();
-            this.claimVerifier = createClaimVerifierService({
-                rootDir,
-                verifier: {
-                    enableStatistics: true,
-                    enableMultiModel: false, // Use consensus engine separately for multi-model
-                    defaultConfidenceThreshold: 0.7,
-                },
-            });
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize ClaimVerifier: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        this.claimVerifier = await ClaimVerifierHelpers.initializeClaimVerifier(this.config.claimVerifierRootDir);
     }
-    /**
-     * Verify a quality report's claims before returning
-     *
-     * Converts QualityReport to QEReport format and verifies all claims.
-     * Adds verification metadata to the report.
-     *
-     * @param report - The quality report to verify
-     * @returns The report with verification status, or original if verification disabled/fails
-     */
     async verifyQualityReportClaims(report) {
         if (!this.config.enableClaimVerification || !this.claimVerifier) {
             return report;
         }
-        try {
-            // Convert QualityReport to QEReport format
-            const qeReport = this.convertToQEReport(report, 'quality-analysis');
-            if (qeReport.claims.length === 0) {
-                return report;
-            }
-            // Verify the report
-            const verification = await this.claimVerifier.verifyReport(qeReport);
-            if (!verification.success) {
-                console.warn('[QualityAssessment] Claim verification failed:', verification.error);
-                return report;
-            }
-            // Annotate report with verification status
-            return {
-                ...report,
-                claimVerification: {
-                    verified: verification.value.passed,
-                    confidence: verification.value.overallConfidence,
-                    unverifiedClaims: verification.value.flaggedClaims.length,
-                },
-            };
-        }
-        catch (error) {
-            console.error('[QualityAssessment] Failed to verify report claims:', error);
-            return report;
-        }
+        return ClaimVerifierHelpers.verifyQualityReportClaims(report, this.claimVerifier);
     }
-    /**
-     * Verify a gate result's claims before returning
-     */
     async verifyGateResultClaims(result) {
         if (!this.config.enableClaimVerification || !this.claimVerifier) {
             return result;
         }
-        try {
-            // Convert GateResult to QEReport format
-            const qeReport = this.convertGateResultToQEReport(result);
-            if (qeReport.claims.length === 0) {
-                return result;
-            }
-            // Verify the report
-            const verification = await this.claimVerifier.verifyReport(qeReport);
-            if (!verification.success) {
-                console.warn('[QualityAssessment] Gate claim verification failed:', verification.error);
-                return result;
-            }
-            // Annotate result with verification status
-            return {
-                ...result,
-                claimVerification: {
-                    verified: verification.value.passed,
-                    confidence: verification.value.overallConfidence,
-                    unverifiedClaims: verification.value.flaggedClaims.length,
-                },
-            };
-        }
-        catch (error) {
-            console.error('[QualityAssessment] Failed to verify gate claims:', error);
-            return result;
-        }
-    }
-    /**
-     * Convert QualityReport to QEReport format for claim verification
-     */
-    convertToQEReport(report, type) {
-        const claims = [];
-        // Extract claims from metrics
-        for (const metric of report.metrics) {
-            claims.push({
-                id: `metric-${metric.name}-${Date.now()}`,
-                type: 'metric-count',
-                statement: `Metric ${metric.name} = ${metric.value}`,
-                evidence: [],
-                sourceAgent: 'quality-analyzer',
-                sourceAgentType: 'analyzer',
-                severity: metric.value < 50 ? 'high' : metric.value < 70 ? 'medium' : 'low',
-                timestamp: new Date(),
-                metadata: {
-                    name: metric.name,
-                    value: metric.value,
-                },
-            });
-        }
-        // Extract claims from score
-        if (report.score.coverage < 80) {
-            claims.push({
-                id: `coverage-${Date.now()}`,
-                type: 'coverage-claim',
-                statement: `Code coverage is ${report.score.coverage}%`,
-                evidence: [],
-                sourceAgent: 'quality-analyzer',
-                sourceAgentType: 'analyzer',
-                severity: report.score.coverage < 50 ? 'critical' : 'high',
-                timestamp: new Date(),
-                metadata: { coverage: report.score.coverage },
-            });
-        }
-        return {
-            id: `quality-report-${Date.now()}`,
-            type,
-            claims,
-            generatedAt: new Date(),
-            sourceAgent: 'quality-assessment-coordinator',
-        };
-    }
-    /**
-     * Convert GateResult to QEReport format for claim verification
-     */
-    convertGateResultToQEReport(result) {
-        const claims = [];
-        // Extract claims from checks
-        for (const check of result.checks) {
-            claims.push({
-                id: `gate-check-${check.name}-${Date.now()}`,
-                type: 'metric-count',
-                statement: `Gate check '${check.name}': ${check.value} (threshold: ${check.threshold})`,
-                evidence: [],
-                sourceAgent: 'quality-gate',
-                sourceAgentType: 'validator',
-                severity: check.passed ? 'low' : check.severity || 'medium',
-                timestamp: new Date(),
-                metadata: {
-                    checkName: check.name,
-                    value: check.value,
-                    threshold: check.threshold,
-                    passed: check.passed,
-                },
-            });
-        }
-        return {
-            id: `gate-result-${Date.now()}`,
-            type: 'gate-evaluation',
-            claims,
-            generatedAt: new Date(),
-            sourceAgent: 'quality-assessment-coordinator',
-        };
+        return ClaimVerifierHelpers.verifyGateResultClaims(result, this.claimVerifier);
     }
     /**
      * Get ClaimVerifier statistics