/**
 * Agentic QE v3 - Coherence-Enhanced Quality Gate Service
 * ADR-030: Integrates lambda-coherence with existing quality gate evaluation
 *
 * This service extends the basic QualityGateService with coherence-based
 * 4-tier decision making using RuVector-inspired patterns.
 */
import { Result } from '../../../shared/types';
import { MemoryBackend } from '../../../kernel/interfaces';
import { GateEvaluationRequest, GateResult, QualityMetrics } from '../interfaces';
import { QualityGateService } from './quality-gate';
import { QualityLambda, QualityGateDecision, QualityTier, CoherenceGatePolicy, QualitySummary } from '../coherence';
import { PartitionDetectionResult } from '../coherence/partition-detector';
/**
 * Extended gate result with coherence information
 */
export interface CoherenceGateResult extends GateResult {
    /** Coherence decision */
    coherenceDecision: QualityGateDecision;
    /** Partition analysis */
    partitionResult: PartitionDetectionResult;
    /** Lambda value (0-100) */
    lambdaValue: number;
    /** Quality tier (0-3) */
    tier: QualityTier;
    /** Whether traditional gate passed but coherence failed */
    coherenceOverride: boolean;
}
/**
 * Configuration for coherence-enhanced gate service
 */
export interface CoherenceGateServiceConfig {
    /** Coherence policy settings */
    policy: CoherenceGatePolicy;
    /** Enable coherence override (coherence can block even if traditional passes) */
    enableCoherenceOverride: boolean;
    /** Store detailed coherence history */
    storeDetailedHistory: boolean;
    /** Maximum history entries */
    maxHistoryEntries: number;
}
/**
 * Coherence-Enhanced Quality Gate Service
 * Combines traditional threshold checking with lambda-coherence analysis
 */
export declare class CoherenceGateService extends QualityGateService {
    private readonly serviceConfig;
    private readonly lambdaCalculator;
    private readonly gateController;
    private readonly partitionDetector;
    private readonly coherenceHistory;
    constructor(memory: MemoryBackend, config?: Partial<CoherenceGateServiceConfig>);
    /**
     * Evaluate quality gate with coherence analysis
     */
    evaluateGateWithCoherence(request: GateEvaluationRequest, previousLambda?: number): Promise<Result<CoherenceGateResult, Error>>;
    /**
     * Quick lambda calculation from metrics
     */
    calculateLambda(metrics: QualityMetrics, previousLambda?: number): QualityLambda;
    /**
     * Quick check if deployment is allowed
     */
    canDeploy(metrics: QualityMetrics, previousLambda?: number): boolean;
    /**
     * Get quality summary
     */
    getQualitySummary(metrics: QualityMetrics, previousLambda?: number): QualitySummary;
    /**
     * Get coherence evaluation history
     */
    getCoherenceHistory(): CoherenceGateResult[];
    /**
     * Get lambda trend over recent evaluations
     */
    getLambdaTrend(): {
        values: number[];
        direction: 'improving' | 'declining' | 'stable';
    };
    /**
     * Update coherence policy
     */
    updatePolicy(policy: Partial<CoherenceGatePolicy>): void;
    /**
     * Clear history
     */
    clearHistory(): void;
    /**
     * Convert QualityMetrics to coherence input format
     */
    private convertToCoherenceMetrics;
    /**
     * Check if coherence should override traditional result
     */
    private checkCoherenceOverride;
    /**
     * Store coherence result in memory
     */
    private storeCoherenceResult;
    /**
     * Record result in history
     */
    private recordHistory;
}
/**
 * Factory function to create a coherence-enhanced gate service
 */
export declare function createCoherenceGateService(memory: MemoryBackend, config?: Partial<CoherenceGateServiceConfig>): CoherenceGateService;
//# sourceMappingURL=coherence-gate.d.ts.map