agentic-qe 3.3.2 → 3.3.4

package/v3/dist/coordination/mixins/consensus-enabled-domain.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Agentic QE v3 - Consensus Enabled Domain Mixin
+ * CONSENSUS-MIXIN-001: Reusable mixin for multi-model consensus verification
+ *
+ * This mixin allows any domain coordinator to leverage multi-model consensus
+ * verification for high-stakes decisions without duplicating consensus logic.
+ *
+ * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 2: Multi-Model Verification
+ */
+import { ConsensusEngine, ConsensusResult, ConsensusStats as ConsensusStatsType, VerificationOptions } from '../consensus';
+export type { ConsensusStats } from '../consensus';
+import { DomainFinding, FindingSeverity } from '../consensus/domain-findings';
+import { Result } from '../../shared/types';
+/**
+ * Configuration for consensus-enabled domains
+ */
+export interface ConsensusEnabledConfig {
+    /** Whether to enable consensus verification */
+    readonly enableConsensus: boolean;
+    /** Minimum confidence threshold requiring consensus verification */
+    readonly consensusThreshold: number;
+    /** Finding types that require consensus verification */
+    readonly verifyFindingTypes: string[];
+    /** Consensus strategy to use */
+    readonly strategy: 'majority' | 'weighted' | 'unanimous';
+    /** Minimum number of models required for consensus */
+    readonly minModels: number;
+    /** Timeout per model in milliseconds */
+    readonly modelTimeout: number;
+    /** Severity levels requiring consensus */
+    readonly verifySeverities: FindingSeverity[];
+    /** Enable logging for consensus operations */
+    readonly enableLogging: boolean;
+}
+/**
+ * Default consensus configuration
+ */
+export declare const DEFAULT_CONSENSUS_ENABLED_CONFIG: ConsensusEnabledConfig;
+/**
+ * Interface for consensus-enabled domain coordinators
+ */
+export interface IConsensusEnabledDomain {
+    /**
+     * Verify a single finding using multi-model consensus
+     *
+     * @param finding - The finding to verify
+     * @param options - Optional verification options
+     * @returns Promise resolving to consensus result
+     */
+    verifyFinding<T>(finding: DomainFinding<T>, options?: VerificationOptions): Promise<Result<ConsensusResult, Error>>;
+    /**
+     * Check if a finding requires consensus verification
+     *
+     * @param finding - The finding to check
+     * @returns true if consensus verification is required
+     */
+    requiresConsensus<T>(finding: DomainFinding<T>): boolean;
+    /**
+     * Verify multiple findings in batch
+     *
+     * @param findings - Array of findings to verify
+     * @param options - Optional verification options
+     * @returns Promise resolving to array of consensus results
+     */
+    verifyFindings<T>(findings: DomainFinding<T>[], options?: VerificationOptions): Promise<Result<ConsensusResult[], Error>>;
+    /**
+     * Get consensus statistics
+     *
+     * @returns Current consensus statistics
+     */
+    getConsensusStats(): ConsensusStatsType | undefined;
+}
+/**
+ * Mixin class that adds consensus verification capabilities to any domain coordinator
+ *
+ * This is designed to be used with TypeScript's class composition pattern.
+ * Domain coordinators can extend this mixin to gain consensus verification capabilities.
+ *
+ * @example
+ * ```typescript
+ * class MyDomainCoordinator extends ConsensusEnabledMixin {
+ *   constructor(config: MyConfig) {
+ *     super({
+ *       enableConsensus: true,
+ *       consensusThreshold: 0.8,
+ *       verifyFindingTypes: ['vulnerability', 'defect'],
+ *       strategy: 'weighted',
+ *       minModels: 2,
+ *       modelTimeout: 30000,
+ *       verifySeverities: ['critical', 'high'],
+ *       enableLogging: true,
+ *     });
+ *   }
+ *
+ *   async initialize(): Promise<void> {
+ *     await this.initializeConsensus();
+ *     // ... other initialization
+ *   }
+ *
+ *   async dispose(): Promise<void> {
+ *     await this.disposeConsensus();
+ *     // ... other cleanup
+ *   }
+ *
+ *   async processFindings(findings: DomainFinding[]): Promise<void> {
+ *     for (const finding of findings) {
+ *       if (this.requiresConsensus(finding)) {
+ *         const result = await this.verifyFinding(finding);
+ *         if (result.success && result.value.verdict === 'verified') {
+ *           // Take action on verified finding
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class ConsensusEnabledMixin implements IConsensusEnabledDomain {
+    protected readonly consensusConfig: ConsensusEnabledConfig;
+    protected consensusEngine: ConsensusEngine | undefined;
+    protected consensusInitialized: boolean;
+    /**
+     * Create a new ConsensusEnabledMixin
+     *
+     * @param config - Configuration for consensus verification
+     */
+    constructor(config?: Partial<ConsensusEnabledConfig>);
+    /**
+     * Initialize the consensus engine
+     *
+     * Call this in the domain coordinator's initialize() method.
+     * Uses registerProvidersFromEnv to auto-detect available model providers.
+     *
+     * @throws Error if consensus initialization fails
+     */
+    protected initializeConsensus(): Promise<void>;
+    /**
+     * Dispose the consensus engine
+     *
+     * Call this in the domain coordinator's dispose() method.
+     */
+    protected disposeConsensus(): Promise<void>;
+    /**
+     * Verify a single finding using multi-model consensus
+     */
+    verifyFinding<T>(finding: DomainFinding<T>, options?: VerificationOptions): Promise<Result<ConsensusResult, Error>>;
+    /**
+     * Check if a finding requires consensus verification
+     */
+    requiresConsensus<T>(finding: DomainFinding<T>): boolean;
+    /**
+     * Verify multiple findings in batch
+     */
+    verifyFindings<T>(findings: DomainFinding<T>[], options?: VerificationOptions): Promise<Result<ConsensusResult[], Error>>;
+    /**
+     * Get consensus statistics
+     */
+    getConsensusStats(): ConsensusStatsType | undefined;
+    /**
+     * Check if consensus engine is available
+     */
+    protected isConsensusAvailable(): boolean;
+    /**
+     * Get the consensus engine (for advanced usage)
+     */
+    protected getConsensusEngine(): ConsensusEngine | undefined;
+    /**
+     * Infer security finding category from finding type
+     */
+    private inferCategory;
+}
+/**
+ * Create a consensus-enabled mixin instance
+ *
+ * @param config - Configuration for consensus verification
+ * @returns ConsensusEnabledMixin instance
+ *
+ * @example
+ * ```typescript
+ * const mixin = createConsensusEnabledMixin({
+ *   enableConsensus: true,
+ *   consensusThreshold: 0.8,
+ *   verifyFindingTypes: ['vulnerability'],
+ *   strategy: 'weighted',
+ *   minModels: 2,
+ *   modelTimeout: 30000,
+ * });
+ *
+ * await mixin.initializeConsensus();
+ *
+ * const result = await mixin.verifyFinding(finding);
+ * ```
+ */
+export declare function createConsensusEnabledMixin(config?: Partial<ConsensusEnabledConfig>): ConsensusEnabledMixin;
+/**
+ * Type helper for mixing ConsensusEnabledMixin into other classes
+ *
+ * @example
+ * ```typescript
+ * // Define base class
+ * class MyBaseCoordinator {
+ *   // ... base implementation
+ * }
+ *
+ * // Create mixed class
+ * const ConsensusEnabledCoordinator = withConsensusEnabled(MyBaseCoordinator);
+ *
+ * class MyDomainCoordinator extends ConsensusEnabledCoordinator {
+ *   // Now has access to consensus methods
+ * }
+ * ```
+ */
+export type Constructor<T = object> = new (...args: any[]) => T;
+/**
+ * Apply ConsensusEnabledMixin to a base class
+ *
+ * This is a TypeScript mixin pattern that adds consensus capabilities
+ * to any base class.
+ *
+ * @param Base - The base class to extend
+ * @param config - Configuration for consensus verification
+ * @returns Mixed class with consensus capabilities
+ */
+export declare function withConsensusEnabled<TBase extends Constructor>(Base: TBase, config?: Partial<ConsensusEnabledConfig>): TBase & Constructor<IConsensusEnabledDomain>;
+//# sourceMappingURL=consensus-enabled-domain.d.ts.map

package/v3/dist/coordination/mixins/consensus-enabled-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consensus-enabled-domain.d.ts","sourceRoot":"","sources":["../../../src/coordination/mixins/consensus-enabled-domain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,eAAe,EACf,eAAe,EACf,cAAc,IAAI,kBAAkB,EAGpC,mBAAmB,EAIpB,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAqB,MAAM,oBAAoB,CAAC;AAM/D;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAElC,oEAAoE;IACpE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAEpC,wDAAwD;IACxD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAEtC,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;IAEzD,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,wCAAwC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,0CAA0C;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IAE7C,8CAA8C;IAC9C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;GAEG;AACH,eAAO,MAAM,gCAAgC,EAAE,sBAS9C,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,aAAa,CAAC,CAAC,EACb,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC,CAAC;IAE3C;;;;;OAKG;IACH,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAEzD;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,EACd,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EAC5B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;IAE7C;;;;OAIG;IACH,iBAAiB,IAAI,kBAAkB,GAAG,SAAS,CAAC;CACrD;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,qBAAsB,YAAW,uBAAuB;IACnE,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,sBAAsB,CAAC;IAC3D,SAAS,CAAC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;IACvD,SAAS,CAAC,oBAAoB,EAAE,OAAO,CAAS;IAEhD;;;;OAIG;gBACS,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM;IAWxD;;;;;;;OAOG;cACa,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDpD;;;;OAIG;cACa,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBjD;;OAEG;IACG,aAAa,CAAC,CAAC,EACnB,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;IAkC1C;;OAEG;IACH,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO;IA2BxD;;OAEG;IACG,cAAc,CAAC,CAAC,EACpB,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EAC5B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,KAAK,CAAC,CAAC;IAuC5C;;OAEG;IACH,iBAAiB,IAAI,kBAAkB,GAAG,SAAS;IAQnD;;OAEG;IACH,SAAS,CAAC,oBAAoB,IAAI,OAAO;IAIzC;;OAEG;IACH,SAAS,CAAC,kBAAkB,IAAI,eAAe,GAAG,SAAS;IAI3D;;OAEG;IACH,OAAO,CAAC,aAAa;CAuCtB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC3C,qBAAqB,CAEvB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAEhE;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,WAAW,EAC5D,IAAI,EAAE,KAAK,EACX,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC3C,KAAK,GAAG,WAAW,CAAC,uBAAuB,CAAC,CA+G9C"}

package/v3/dist/coordination/mixins/consensus-enabled-domain.js

@@ -0,0 +1,466 @@
+/**
+ * Agentic QE v3 - Consensus Enabled Domain Mixin
+ * CONSENSUS-MIXIN-001: Reusable mixin for multi-model consensus verification
+ *
+ * This mixin allows any domain coordinator to leverage multi-model consensus
+ * verification for high-stakes decisions without duplicating consensus logic.
+ *
+ * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 2: Multi-Model Verification
+ */
+import { createConsensusEngine, registerProvidersFromEnv, DEFAULT_CONSENSUS_CONFIG, } from '../consensus';
+import { ok, err } from '../../shared/types';
+/**
+ * Default consensus configuration
+ */
+export const DEFAULT_CONSENSUS_ENABLED_CONFIG = {
+    enableConsensus: true,
+    consensusThreshold: 0.7,
+    verifyFindingTypes: [],
+    strategy: 'weighted',
+    minModels: 2,
+    modelTimeout: 60000,
+    verifySeverities: ['critical', 'high'],
+    enableLogging: false,
+};
+// ============================================================================
+// Domain Finding to Security Finding Conversion
+// ============================================================================
+/**
+ * Convert a generic DomainFinding to SecurityFinding format for the consensus engine
+ */
+function toSecurityFinding(finding, category = 'other') {
+    // Map FindingSeverity to Severity
+    const severityMap = {
+        critical: 'critical',
+        high: 'high',
+        medium: 'medium',
+        low: 'low',
+        info: 'info',
+    };
+    // Extract location from payload if available
+    const payload = finding.payload;
+    const location = payload?.location || {
+        file: 'unknown',
+    };
+    // Extract evidence from payload if available
+    const evidence = payload?.evidence || [];
+    return {
+        id: finding.id,
+        type: finding.type,
+        category,
+        severity: severityMap[finding.severity || 'medium'],
+        description: finding.description,
+        location,
+        evidence,
+        detectedAt: finding.detectedAt,
+        detectedBy: finding.detectedBy,
+        correlationId: finding.correlationId,
+        metadata: {
+            originalFinding: finding,
+            domainContext: finding.context,
+        },
+    };
+}
+// ============================================================================
+// Consensus Enabled Mixin Class
+// ============================================================================
+/**
+ * Mixin class that adds consensus verification capabilities to any domain coordinator
+ *
+ * This is designed to be used with TypeScript's class composition pattern.
+ * Domain coordinators can extend this mixin to gain consensus verification capabilities.
+ *
+ * @example
+ * ```typescript
+ * class MyDomainCoordinator extends ConsensusEnabledMixin {
+ *   constructor(config: MyConfig) {
+ *     super({
+ *       enableConsensus: true,
+ *       consensusThreshold: 0.8,
+ *       verifyFindingTypes: ['vulnerability', 'defect'],
+ *       strategy: 'weighted',
+ *       minModels: 2,
+ *       modelTimeout: 30000,
+ *       verifySeverities: ['critical', 'high'],
+ *       enableLogging: true,
+ *     });
+ *   }
+ *
+ *   async initialize(): Promise<void> {
+ *     await this.initializeConsensus();
+ *     // ... other initialization
+ *   }
+ *
+ *   async dispose(): Promise<void> {
+ *     await this.disposeConsensus();
+ *     // ... other cleanup
+ *   }
+ *
+ *   async processFindings(findings: DomainFinding[]): Promise<void> {
+ *     for (const finding of findings) {
+ *       if (this.requiresConsensus(finding)) {
+ *         const result = await this.verifyFinding(finding);
+ *         if (result.success && result.value.verdict === 'verified') {
+ *           // Take action on verified finding
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class ConsensusEnabledMixin {
+    consensusConfig;
+    consensusEngine;
+    consensusInitialized = false;
+    /**
+     * Create a new ConsensusEnabledMixin
+     *
+     * @param config - Configuration for consensus verification
+     */
+    constructor(config = {}) {
+        this.consensusConfig = {
+            ...DEFAULT_CONSENSUS_ENABLED_CONFIG,
+            ...config,
+        };
+    }
+    // ============================================================================
+    // Lifecycle Methods
+    // ============================================================================
+    /**
+     * Initialize the consensus engine
+     *
+     * Call this in the domain coordinator's initialize() method.
+     * Uses registerProvidersFromEnv to auto-detect available model providers.
+     *
+     * @throws Error if consensus initialization fails
+     */
+    async initializeConsensus() {
+        if (!this.consensusConfig.enableConsensus) {
+            if (this.consensusConfig.enableLogging) {
+                console.log('[ConsensusEnabledMixin] Consensus verification disabled');
+            }
+            return;
+        }
+        try {
+            // Register providers from environment
+            const registry = registerProvidersFromEnv(this.consensusConfig.enableLogging);
+            const providers = registry.getAll();
+            if (providers.length === 0) {
+                if (this.consensusConfig.enableLogging) {
+                    console.warn('[ConsensusEnabledMixin] No model providers available for consensus verification');
+                }
+                return;
+            }
+            // Create consensus engine
+            this.consensusEngine = createConsensusEngine({
+                strategy: this.consensusConfig.strategy,
+                models: providers,
+                engineConfig: {
+                    minModels: Math.min(this.consensusConfig.minModels, providers.length),
+                    defaultModelTimeout: this.consensusConfig.modelTimeout,
+                    verifySeverities: this.consensusConfig.verifySeverities,
+                    humanReviewThreshold: DEFAULT_CONSENSUS_CONFIG.humanReviewThreshold,
+                },
+            });
+            this.consensusInitialized = true;
+            if (this.consensusConfig.enableLogging) {
+                console.log(`[ConsensusEnabledMixin] Initialized with ${providers.length} providers ` +
+                    `(strategy: ${this.consensusConfig.strategy})`);
+            }
+        }
+        catch (error) {
+            console.error('[ConsensusEnabledMixin] Failed to initialize consensus:', error);
+            throw error;
+        }
+    }
+    /**
+     * Dispose the consensus engine
+     *
+     * Call this in the domain coordinator's dispose() method.
+     */
+    async disposeConsensus() {
+        if (this.consensusEngine) {
+            await this.consensusEngine.dispose();
+            this.consensusEngine = undefined;
+            this.consensusInitialized = false;
+            if (this.consensusConfig.enableLogging) {
+                console.log('[ConsensusEnabledMixin] Consensus engine disposed');
+            }
+        }
+    }
+    // ============================================================================
+    // IConsensusEnabledDomain Implementation
+    // ============================================================================
+    /**
+     * Verify a single finding using multi-model consensus
+     */
+    async verifyFinding(finding, options) {
+        // Check if consensus is available
+        if (!this.consensusEngine || !this.consensusInitialized) {
+            return err(new Error('Consensus engine not initialized'));
+        }
+        // Check if finding requires consensus
+        if (!this.requiresConsensus(finding)) {
+            return err(new Error(`Finding ${finding.id} does not require consensus verification`));
+        }
+        try {
+            // Convert to SecurityFinding format
+            const securityFinding = toSecurityFinding(finding, this.inferCategory(finding.type));
+            // Verify using consensus engine
+            const result = await this.consensusEngine.verify(securityFinding, {
+                forceVerification: true,
+                ...options,
+            });
+            if (this.consensusConfig.enableLogging && result.success) {
+                console.log(`[ConsensusEnabledMixin] Finding ${finding.id} verified: ` +
+                    `verdict=${result.value.verdict}, confidence=${result.value.confidence.toFixed(2)}`);
+            }
+            return result;
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Check if a finding requires consensus verification
+     */
+    requiresConsensus(finding) {
+        // Check if consensus is enabled
+        if (!this.consensusConfig.enableConsensus) {
+            return false;
+        }
+        // Check if finding type is in the verify list
+        const typeMatches = this.consensusConfig.verifyFindingTypes.length === 0 ||
+            this.consensusConfig.verifyFindingTypes.includes(finding.type);
+        if (!typeMatches) {
+            return false;
+        }
+        // Check severity
+        if (finding.severity) {
+            const severityMatches = this.consensusConfig.verifySeverities.includes(finding.severity);
+            if (severityMatches) {
+                return true;
+            }
+        }
+        // Check confidence threshold
+        return finding.confidence >= this.consensusConfig.consensusThreshold;
+    }
+    /**
+     * Verify multiple findings in batch
+     */
+    async verifyFindings(findings, options) {
+        // Check if consensus is available
+        if (!this.consensusEngine || !this.consensusInitialized) {
+            return err(new Error('Consensus engine not initialized'));
+        }
+        // Filter findings that require consensus
+        const findingsRequiringConsensus = findings.filter(f => this.requiresConsensus(f));
+        if (findingsRequiringConsensus.length === 0) {
+            return ok([]);
+        }
+        try {
+            // Convert all findings to SecurityFinding format
+            const securityFindings = findingsRequiringConsensus.map(f => toSecurityFinding(f, this.inferCategory(f.type)));
+            // Verify batch
+            const result = await this.consensusEngine.verifyBatch(securityFindings, {
+                forceVerification: true,
+                ...options,
+            });
+            if (this.consensusConfig.enableLogging && result.success) {
+                const verified = result.value.filter(r => r.verdict === 'verified').length;
+                console.log(`[ConsensusEnabledMixin] Batch verification complete: ` +
+                    `${verified}/${result.value.length} verified`);
+            }
+            return result;
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Get consensus statistics
+     */
+    getConsensusStats() {
+        return this.consensusEngine?.getStats();
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    /**
+     * Check if consensus engine is available
+     */
+    isConsensusAvailable() {
+        return this.consensusInitialized && this.consensusEngine !== undefined;
+    }
+    /**
+     * Get the consensus engine (for advanced usage)
+     */
+    getConsensusEngine() {
+        return this.consensusEngine;
+    }
+    /**
+     * Infer security finding category from finding type
+     */
+    inferCategory(findingType) {
+        const categoryMap = {
+            // Security categories
+            'sql-injection': 'injection',
+            'command-injection': 'injection',
+            'xss': 'input-validation',
+            'authentication': 'authentication',
+            'authorization': 'authorization',
+            'crypto': 'cryptography',
+            'hardcoded-secret': 'cryptography',
+            'data-exposure': 'data-exposure',
+            'pii-exposure': 'data-exposure',
+            'misconfiguration': 'configuration',
+            'vulnerable-dependency': 'dependency',
+            'path-traversal': 'input-validation',
+            'session': 'session-management',
+            'timing': 'timing-attack',
+            'dos': 'resource-management',
+            'memory-leak': 'resource-management',
+            'logging': 'logging',
+            // Generic categories for non-security findings
+            'vulnerability': 'other',
+            'defect': 'other',
+            'coverage-gap': 'other',
+            'contract-violation': 'other',
+            'quality-issue': 'other',
+        };
+        // Find matching category
+        const lowercaseType = findingType.toLowerCase();
+        for (const [pattern, category] of Object.entries(categoryMap)) {
+            if (lowercaseType.includes(pattern)) {
+                return category;
+            }
+        }
+        return 'other';
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create a consensus-enabled mixin instance
+ *
+ * @param config - Configuration for consensus verification
+ * @returns ConsensusEnabledMixin instance
+ *
+ * @example
+ * ```typescript
+ * const mixin = createConsensusEnabledMixin({
+ *   enableConsensus: true,
+ *   consensusThreshold: 0.8,
+ *   verifyFindingTypes: ['vulnerability'],
+ *   strategy: 'weighted',
+ *   minModels: 2,
+ *   modelTimeout: 30000,
+ * });
+ *
+ * await mixin.initializeConsensus();
+ *
+ * const result = await mixin.verifyFinding(finding);
+ * ```
+ */
+export function createConsensusEnabledMixin(config = {}) {
+    return new ConsensusEnabledMixin(config);
+}
+/**
+ * Apply ConsensusEnabledMixin to a base class
+ *
+ * This is a TypeScript mixin pattern that adds consensus capabilities
+ * to any base class.
+ *
+ * @param Base - The base class to extend
+ * @param config - Configuration for consensus verification
+ * @returns Mixed class with consensus capabilities
+ */
+export function withConsensusEnabled(Base, config = {}) {
+    return class extends Base {
+        consensusConfig;
+        consensusEngine;
+        consensusInitialized = false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            this.consensusConfig = {
+                ...DEFAULT_CONSENSUS_ENABLED_CONFIG,
+                ...config,
+            };
+        }
+        async initializeConsensus() {
+            if (!this.consensusConfig.enableConsensus) {
+                return;
+            }
+            const registry = registerProvidersFromEnv(this.consensusConfig.enableLogging);
+            const providers = registry.getAll();
+            if (providers.length === 0) {
+                return;
+            }
+            this.consensusEngine = createConsensusEngine({
+                strategy: this.consensusConfig.strategy,
+                models: providers,
+                engineConfig: {
+                    minModels: Math.min(this.consensusConfig.minModels, providers.length),
+                    defaultModelTimeout: this.consensusConfig.modelTimeout,
+                    verifySeverities: this.consensusConfig.verifySeverities,
+                },
+            });
+            this.consensusInitialized = true;
+        }
+        async disposeConsensus() {
+            if (this.consensusEngine) {
+                await this.consensusEngine.dispose();
+                this.consensusEngine = undefined;
+                this.consensusInitialized = false;
+            }
+        }
+        async verifyFinding(finding, options) {
+            if (!this.consensusEngine || !this.consensusInitialized) {
+                return err(new Error('Consensus engine not initialized'));
+            }
+            if (!this.requiresConsensus(finding)) {
+                return err(new Error(`Finding ${finding.id} does not require consensus verification`));
+            }
+            const securityFinding = toSecurityFinding(finding, 'other');
+            return this.consensusEngine.verify(securityFinding, {
+                forceVerification: true,
+                ...options,
+            });
+        }
+        requiresConsensus(finding) {
+            if (!this.consensusConfig.enableConsensus) {
+                return false;
+            }
+            const typeMatches = this.consensusConfig.verifyFindingTypes.length === 0 ||
+                this.consensusConfig.verifyFindingTypes.includes(finding.type);
+            if (!typeMatches) {
+                return false;
+            }
+            if (finding.severity && this.consensusConfig.verifySeverities.includes(finding.severity)) {
+                return true;
+            }
+            return finding.confidence >= this.consensusConfig.consensusThreshold;
+        }
+        async verifyFindings(findings, options) {
+            if (!this.consensusEngine || !this.consensusInitialized) {
+                return err(new Error('Consensus engine not initialized'));
+            }
+            const findingsRequiringConsensus = findings.filter(f => this.requiresConsensus(f));
+            if (findingsRequiringConsensus.length === 0) {
+                return ok([]);
+            }
+            const securityFindings = findingsRequiringConsensus.map(f => toSecurityFinding(f, 'other'));
+            return this.consensusEngine.verifyBatch(securityFindings, {
+                forceVerification: true,
+                ...options,
+            });
+        }
+        getConsensusStats() {
+            return this.consensusEngine?.getStats();
+        }
+    };
+}
+//# sourceMappingURL=consensus-enabled-domain.js.map