/**
 * Agentic QE v3 - Learning Consolidation Protocol
 *
 * Schedule: Friday 6pm (weekly)
 * Participants: Learning Coordinator, Transfer Specialist, Pattern Learner
 * Actions: Gather patterns, consolidate, update knowledge base
 */
import { Result, DomainName, DomainEvent } from '../../shared/types/index.js';
import { EventBus, MemoryBackend } from '../../kernel/interfaces.js';
import { LearnedPattern, PatternType, IPatternLearningService, IKnowledgeSynthesisService } from '../../domains/learning-optimization/interfaces.js';
export interface LearningConsolidationConfig {
    /** Minimum patterns per domain to trigger consolidation */
    minPatternsForConsolidation: number;
    /** Pattern similarity threshold for merging (0-1) */
    similarityThreshold: number;
    /** Maximum patterns to keep per domain after consolidation */
    maxPatternsPerDomain: number;
    /** Minimum confidence to retain pattern */
    minConfidenceThreshold: number;
    /** Number of weeks of data to analyze */
    analysisWindowWeeks: number;
    /** Enable cross-project transfer */
    enableCrossProjectTransfer: boolean;
}
export interface LearningConsolidationStartedEvent extends DomainEvent {
    readonly type: 'LearningConsolidationStarted';
    readonly payload: {
        consolidationId: string;
        timestamp: Date;
        domainsToProcess: DomainName[];
    };
}
export interface PatternConsolidatedEvent extends DomainEvent {
    readonly type: 'PatternConsolidated';
    readonly payload: {
        consolidationId: string;
        domain: DomainName;
        patternsBeforeCount: number;
        patternsAfterCount: number;
        mergedPatternIds: string[];
        removedPatternIds: string[];
    };
}
export interface LearningConsolidationCompletedEvent extends DomainEvent {
    readonly type: 'LearningConsolidationCompleted';
    readonly payload: {
        consolidationId: string;
        stats: ConsolidationStats;
        insights: WeeklyInsight[];
        duration: number;
    };
}
export interface TransferReadyEvent extends DomainEvent {
    readonly type: 'TransferReady';
    readonly payload: {
        consolidationId: string;
        transferablePatterns: TransferablePattern[];
        targetProjects: string[];
    };
}
export interface DomainPatternGroup {
    domain: DomainName;
    patterns: LearnedPattern[];
    stats: DomainPatternStats;
}
export interface DomainPatternStats {
    totalPatterns: number;
    avgConfidence: number;
    avgSuccessRate: number;
    avgUsageCount: number;
    topPatternType: PatternType;
    newPatternsThisWeek: number;
}
export interface ConsolidationStats {
    domainsProcessed: number;
    totalPatternsAnalyzed: number;
    patternsMerged: number;
    patternsRemoved: number;
    patternsRetained: number;
    knowledgeItemsUpdated: number;
    improvementOpportunities: number;
    crossDomainTransfers: number;
}
export interface WeeklyInsight {
    type: 'improvement' | 'trend' | 'anomaly' | 'recommendation';
    domain: DomainName;
    title: string;
    description: string;
    impact: 'high' | 'medium' | 'low';
    actionItems: string[];
}
export interface TransferablePattern {
    patternId: string;
    domain: DomainName;
    name: string;
    applicableDomains: DomainName[];
    transferConfidence: number;
    reason: string;
}
export interface ConsolidationResult {
    consolidationId: string;
    startedAt: Date;
    completedAt: Date;
    stats: ConsolidationStats;
    insights: WeeklyInsight[];
    transferablePatterns: TransferablePattern[];
    domainReports: DomainConsolidationReport[];
}
export interface DomainConsolidationReport {
    domain: DomainName;
    patternsBeforeCount: number;
    patternsAfterCount: number;
    mergedPatterns: MergedPatternInfo[];
    removedPatterns: RemovedPatternInfo[];
    topPerformingPatterns: LearnedPattern[];
    improvementAreas: string[];
}
export interface MergedPatternInfo {
    resultPatternId: string;
    sourcePatternIds: string[];
    mergeReason: string;
}
export interface RemovedPatternInfo {
    patternId: string;
    name: string;
    removalReason: string;
}
/**
 * Learning Consolidation Protocol
 *
 * Orchestrates weekly learning consolidation across all QE domains.
 * Gathers patterns, consolidates similar ones, removes underperformers,
 * and prepares high-value patterns for cross-project transfer.
 */
export declare class LearningConsolidationProtocol {
    private readonly eventBus;
    private readonly memory;
    private readonly patternService;
    private readonly knowledgeService;
    private readonly config;
    constructor(eventBus: EventBus, memory: MemoryBackend, patternService: IPatternLearningService, knowledgeService: IKnowledgeSynthesisService, config?: Partial<LearningConsolidationConfig>);
    /**
     * Execute the weekly learning consolidation protocol
     */
    execute(): Promise<Result<ConsolidationResult>>;
    /**
     * Gather patterns from all 12 domains
     */
    gatherPatterns(): Promise<Result<DomainPatternGroup[]>>;
    /**
     * Get patterns for a specific domain
     */
    private getPatternsForDomain;
    /**
     * Calculate statistics for a domain's patterns
     */
    private calculateDomainStats;
    /**
     * Consolidate patterns within a domain - merge similar, remove underperformers
     */
    consolidatePatterns(consolidationId: string, domainGroup: DomainPatternGroup): Promise<Result<DomainConsolidationReport>>;
    /**
     * Group patterns by similarity
     */
    private groupSimilarPatterns;
    /**
     * Check if two patterns are similar enough to merge
     */
    private areSimilarPatterns;
    /**
     * Calculate similarity between two pattern contexts
     */
    private calculateContextSimilarity;
    /**
     * Merge a group of similar patterns into one
     */
    private mergePatternGroup;
    /**
     * Check if a pattern should be retained
     */
    private shouldRetainPattern;
    /**
     * Get reason for pattern removal
     */
    private getRemovalReason;
    /**
     * Archive a pattern (soft delete)
     */
    private archivePattern;
    /**
     * Trim patterns to max allowed per domain
     */
    private trimToMaxPatterns;
    /**
     * Get top performing patterns
     */
    private getTopPerformingPatterns;
    /**
     * Identify improvement areas for a domain
     */
    private identifyImprovementAreas;
    /**
     * Update knowledge base with consolidated patterns
     */
    updateKnowledgeBase(domainReports: DomainConsolidationReport[]): Promise<Result<number>>;
    /**
     * Create a knowledge entry from a high-performing pattern
     */
    private createKnowledgeFromPattern;
    /**
     * Store consolidation summary as knowledge
     */
    private storeConsolidationSummary;
    /**
     * Prepare high-value patterns for cross-project transfer
     */
    prepareTransfer(consolidationId: string, domainReports: DomainConsolidationReport[]): Promise<Result<TransferablePattern[]>>;
    /**
     * Find domains where a pattern could be applicable
     */
    private findApplicableDomains;
    /**
     * Generate weekly learning report with insights
     */
    generateInsights(gatheredPatterns: DomainPatternGroup[], domainReports: DomainConsolidationReport[]): Promise<WeeklyInsight[]>;
    private publishStartEvent;
    private publishPatternConsolidatedEvent;
    private publishCompletedEvent;
    private publishTransferReadyEvent;
    private storeConsolidationResult;
    /**
     * Get previous consolidation results for trend analysis
     */
    getPreviousConsolidations(count: number): Promise<ConsolidationResult[]>;
    /**
     * Get consolidation history summary
     */
    getConsolidationHistory(weeks: number): Promise<{
        consolidations: number;
        totalPatternsMerged: number;
        totalPatternsRemoved: number;
        avgImprovementOpportunities: number;
    }>;
}
/**
 * Create a Learning Consolidation Protocol instance
 */
export declare function createLearningConsolidationProtocol(eventBus: EventBus, memory: MemoryBackend, patternService: IPatternLearningService, knowledgeService: IKnowledgeSynthesisService, config?: Partial<LearningConsolidationConfig>): LearningConsolidationProtocol;
//# sourceMappingURL=learning-consolidation.d.ts.map