/**
 * Agentic QE v3 - Morning Sync Protocol
 *
 * Daily coordination protocol that runs at 9am or session start
 * Participants: All 12 domains
 * Actions: Review overnight results, identify risks, prioritize work
 */
import { DomainName, Result, Severity, Priority } from '../../shared/types';
import { EventBus } from '../../kernel/interfaces';
/**
 * Configuration for morning sync execution
 */
export interface MorningSyncConfig {
    /** Time window to look back for results (default: 24 hours) */
    lookbackHours: number;
    /** Minimum severity threshold for risk identification */
    riskSeverityThreshold: Severity;
    /** Maximum number of priority items to generate */
    maxPriorityItems: number;
    /** Domains to include (default: all) */
    includedDomains: DomainName[];
}
/**
 * Overnight results from a single domain
 */
export interface DomainOvernightResults {
    domain: DomainName;
    /** Test execution results */
    testResults?: TestExecutionSummary;
    /** Coverage analysis results */
    coverageResults?: CoverageSummary;
    /** Quality metrics */
    qualityMetrics?: QualityMetricsSummary;
    /** Defect predictions */
    defectPredictions?: DefectPredictionSummary;
    /** Security findings */
    securityFindings?: SecurityFindingsSummary;
    /** Errors encountered */
    errors: string[];
    /** Timestamp of last activity */
    lastActivity?: Date;
}
export interface TestExecutionSummary {
    totalRuns: number;
    passed: number;
    failed: number;
    skipped: number;
    flakyTests: number;
    averageDuration: number;
    failedTestIds: string[];
}
export interface CoverageSummary {
    line: number;
    branch: number;
    function: number;
    statement: number;
    delta: number;
    trend: 'improving' | 'declining' | 'stable';
    gapsIdentified: number;
    criticalGaps: CriticalGap[];
}
export interface CriticalGap {
    file: string;
    lines: number[];
    riskScore: number;
}
export interface QualityMetricsSummary {
    overallScore: number;
    gatesPassed: number;
    gatesFailed: number;
    failedGates: string[];
    deploymentsBlocked: number;
}
export interface DefectPredictionSummary {
    highRiskFiles: number;
    predictedDefects: number;
    topRiskFiles: Array<{
        file: string;
        probability: number;
    }>;
}
export interface SecurityFindingsSummary {
    critical: number;
    high: number;
    medium: number;
    low: number;
    newVulnerabilities: number;
    resolvedVulnerabilities: number;
    complianceScore: number;
}
/**
 * Identified risk from overnight analysis
 */
export interface IdentifiedRisk {
    id: string;
    severity: Severity;
    priority: Priority;
    domain: DomainName;
    title: string;
    description: string;
    source: string;
    impact: string;
    recommendation: string;
    relatedItems: string[];
    detectedAt: Date;
}
/**
 * Prioritized work item
 */
export interface PrioritizedWorkItem {
    id: string;
    priority: Priority;
    type: 'fix' | 'test' | 'review' | 'investigate' | 'improve';
    title: string;
    description: string;
    estimatedEffort: 'trivial' | 'small' | 'medium' | 'large';
    domains: DomainName[];
    relatedRisks: string[];
    suggestedAssignee?: string;
    deadline?: Date;
}
/**
 * Morning sync report
 */
export interface MorningSyncReport {
    syncId: string;
    timestamp: Date;
    duration: number;
    config: MorningSyncConfig;
    /** Aggregated overnight results by domain */
    overnightResults: Map<DomainName, DomainOvernightResults>;
    /** Identified risks */
    risks: IdentifiedRisk[];
    /** Prioritized work items */
    workItems: PrioritizedWorkItem[];
    /** Summary statistics */
    summary: MorningSyncSummary;
}
export interface MorningSyncSummary {
    totalTestsRun: number;
    overallPassRate: number;
    coverageChange: number;
    criticalRisks: number;
    highPriorityItems: number;
    domainsWithIssues: DomainName[];
    healthyDomains: DomainName[];
    overallHealth: 'healthy' | 'warning' | 'critical';
}
export interface MorningSyncCompletedPayload {
    syncId: string;
    duration: number;
    risksIdentified: number;
    workItemsGenerated: number;
    criticalIssues: number;
    overallHealth: 'healthy' | 'warning' | 'critical';
}
export interface RiskIdentifiedPayload {
    riskId: string;
    severity: Severity;
    priority: Priority;
    domain: DomainName;
    title: string;
    recommendation: string;
}
export interface WorkPrioritizedPayload {
    syncId: string;
    workItems: Array<{
        id: string;
        priority: Priority;
        type: string;
        title: string;
    }>;
    totalItems: number;
}
export declare const MorningSyncEvents: {
    readonly MorningSyncStarted: "coordination.MorningSyncStarted";
    readonly MorningSyncCompleted: "coordination.MorningSyncCompleted";
    readonly RiskIdentified: "coordination.RiskIdentified";
    readonly WorkPrioritized: "coordination.WorkPrioritized";
    readonly DomainResultsCollected: "coordination.DomainResultsCollected";
};
/**
 * Interface for collecting overnight data from domains
 */
export interface DomainDataCollector {
    collectTestExecutionResults(since: Date): Promise<Result<TestExecutionSummary | undefined, Error>>;
    collectCoverageResults(since: Date): Promise<Result<CoverageSummary | undefined, Error>>;
    collectQualityMetrics(since: Date): Promise<Result<QualityMetricsSummary | undefined, Error>>;
    collectDefectPredictions(since: Date): Promise<Result<DefectPredictionSummary | undefined, Error>>;
    collectSecurityFindings(since: Date): Promise<Result<SecurityFindingsSummary | undefined, Error>>;
}
/**
 * Morning Sync Protocol
 *
 * Coordinates daily synchronization across all 12 QE domains.
 * Collects overnight results, identifies risks, and prioritizes work.
 */
export declare class MorningSyncProtocol {
    private readonly eventBus;
    private config;
    private collectors;
    constructor(eventBus: EventBus, config?: Partial<MorningSyncConfig>);
    /**
     * Register a data collector for a domain
     */
    registerCollector(domain: DomainName, collector: DomainDataCollector): void;
    /**
     * Execute the morning sync workflow
     */
    execute(): Promise<Result<MorningSyncReport, Error>>;
    /**
     * Gather overnight results from all domains
     */
    gatherOvernightResults(): Promise<Result<Map<DomainName, DomainOvernightResults>, Error>>;
    /**
     * Identify risks from overnight results
     */
    identifyRisks(overnightResults: Map<DomainName, DomainOvernightResults>): Promise<Result<IdentifiedRisk[], Error>>;
    /**
     * Prioritize work based on identified risks
     */
    prioritizeWork(risks: IdentifiedRisk[], overnightResults: Map<DomainName, DomainOvernightResults>): Promise<Result<PrioritizedWorkItem[], Error>>;
    /**
     * Generate the morning sync summary report
     */
    generateReport(syncId: string, startTime: number, overnightResults: Map<DomainName, DomainOvernightResults>, risks: IdentifiedRisk[], workItems: PrioritizedWorkItem[]): MorningSyncReport;
    private identifyTestRisks;
    private identifyCoverageRisks;
    private identifyQualityRisks;
    private identifyDefectRisks;
    private identifySecurityRisks;
    private createWorkItemFromRisk;
    private estimateEffort;
    private generateProactiveWorkItems;
    private deduplicateWorkItems;
    private priorityValue;
    private calculateSummary;
    private publishEvent;
}
/**
 * Default collector that returns empty results
 * Used as fallback when domain-specific collectors aren't available
 */
export declare class DefaultDomainDataCollector implements DomainDataCollector {
    collectTestExecutionResults(_since: Date): Promise<Result<TestExecutionSummary | undefined, Error>>;
    collectCoverageResults(_since: Date): Promise<Result<CoverageSummary | undefined, Error>>;
    collectQualityMetrics(_since: Date): Promise<Result<QualityMetricsSummary | undefined, Error>>;
    collectDefectPredictions(_since: Date): Promise<Result<DefectPredictionSummary | undefined, Error>>;
    collectSecurityFindings(_since: Date): Promise<Result<SecurityFindingsSummary | undefined, Error>>;
}
/**
 * Create a Morning Sync Protocol instance with default configuration
 */
export declare function createMorningSyncProtocol(eventBus: EventBus, config?: Partial<MorningSyncConfig>): MorningSyncProtocol;
//# sourceMappingURL=morning-sync.d.ts.map