@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/coordination/protocols/morning-sync.ts

@@ -1,1055 +0,0 @@
-/**
- * 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 { v4 as uuidv4 } from 'uuid';
-import {
-  DomainEvent,
-  DomainName,
-  Result,
-  ok,
-  err,
-  Severity,
-  Priority,
-  ALL_DOMAINS,
-} from '../../shared/types';
-import { EventBus } from '../../kernel/interfaces';
-
-// ============================================================================
-// Protocol Types
-// ============================================================================
-
-/**
- * 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';
-}
-
-// ============================================================================
-// Protocol Events
-// ============================================================================
-
-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 const MorningSyncEvents = {
-  MorningSyncStarted: 'coordination.MorningSyncStarted',
-  MorningSyncCompleted: 'coordination.MorningSyncCompleted',
-  RiskIdentified: 'coordination.RiskIdentified',
-  WorkPrioritized: 'coordination.WorkPrioritized',
-  DomainResultsCollected: 'coordination.DomainResultsCollected',
-} as const;
-
-// ============================================================================
-// Domain Data Collectors (Interfaces)
-// ============================================================================
-
-/**
- * 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>>;
-}
-
-// ============================================================================
-// Result Type Helpers
-// ============================================================================
-
-function isSuccess<T, E>(result: Result<T, E>): result is { success: true; value: T } {
-  return result.success;
-}
-
-function isFailure<T, E>(result: Result<T, E>): result is { success: false; error: E } {
-  return !result.success;
-}
-
-// ============================================================================
-// Morning Sync Protocol Implementation
-// ============================================================================
-
-const DEFAULT_CONFIG: MorningSyncConfig = {
-  lookbackHours: 24,
-  riskSeverityThreshold: 'medium',
-  maxPriorityItems: 20,
-  includedDomains: [...ALL_DOMAINS],
-};
-
-/**
- * Morning Sync Protocol
- *
- * Coordinates daily synchronization across all 12 QE domains.
- * Collects overnight results, identifies risks, and prioritizes work.
- */
-export class MorningSyncProtocol {
-  private config: MorningSyncConfig;
-  private collectors: Map<DomainName, DomainDataCollector> = new Map();
-
-  constructor(
-    private readonly eventBus: EventBus,
-    config?: Partial<MorningSyncConfig>
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Register a data collector for a domain
-   */
-  registerCollector(domain: DomainName, collector: DomainDataCollector): void {
-    this.collectors.set(domain, collector);
-  }
-
-  /**
-   * Execute the morning sync workflow
-   */
-  async execute(): Promise<Result<MorningSyncReport, Error>> {
-    const syncId = uuidv4();
-    const startTime = Date.now();
-
-    try {
-      // Publish sync started event
-      await this.publishEvent(MorningSyncEvents.MorningSyncStarted, {
-        syncId,
-        timestamp: new Date(),
-        config: this.config,
-      });
-
-      // Step 1: Gather overnight results from all domains
-      const overnightResultsResult = await this.gatherOvernightResults();
-      if (isFailure(overnightResultsResult)) {
-        return err(overnightResultsResult.error);
-      }
-      const overnightResults = overnightResultsResult.value;
-
-      // Step 2: Identify risks based on results
-      const risksResult = await this.identifyRisks(overnightResults);
-      if (isFailure(risksResult)) {
-        return err(risksResult.error);
-      }
-      const risks = risksResult.value;
-
-      // Publish risk events for high-priority items
-      for (const risk of risks.filter(r => r.severity === 'critical' || r.severity === 'high')) {
-        await this.publishEvent<RiskIdentifiedPayload>(MorningSyncEvents.RiskIdentified, {
-          riskId: risk.id,
-          severity: risk.severity,
-          priority: risk.priority,
-          domain: risk.domain,
-          title: risk.title,
-          recommendation: risk.recommendation,
-        });
-      }
-
-      // Step 3: Prioritize work based on risks
-      const workItemsResult = await this.prioritizeWork(risks, overnightResults);
-      if (isFailure(workItemsResult)) {
-        return err(workItemsResult.error);
-      }
-      const workItems = workItemsResult.value;
-
-      // Publish work prioritized event
-      await this.publishEvent<WorkPrioritizedPayload>(MorningSyncEvents.WorkPrioritized, {
-        syncId,
-        workItems: workItems.map(w => ({
-          id: w.id,
-          priority: w.priority,
-          type: w.type,
-          title: w.title,
-        })),
-        totalItems: workItems.length,
-      });
-
-      // Step 4: Generate report
-      const report = this.generateReport(
-        syncId,
-        startTime,
-        overnightResults,
-        risks,
-        workItems
-      );
-
-      // Publish sync completed event
-      await this.publishEvent<MorningSyncCompletedPayload>(MorningSyncEvents.MorningSyncCompleted, {
-        syncId,
-        duration: Date.now() - startTime,
-        risksIdentified: risks.length,
-        workItemsGenerated: workItems.length,
-        criticalIssues: risks.filter(r => r.severity === 'critical').length,
-        overallHealth: report.summary.overallHealth,
-      });
-
-      return ok(report);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Gather overnight results from all domains
-   */
-  async gatherOvernightResults(): Promise<Result<Map<DomainName, DomainOvernightResults>, Error>> {
-    const results = new Map<DomainName, DomainOvernightResults>();
-    const since = new Date(Date.now() - this.config.lookbackHours * 60 * 60 * 1000);
-
-    for (const domain of this.config.includedDomains) {
-      const domainResults: DomainOvernightResults = {
-        domain,
-        errors: [],
-      };
-
-      const collector = this.collectors.get(domain);
-      if (!collector) {
-        // No collector registered, create empty results
-        results.set(domain, domainResults);
-        continue;
-      }
-
-      // Collect test execution results
-      if (domain === 'test-execution' || domain === 'test-generation') {
-        const testResult = await collector.collectTestExecutionResults(since);
-        if (isSuccess(testResult)) {
-          domainResults.testResults = testResult.value;
-        } else if (isFailure(testResult)) {
-          domainResults.errors.push(`Test execution: ${testResult.error.message}`);
-        }
-      }
-
-      // Collect coverage results
-      if (domain === 'coverage-analysis') {
-        const coverageResult = await collector.collectCoverageResults(since);
-        if (isSuccess(coverageResult)) {
-          domainResults.coverageResults = coverageResult.value;
-        } else if (isFailure(coverageResult)) {
-          domainResults.errors.push(`Coverage: ${coverageResult.error.message}`);
-        }
-      }
-
-      // Collect quality metrics
-      if (domain === 'quality-assessment') {
-        const qualityResult = await collector.collectQualityMetrics(since);
-        if (isSuccess(qualityResult)) {
-          domainResults.qualityMetrics = qualityResult.value;
-        } else if (isFailure(qualityResult)) {
-          domainResults.errors.push(`Quality: ${qualityResult.error.message}`);
-        }
-      }
-
-      // Collect defect predictions
-      if (domain === 'defect-intelligence') {
-        const defectResult = await collector.collectDefectPredictions(since);
-        if (isSuccess(defectResult)) {
-          domainResults.defectPredictions = defectResult.value;
-        } else if (isFailure(defectResult)) {
-          domainResults.errors.push(`Defect prediction: ${defectResult.error.message}`);
-        }
-      }
-
-      // Collect security findings
-      if (domain === 'security-compliance') {
-        const securityResult = await collector.collectSecurityFindings(since);
-        if (isSuccess(securityResult)) {
-          domainResults.securityFindings = securityResult.value;
-        } else if (isFailure(securityResult)) {
-          domainResults.errors.push(`Security: ${securityResult.error.message}`);
-        }
-      }
-
-      domainResults.lastActivity = new Date();
-      results.set(domain, domainResults);
-
-      // Publish domain results collected event
-      await this.publishEvent(MorningSyncEvents.DomainResultsCollected, {
-        domain,
-        hasResults: domainResults.errors.length === 0,
-        errorCount: domainResults.errors.length,
-      });
-    }
-
-    return ok(results);
-  }
-
-  /**
-   * Identify risks from overnight results
-   */
-  async identifyRisks(
-    overnightResults: Map<DomainName, DomainOvernightResults>
-  ): Promise<Result<IdentifiedRisk[], Error>> {
-    const risks: IdentifiedRisk[] = [];
-
-    const entries = Array.from(overnightResults.entries());
-    for (const [domain, results] of entries) {
-      // Check test execution risks
-      if (results.testResults) {
-        const testRisks = this.identifyTestRisks(domain, results.testResults);
-        risks.push(...testRisks);
-      }
-
-      // Check coverage risks
-      if (results.coverageResults) {
-        const coverageRisks = this.identifyCoverageRisks(domain, results.coverageResults);
-        risks.push(...coverageRisks);
-      }
-
-      // Check quality risks
-      if (results.qualityMetrics) {
-        const qualityRisks = this.identifyQualityRisks(domain, results.qualityMetrics);
-        risks.push(...qualityRisks);
-      }
-
-      // Check defect prediction risks
-      if (results.defectPredictions) {
-        const defectRisks = this.identifyDefectRisks(domain, results.defectPredictions);
-        risks.push(...defectRisks);
-      }
-
-      // Check security risks
-      if (results.securityFindings) {
-        const securityRisks = this.identifySecurityRisks(domain, results.securityFindings);
-        risks.push(...securityRisks);
-      }
-    }
-
-    // Sort by severity and priority
-    risks.sort((a, b) => {
-      const severityOrder: Record<Severity, number> = {
-        critical: 0,
-        high: 1,
-        medium: 2,
-        low: 3,
-        info: 4,
-      };
-      const priorityOrder: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-
-      const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
-      if (severityDiff !== 0) return severityDiff;
-      return priorityOrder[a.priority] - priorityOrder[b.priority];
-    });
-
-    return ok(risks);
-  }
-
-  /**
-   * Prioritize work based on identified risks
-   */
-  async prioritizeWork(
-    risks: IdentifiedRisk[],
-    overnightResults: Map<DomainName, DomainOvernightResults>
-  ): Promise<Result<PrioritizedWorkItem[], Error>> {
-    const workItems: PrioritizedWorkItem[] = [];
-
-    // Generate work items from risks
-    for (const risk of risks) {
-      const workItem = this.createWorkItemFromRisk(risk);
-      workItems.push(workItem);
-    }
-
-    // Add proactive work items based on overnight results
-    const proactiveItems = this.generateProactiveWorkItems(overnightResults);
-    workItems.push(...proactiveItems);
-
-    // Deduplicate and merge related items
-    const deduplicatedItems = this.deduplicateWorkItems(workItems);
-
-    // Sort by priority
-    deduplicatedItems.sort((a, b) => {
-      const priorityOrder: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-      return priorityOrder[a.priority] - priorityOrder[b.priority];
-    });
-
-    // Limit to max configured items
-    return ok(deduplicatedItems.slice(0, this.config.maxPriorityItems));
-  }
-
-  /**
-   * Generate the morning sync summary report
-   */
-  generateReport(
-    syncId: string,
-    startTime: number,
-    overnightResults: Map<DomainName, DomainOvernightResults>,
-    risks: IdentifiedRisk[],
-    workItems: PrioritizedWorkItem[]
-  ): MorningSyncReport {
-    const summary = this.calculateSummary(overnightResults, risks);
-
-    return {
-      syncId,
-      timestamp: new Date(),
-      duration: Date.now() - startTime,
-      config: this.config,
-      overnightResults,
-      risks,
-      workItems,
-      summary,
-    };
-  }
-
-  // ============================================================================
-  // Private Risk Identification Methods
-  // ============================================================================
-
-  private identifyTestRisks(domain: DomainName, testResults: TestExecutionSummary): IdentifiedRisk[] {
-    const risks: IdentifiedRisk[] = [];
-    const passRate = testResults.totalRuns > 0
-      ? testResults.passed / testResults.totalRuns
-      : 1;
-
-    // High failure rate
-    if (passRate < 0.9) {
-      risks.push({
-        id: uuidv4(),
-        severity: passRate < 0.7 ? 'critical' : 'high',
-        priority: passRate < 0.7 ? 'p0' : 'p1',
-        domain,
-        title: 'High Test Failure Rate',
-        description: `Test pass rate is ${(passRate * 100).toFixed(1)}%, below acceptable threshold`,
-        source: 'test-execution',
-        impact: 'Reduced confidence in code quality, potential release delays',
-        recommendation: `Review and fix ${testResults.failed} failing tests immediately`,
-        relatedItems: testResults.failedTestIds,
-        detectedAt: new Date(),
-      });
-    }
-
-    // Flaky tests detected
-    if (testResults.flakyTests > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: testResults.flakyTests > 10 ? 'high' : 'medium',
-        priority: testResults.flakyTests > 10 ? 'p1' : 'p2',
-        domain,
-        title: 'Flaky Tests Detected',
-        description: `${testResults.flakyTests} flaky tests identified`,
-        source: 'test-execution',
-        impact: 'Unreliable test results, wasted CI/CD resources',
-        recommendation: 'Investigate and stabilize flaky tests',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    return risks;
-  }
-
-  private identifyCoverageRisks(domain: DomainName, coverageResults: CoverageSummary): IdentifiedRisk[] {
-    const risks: IdentifiedRisk[] = [];
-
-    // Low coverage
-    if (coverageResults.line < 70) {
-      risks.push({
-        id: uuidv4(),
-        severity: coverageResults.line < 50 ? 'critical' : 'high',
-        priority: coverageResults.line < 50 ? 'p0' : 'p1',
-        domain,
-        title: 'Low Code Coverage',
-        description: `Line coverage is ${coverageResults.line}%, below minimum threshold`,
-        source: 'coverage-analysis',
-        impact: 'High risk of undetected bugs in production',
-        recommendation: `Focus on covering ${coverageResults.gapsIdentified} identified gaps`,
-        relatedItems: coverageResults.criticalGaps.map(g => g.file),
-        detectedAt: new Date(),
-      });
-    }
-
-    // Coverage declining
-    if (coverageResults.trend === 'declining' && coverageResults.delta < -5) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'high',
-        priority: 'p1',
-        domain,
-        title: 'Coverage Declining',
-        description: `Coverage dropped by ${Math.abs(coverageResults.delta)}% in the last 24 hours`,
-        source: 'coverage-analysis',
-        impact: 'Quality regression, increasing technical debt',
-        recommendation: 'Review recent changes and add missing tests',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    // Critical gaps
-    for (const gap of coverageResults.criticalGaps) {
-      if (gap.riskScore > 0.8) {
-        risks.push({
-          id: uuidv4(),
-          severity: 'high',
-          priority: 'p1',
-          domain,
-          title: `Critical Coverage Gap: ${gap.file}`,
-          description: `High-risk file with ${gap.lines.length} uncovered lines`,
-          source: 'coverage-analysis',
-          impact: 'High probability of production issues',
-          recommendation: `Add tests for lines: ${gap.lines.slice(0, 5).join(', ')}${gap.lines.length > 5 ? '...' : ''}`,
-          relatedItems: [gap.file],
-          detectedAt: new Date(),
-        });
-      }
-    }
-
-    return risks;
-  }
-
-  private identifyQualityRisks(domain: DomainName, qualityMetrics: QualityMetricsSummary): IdentifiedRisk[] {
-    const risks: IdentifiedRisk[] = [];
-
-    // Failed quality gates
-    if (qualityMetrics.gatesFailed > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'critical',
-        priority: 'p0',
-        domain,
-        title: 'Quality Gates Failing',
-        description: `${qualityMetrics.gatesFailed} quality gates are currently failing`,
-        source: 'quality-assessment',
-        impact: 'Cannot proceed with deployment until resolved',
-        recommendation: `Address failing gates: ${qualityMetrics.failedGates.join(', ')}`,
-        relatedItems: qualityMetrics.failedGates,
-        detectedAt: new Date(),
-      });
-    }
-
-    // Low quality score
-    if (qualityMetrics.overallScore < 60) {
-      risks.push({
-        id: uuidv4(),
-        severity: qualityMetrics.overallScore < 40 ? 'critical' : 'high',
-        priority: qualityMetrics.overallScore < 40 ? 'p0' : 'p1',
-        domain,
-        title: 'Low Quality Score',
-        description: `Overall quality score is ${qualityMetrics.overallScore}/100`,
-        source: 'quality-assessment',
-        impact: 'High maintenance cost, elevated bug risk',
-        recommendation: 'Focus on improving code quality metrics',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    // Blocked deployments
-    if (qualityMetrics.deploymentsBlocked > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'high',
-        priority: 'p1',
-        domain,
-        title: 'Deployments Blocked',
-        description: `${qualityMetrics.deploymentsBlocked} deployments were blocked overnight`,
-        source: 'quality-assessment',
-        impact: 'Delivery delays, potential customer impact',
-        recommendation: 'Review and address blocking issues',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    return risks;
-  }
-
-  private identifyDefectRisks(domain: DomainName, defectPredictions: DefectPredictionSummary): IdentifiedRisk[] {
-    const risks: IdentifiedRisk[] = [];
-
-    // High-risk files identified
-    if (defectPredictions.highRiskFiles > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: defectPredictions.highRiskFiles > 5 ? 'high' : 'medium',
-        priority: defectPredictions.highRiskFiles > 5 ? 'p1' : 'p2',
-        domain,
-        title: 'High-Risk Files Detected',
-        description: `${defectPredictions.highRiskFiles} files have elevated defect probability`,
-        source: 'defect-intelligence',
-        impact: 'Increased likelihood of production bugs',
-        recommendation: 'Prioritize review and testing of high-risk files',
-        relatedItems: defectPredictions.topRiskFiles.map(f => f.file),
-        detectedAt: new Date(),
-      });
-    }
-
-    // Top risk files
-    for (const riskFile of defectPredictions.topRiskFiles.filter(f => f.probability > 0.7)) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'high',
-        priority: 'p1',
-        domain,
-        title: `High Defect Probability: ${riskFile.file}`,
-        description: `${(riskFile.probability * 100).toFixed(0)}% probability of defects`,
-        source: 'defect-intelligence',
-        impact: 'Very likely to cause production issues',
-        recommendation: 'Thorough code review and additional testing required',
-        relatedItems: [riskFile.file],
-        detectedAt: new Date(),
-      });
-    }
-
-    return risks;
-  }
-
-  private identifySecurityRisks(domain: DomainName, securityFindings: SecurityFindingsSummary): IdentifiedRisk[] {
-    const risks: IdentifiedRisk[] = [];
-
-    // Critical vulnerabilities
-    if (securityFindings.critical > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'critical',
-        priority: 'p0',
-        domain,
-        title: 'Critical Security Vulnerabilities',
-        description: `${securityFindings.critical} critical vulnerabilities detected`,
-        source: 'security-compliance',
-        impact: 'Immediate security threat, potential data breach',
-        recommendation: 'Fix critical vulnerabilities immediately',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    // High vulnerabilities
-    if (securityFindings.high > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'high',
-        priority: 'p1',
-        domain,
-        title: 'High Security Vulnerabilities',
-        description: `${securityFindings.high} high-severity vulnerabilities detected`,
-        source: 'security-compliance',
-        impact: 'Significant security risk',
-        recommendation: 'Address high-severity vulnerabilities within 24 hours',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    // New vulnerabilities
-    if (securityFindings.newVulnerabilities > 0) {
-      risks.push({
-        id: uuidv4(),
-        severity: 'medium',
-        priority: 'p2',
-        domain,
-        title: 'New Vulnerabilities Introduced',
-        description: `${securityFindings.newVulnerabilities} new vulnerabilities introduced overnight`,
-        source: 'security-compliance',
-        impact: 'Security posture degradation',
-        recommendation: 'Review recent changes for security issues',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    // Low compliance score
-    if (securityFindings.complianceScore < 80) {
-      risks.push({
-        id: uuidv4(),
-        severity: securityFindings.complianceScore < 60 ? 'high' : 'medium',
-        priority: securityFindings.complianceScore < 60 ? 'p1' : 'p2',
-        domain,
-        title: 'Low Compliance Score',
-        description: `Compliance score is ${securityFindings.complianceScore}%`,
-        source: 'security-compliance',
-        impact: 'Regulatory risk, potential audit findings',
-        recommendation: 'Address compliance violations',
-        relatedItems: [],
-        detectedAt: new Date(),
-      });
-    }
-
-    return risks;
-  }
-
-  // ============================================================================
-  // Private Work Item Methods
-  // ============================================================================
-
-  private createWorkItemFromRisk(risk: IdentifiedRisk): PrioritizedWorkItem {
-    const typeMap: Record<string, PrioritizedWorkItem['type']> = {
-      'test-execution': 'fix',
-      'coverage-analysis': 'test',
-      'quality-assessment': 'improve',
-      'defect-intelligence': 'review',
-      'security-compliance': 'fix',
-    };
-
-    return {
-      id: uuidv4(),
-      priority: risk.priority,
-      type: typeMap[risk.source] || 'investigate',
-      title: `[${risk.severity.toUpperCase()}] ${risk.title}`,
-      description: `${risk.description}\n\nRecommendation: ${risk.recommendation}`,
-      estimatedEffort: this.estimateEffort(risk),
-      domains: [risk.domain],
-      relatedRisks: [risk.id],
-    };
-  }
-
-  private estimateEffort(risk: IdentifiedRisk): PrioritizedWorkItem['estimatedEffort'] {
-    // Simple estimation based on severity and related items
-    if (risk.severity === 'critical') return 'large';
-    if (risk.severity === 'high') return risk.relatedItems.length > 3 ? 'large' : 'medium';
-    if (risk.severity === 'medium') return risk.relatedItems.length > 5 ? 'medium' : 'small';
-    return 'trivial';
-  }
-
-  private generateProactiveWorkItems(
-    overnightResults: Map<DomainName, DomainOvernightResults>
-  ): PrioritizedWorkItem[] {
-    const items: PrioritizedWorkItem[] = [];
-
-    // Check for domains with no activity
-    const entries = Array.from(overnightResults.entries());
-    for (const [domain, results] of entries) {
-      if (!results.lastActivity) {
-        items.push({
-          id: uuidv4(),
-          priority: 'p3',
-          type: 'investigate',
-          title: `No Activity: ${domain}`,
-          description: `Domain ${domain} had no activity in the last ${this.config.lookbackHours} hours`,
-          estimatedEffort: 'small',
-          domains: [domain],
-          relatedRisks: [],
-        });
-      }
-    }
-
-    // Add coverage improvement item if coverage is good but could be better
-    const coverageResults = overnightResults.get('coverage-analysis')?.coverageResults;
-    if (coverageResults && coverageResults.line >= 70 && coverageResults.line < 85) {
-      items.push({
-        id: uuidv4(),
-        priority: 'p3',
-        type: 'improve',
-        title: 'Proactive Coverage Improvement',
-        description: `Coverage is at ${coverageResults.line}%. Consider targeting 85%+ for better quality.`,
-        estimatedEffort: 'medium',
-        domains: ['coverage-analysis', 'test-generation'],
-        relatedRisks: [],
-      });
-    }
-
-    return items;
-  }
-
-  private deduplicateWorkItems(items: PrioritizedWorkItem[]): PrioritizedWorkItem[] {
-    const seen = new Map<string, PrioritizedWorkItem>();
-
-    for (const item of items) {
-      // Create a key based on type and related items
-      const key = `${item.type}-${item.title.substring(0, 50)}`;
-
-      if (!seen.has(key)) {
-        seen.set(key, item);
-      } else {
-        // Merge related risks
-        const existing = seen.get(key)!;
-        existing.relatedRisks.push(...item.relatedRisks);
-        // Keep higher priority
-        if (this.priorityValue(item.priority) < this.priorityValue(existing.priority)) {
-          existing.priority = item.priority;
-        }
-      }
-    }
-
-    return Array.from(seen.values());
-  }
-
-  private priorityValue(priority: Priority): number {
-    const map: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-    return map[priority];
-  }
-
-  // ============================================================================
-  // Private Summary Methods
-  // ============================================================================
-
-  private calculateSummary(
-    overnightResults: Map<DomainName, DomainOvernightResults>,
-    risks: IdentifiedRisk[]
-  ): MorningSyncSummary {
-    let totalTestsRun = 0;
-    let totalPassed = 0;
-    let coverageChange = 0;
-    const domainsWithIssues: DomainName[] = [];
-    const healthyDomains: DomainName[] = [];
-
-    const entries = Array.from(overnightResults.entries());
-    for (const [domain, results] of entries) {
-      if (results.testResults) {
-        totalTestsRun += results.testResults.totalRuns;
-        totalPassed += results.testResults.passed;
-      }
-
-      if (results.coverageResults) {
-        coverageChange = results.coverageResults.delta;
-      }
-
-      if (results.errors.length > 0) {
-        domainsWithIssues.push(domain);
-      } else {
-        healthyDomains.push(domain);
-      }
-    }
-
-    const criticalRisks = risks.filter(r => r.severity === 'critical').length;
-    const highPriorityItems = risks.filter(r => r.priority === 'p0' || r.priority === 'p1').length;
-
-    // Determine overall health
-    let overallHealth: MorningSyncSummary['overallHealth'];
-    if (criticalRisks > 0) {
-      overallHealth = 'critical';
-    } else if (highPriorityItems > 5 || domainsWithIssues.length > 3) {
-      overallHealth = 'warning';
-    } else {
-      overallHealth = 'healthy';
-    }
-
-    return {
-      totalTestsRun,
-      overallPassRate: totalTestsRun > 0 ? totalPassed / totalTestsRun : 1,
-      coverageChange,
-      criticalRisks,
-      highPriorityItems,
-      domainsWithIssues,
-      healthyDomains,
-      overallHealth,
-    };
-  }
-
-  // ============================================================================
-  // Event Publishing
-  // ============================================================================
-
-  private async publishEvent<T>(type: string, payload: T): Promise<void> {
-    const event: DomainEvent<T> = {
-      id: uuidv4(),
-      type,
-      timestamp: new Date(),
-      source: 'test-execution', // Using a valid DomainName as coordination isn't a domain
-      payload,
-    };
-    await this.eventBus.publish(event);
-  }
-}
-
-// ============================================================================
-// Default Data Collector (for when no collector is registered)
-// ============================================================================
-
-/**
- * Default collector that returns empty results
- * Used as fallback when domain-specific collectors aren't available
- */
-export class DefaultDomainDataCollector implements DomainDataCollector {
-  async collectTestExecutionResults(_since: Date): Promise<Result<TestExecutionSummary | undefined, Error>> {
-    return ok(undefined);
-  }
-
-  async collectCoverageResults(_since: Date): Promise<Result<CoverageSummary | undefined, Error>> {
-    return ok(undefined);
-  }
-
-  async collectQualityMetrics(_since: Date): Promise<Result<QualityMetricsSummary | undefined, Error>> {
-    return ok(undefined);
-  }
-
-  async collectDefectPredictions(_since: Date): Promise<Result<DefectPredictionSummary | undefined, Error>> {
-    return ok(undefined);
-  }
-
-  async collectSecurityFindings(_since: Date): Promise<Result<SecurityFindingsSummary | undefined, Error>> {
-    return ok(undefined);
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create a Morning Sync Protocol instance with default configuration
- */
-export function createMorningSyncProtocol(
-  eventBus: EventBus,
-  config?: Partial<MorningSyncConfig>
-): MorningSyncProtocol {
-  return new MorningSyncProtocol(eventBus, config);
-}