/**
 * Feedback Loop Integrator
 * ADR-023: Quality Feedback Loop System
 *
 * Integrates all feedback components into a unified system.
 */
import type { TestOutcome, CoverageSession, QualityScore, FeedbackConfig, PatternTier } from './types.js';
import { TestOutcomeTracker } from './test-outcome-tracker.js';
import { CoverageLearner } from './coverage-learner.js';
import { QualityScoreCalculator } from './quality-score-calculator.js';
import { PatternPromotionManager } from './pattern-promotion.js';
import { RoutingFeedbackCollector } from '../routing/routing-feedback.js';
import type { RealQEReasoningBank } from '../learning/real-qe-reasoning-bank.js';
/**
 * Simplified routing outcome for feedback recording
 */
export interface RoutingOutcomeInput {
    taskId: string;
    taskDescription: string;
    recommendedAgent: string;
    usedAgent: string;
    followedRecommendation: boolean;
    success: boolean;
    qualityScore: number;
    durationMs: number;
    timestamp: Date;
    error?: string;
}
/**
 * Comprehensive feedback loop statistics
 */
export interface FeedbackLoopStats {
    testOutcomes: {
        total: number;
        passRate: number;
        avgQuality: number;
        flakyCount: number;
    };
    coverage: {
        totalSessions: number;
        successfulSessions: number;
        avgImprovement: number;
        strategiesLearned: number;
    };
    patterns: {
        promoted: number;
        demoted: number;
        tracked: number;
    };
    quality: {
        currentTrend: 'improving' | 'stable' | 'declining';
        avgRecentScore: number;
    };
    routing: {
        totalOutcomes: number;
        recommendationFollowRate: number;
        successRateWhenFollowed: number;
        successRateWhenOverridden: number;
    };
    integrationStatus: {
        reasoningBankConnected: boolean;
    };
}
/**
 * Routing analysis results
 */
export interface RoutingAnalysis {
    totalOutcomes: number;
    recommendationFollowRate: number;
    successRateWhenFollowed: number;
    successRateWhenOverridden: number;
    confidenceCorrelation: number;
    recommendations: string[];
}
/**
 * Unified feedback loop that coordinates all feedback components
 */
export declare class QualityFeedbackLoop {
    readonly outcomeTracker: TestOutcomeTracker;
    readonly coverageLearner: CoverageLearner;
    readonly qualityCalculator: QualityScoreCalculator;
    readonly promotionManager: PatternPromotionManager;
    readonly routingFeedback: RoutingFeedbackCollector;
    private reasoningBank;
    private config;
    constructor(config?: Partial<FeedbackConfig>);
    /**
     * Connect to ReasoningBank for pattern storage and updates
     */
    connectReasoningBank(bank: RealQEReasoningBank): void;
    /**
     * Record a test outcome and process through the feedback loop
     */
    recordTestOutcome(outcome: TestOutcome): Promise<{
        qualityScore: QualityScore;
        patternUpdate?: {
            action: 'promoted' | 'demoted' | 'unchanged';
            tier?: PatternTier;
        };
    }>;
    /**
     * Record a coverage session and learn from it
     */
    recordCoverageSession(session: CoverageSession): Promise<{
        improvement: number;
        strategyLearned: boolean;
        strategyId?: string;
    }>;
    /**
     * Get recommended coverage strategy for a file
     */
    getRecommendedCoverageStrategy(filePath: string): import("./types.js").CoverageStrategy | null;
    /**
     * Get quality recommendations based on recent outcomes
     */
    getQualityRecommendations(): string[];
    /**
     * Record a routing outcome (ADR-022 integration)
     */
    recordRoutingOutcome(input: RoutingOutcomeInput): Promise<void>;
    /**
     * Get routing analysis and recommendations
     */
    getRoutingAnalysis(): RoutingAnalysis;
    /**
     * Calculate pattern age in days
     */
    private calculateAgeDays;
    /**
     * Calculate recent success rate for a pattern
     */
    private calculateRecentSuccessRate;
    /**
     * Calculate recent failures for a pattern
     */
    private calculateRecentFailures;
    /**
     * Get comprehensive statistics
     */
    getStats(): FeedbackLoopStats;
    /**
     * Export all data for persistence
     */
    exportData(): {
        outcomes: TestOutcome[];
        sessions: CoverageSession[];
        strategies: ReturnType<CoverageLearner['exportStrategies']>;
        promotionHistory: ReturnType<PatternPromotionManager['exportHistory']>;
        routingOutcomes: ReturnType<RoutingFeedbackCollector['exportOutcomes']>;
    };
    /**
     * Import data from persistence
     */
    importData(data: {
        outcomes?: TestOutcome[];
        sessions?: CoverageSession[];
        strategies?: ReturnType<CoverageLearner['exportStrategies']>;
        promotionHistory?: ReturnType<PatternPromotionManager['exportHistory']>;
        routingOutcomes?: ReturnType<RoutingFeedbackCollector['exportOutcomes']>;
    }): void;
    /**
     * Clear all data
     */
    clear(): void;
}
/**
 * Create a new quality feedback loop
 */
export declare function createQualityFeedbackLoop(config?: Partial<FeedbackConfig>): QualityFeedbackLoop;
//# sourceMappingURL=feedback-loop.d.ts.map