How to Implement Clinical Decision Support Systems: Integration, Customization, and Workflow Optimization

Clinical Decision Support (CDS) systems are powerful tools for improving patient care, but their success depends on thoughtful implementation that integrates seamlessly with clinical workflows. Poorly implemented CDS can lead to alert fatigue, workflow disruption, and clinician frustration.

This comprehensive guide walks through the complete process of implementing CDS systems, from initial planning through integration, customization, training, and ongoing optimization to ensure maximum clinical impact and user adoption.

Phase 1: Strategic Planning and Requirements Analysis

Current State Assessment

Clinical Workflow Analysis:

// Clinical Workflow Analysis Framework
interface WorkflowAnalysis {
  analyzeCurrentWorkflows(): Promise<WorkflowAssessment>;
  identifyCDSOpportunities(): Promise<CDSOpportunity[]>;
  assessTechnologyReadiness(): Promise<TechnologyReadiness>;
  evaluateChangeCapacity(): Promise<ChangeCapacity>;
}

class ClinicalWorkflowAnalyzer implements WorkflowAnalysis {
  private workflowObserver: WorkflowObserver;
  private clinicianSurvey: ClinicianSurvey;
  private technologyAssessment: TechnologyAssessment;

  async analyzeCurrentWorkflows(): Promise<WorkflowAssessment> {
    // Observe clinical workflows
    const observations = await this.workflowObserver.observeWorkflows();

    // Survey clinicians
    const surveyResults = await this.clinicianSurvey.collectFeedback();

    // Analyze pain points and inefficiencies
    const painPoints = await this.identifyPainPoints(observations, surveyResults);

    return {
      currentWorkflows: observations,
      clinicianFeedback: surveyResults,
      painPoints,
      efficiencyMetrics: await this.calculateEfficiencyMetrics(observations),
      technologyUsage: await this.assessTechnologyUsage(observations)
    };
  }

  async identifyCDSOpportunities(): Promise<CDSOpportunity[]> {
    const assessment = await this.analyzeCurrentWorkflows();
    const opportunities: CDSOpportunity[] = [];

    // Medication safety opportunities
    if (assessment.painPoints.includes('medication_errors')) {
      opportunities.push({
        type: 'medication_safety',
        title: 'Drug Interaction and Allergy Checking',
        description: 'Real-time medication safety alerts and recommendations',
        potentialImpact: 'high',
        implementationEffort: 'medium',
        priority: this.calculatePriority('medication_safety', assessment)
      });
    }

    // Diagnostic support opportunities
    if (assessment.painPoints.includes('diagnostic_delays')) {
      opportunities.push({
        type: 'diagnostic_support',
        title: 'Evidence-Based Diagnostic Suggestions',
        description: 'Contextual diagnostic recommendations based on patient data',
        potentialImpact: 'high',
        implementationEffort: 'high',
        priority: this.calculatePriority('diagnostic_support', assessment)
      });
    }

    // Preventive care opportunities
    if (assessment.painPoints.includes('preventive_care_gaps')) {
      opportunities.push({
        type: 'preventive_care',
        title: 'Preventive Care Reminders',
        description: 'Automated preventive care recommendations and scheduling',
        potentialImpact: 'medium',
        implementationEffort: 'low',
        priority: this.calculatePriority('preventive_care', assessment)
      });
    }

    // Order set optimization
    if (assessment.painPoints.includes('order_set_inefficiency')) {
      opportunities.push({
        type: 'order_sets',
        title: 'Smart Order Sets',
        description: 'Context-aware order sets that adapt to patient characteristics',
        potentialImpact: 'medium',
        implementationEffort: 'medium',
        priority: this.calculatePriority('order_sets', assessment)
      });
    }

    return opportunities.sort((a, b) => b.priority - a.priority);
  }

  private async identifyPainPoints(observations: WorkflowObservation[], surveyResults: SurveyResponse[]): Promise<string[]> {
    const painPoints: string[] = [];

    // Analyze workflow observations
    const avgTaskTime = observations.reduce((sum, obs) => sum + obs.duration, 0) / observations.length;
    if (avgTaskTime > 15) painPoints.push('workflow_efficiency');

    // Analyze survey responses
    const errorRate = surveyResults.filter(r => r.reportsErrors).length / surveyResults.length;
    if (errorRate > 0.3) painPoints.push('medication_errors');

    const delayRate = surveyResults.filter(r => r.reportsDelays).length / surveyResults.length;
    if (delayRate > 0.4) painPoints.push('diagnostic_delays');

    const preventiveCareGap = surveyResults.filter(r => r.preventiveCareGaps).length / surveyResults.length;
    if (preventiveCareGap > 0.5) painPoints.push('preventive_care_gaps');

    return painPoints;
  }

  private calculatePriority(opportunityType: string, assessment: WorkflowAssessment): number {
    // Priority calculation based on impact, feasibility, and alignment with goals
    const impactWeights: { [key: string]: number } = {
      medication_safety: 10,
      diagnostic_support: 9,
      preventive_care: 7,
      order_sets: 6
    };

    const basePriority = impactWeights[opportunityType] || 5;

    // Adjust based on pain point severity
    const painPointMultiplier = assessment.painPoints.includes(opportunityType) ? 1.5 : 1.0;

    // Adjust based on technology readiness
    const techReadiness = assessment.technologyUsage.overallReadiness;
    const techMultiplier = techReadiness > 0.8 ? 1.2 : techReadiness > 0.6 ? 1.0 : 0.8;

    return Math.round(basePriority * painPointMultiplier * techMultiplier);
  }

  private async calculateEfficiencyMetrics(observations: WorkflowObservation[]): Promise<EfficiencyMetrics> {
    const totalTasks = observations.length;
    const totalTime = observations.reduce((sum, obs) => sum + obs.duration, 0);
    const avgTime = totalTime / totalTasks;

    const errorTasks = observations.filter(obs => obs.hadErrors).length;
    const errorRate = errorTasks / totalTasks;

    const interruptedTasks = observations.filter(obs => obs.wasInterrupted).length;
    const interruptionRate = interruptedTasks / totalTasks;

    return {
      averageTaskTime: avgTime,
      errorRate,
      interruptionRate,
      tasksPerHour: (3600 / avgTime), // Assuming 1 hour = 3600 seconds
      efficiencyScore: this.calculateEfficiencyScore(avgTime, errorRate, interruptionRate)
    };
  }

  private calculateEfficiencyScore(avgTime: number, errorRate: number, interruptionRate: number): number {
    // Efficiency score from 0-100
    const timeScore = Math.max(0, 100 - (avgTime - 5) * 5); // Optimal time = 5 minutes
    const errorPenalty = errorRate * 50;
    const interruptionPenalty = interruptionRate * 30;

    return Math.max(0, Math.min(100, timeScore - errorPenalty - interruptionPenalty));
  }

  async assessTechnologyReadiness(): Promise<TechnologyReadiness> {
    return await this.technologyAssessment.evaluateReadiness();
  }

  async evaluateChangeCapacity(): Promise<ChangeCapacity> {
    // Assess organizational capacity for change
    const surveyResults = await this.clinicianSurvey.collectChangeReadiness();

    return {
      overallCapacity: this.calculateChangeCapacity(surveyResults),
      factors: {
        leadershipSupport: surveyResults.filter(r => r.leadershipSupport).length / surveyResults.length,
        resourceAvailability: surveyResults.filter(r => r.resourcesAvailable).length / surveyResults.length,
        trainingReadiness: surveyResults.filter(r => r.trainingWillingness).length / surveyResults.length,
        technologyComfort: surveyResults.filter(r => r.technologyComfortable).length / surveyResults.length
      },
      recommendations: this.generateChangeRecommendations(surveyResults)
    };
  }

  private calculateChangeCapacity(surveyResults: SurveyResponse[]): number {
    const factors = [
      surveyResults.filter(r => r.leadershipSupport).length / surveyResults.length,
      surveyResults.filter(r => r.resourcesAvailable).length / surveyResults.length,
      surveyResults.filter(r => r.trainingWillingness).length / surveyResults.length,
      surveyResults.filter(r => r.technologyComfortable).length / surveyResults.length
    ];

    return factors.reduce((sum, factor) => sum + factor, 0) / factors.length;
  }

  private generateChangeRecommendations(surveyResults: SurveyResponse[]): string[] {
    const recommendations: string[] = [];

    const leadershipSupport = surveyResults.filter(r => r.leadershipSupport).length / surveyResults.length;
    if (leadershipSupport < 0.7) {
      recommendations.push('Strengthen leadership communication and support for CDS implementation');
    }

    const trainingWillingness = surveyResults.filter(r => r.trainingWillingness).length / surveyResults.length;
    if (trainingWillingness < 0.6) {
      recommendations.push('Develop comprehensive training program with hands-on practice');
    }

    const technologyComfort = surveyResults.filter(r => r.technologyComfortable).length / surveyResults.length;
    if (technologyComfort < 0.5) {
      recommendations.push('Provide extensive technology support and gradual rollout');
    }

    return recommendations;
  }
}

interface WorkflowAssessment {
  currentWorkflows: WorkflowObservation[];
  clinicianFeedback: SurveyResponse[];
  painPoints: string[];
  efficiencyMetrics: EfficiencyMetrics;
  technologyUsage: TechnologyUsage;
}

interface CDSOpportunity {
  type: string;
  title: string;
  description: string;
  potentialImpact: 'low' | 'medium' | 'high';
  implementationEffort: 'low' | 'medium' | 'high';
  priority: number;
}

interface WorkflowObservation {
  task: string;
  duration: number; // in minutes
  hadErrors: boolean;
  wasInterrupted: boolean;
  toolsUsed: string[];
  painPoints: string[];
}

interface SurveyResponse {
  clinicianId: string;
  reportsErrors: boolean;
  reportsDelays: boolean;
  preventiveCareGaps: boolean;
  leadershipSupport?: boolean;
  resourcesAvailable?: boolean;
  trainingWillingness?: boolean;
  technologyComfortable?: boolean;
}

interface EfficiencyMetrics {
  averageTaskTime: number;
  errorRate: number;
  interruptionRate: number;
  tasksPerHour: number;
  efficiencyScore: number;
}

interface TechnologyUsage {
  overallReadiness: number;
  ehrUsage: number;
  mobileDeviceUsage: number;
  alertResponseRate: number;
  systemSatisfaction: number;
}

interface TechnologyReadiness {
  infrastructure: number;
  integration: number;
  dataQuality: number;
  userAdoption: number;
  overall: number;
}

interface ChangeCapacity {
  overallCapacity: number;
  factors: {
    leadershipSupport: number;
    resourceAvailability: number;
    trainingReadiness: number;
    technologyComfort: number;
  };
  recommendations: string[];
}

CDS Governance Structure

Implementation Governance Committee:

Executive Sponsor (CMO)
├── Clinical Leadership (Department Chiefs, Quality Officer)
├── IT Leadership (CIO, CDS Administrator)
├── Implementation Team (Clinical Informatics, Super Users)
├── End-User Representatives (Physicians, Nurses, Pharmacists)
├── Quality & Safety Committee
├── Compliance Officer
└── Change Management Lead

Decision-Making Framework:

• Strategic Decisions: Executive sponsor and clinical leadership
• Clinical Content Decisions: Clinical leadership and specialists
• Technical Decisions: IT leadership and implementation team
• Workflow Decisions: End-user representatives and implementation team

Phase 2: Technical Integration and Configuration

EHR Integration Architecture

CDS Integration Patterns:

// CDS-EHR Integration Framework
interface CDSEHRIntegration {
  connectToEHR(ehrConfig: EHRConfig): Promise<IntegrationStatus>;
  configureCDSHooks(hooks: CDSHook[]): Promise<void>;
  setupDataMapping(mappings: DataMapping[]): Promise<void>;
  testIntegration(testCases: IntegrationTest[]): Promise<TestResults>;
}

class FHIRCDSIntegrator implements CDSEHRIntegration {
  private ehrClient: EHRClient;
  private cdsEngine: CDSEngine;
  private mappingEngine: DataMappingEngine;

  async connectToEHR(ehrConfig: EHRConfig): Promise<IntegrationStatus> {
    try {
      // Establish FHIR connection
      await this.ehrClient.connect(ehrConfig);

      // Validate FHIR version compatibility
      const ehrVersion = await this.ehrClient.getFHIRVersion();
      if (!this.isCompatibleVersion(ehrVersion)) {
        throw new Error(`Incompatible FHIR version: ${ehrVersion}`);
      }

      // Test basic connectivity
      await this.testBasicConnectivity();

      // Verify required resources
      await this.verifyRequiredResources();

      return {
        status: 'connected',
        ehrVersion,
        capabilities: await this.ehrClient.getCapabilities(),
        lastTested: new Date()
      };

    } catch (error) {
      return {
        status: 'failed',
        error: error.message,
        lastTested: new Date()
      };
    }
  }

  async configureCDSHooks(hooks: CDSHook[]): Promise<void> {
    for (const hook of hooks) {
      // Register hook with EHR
      await this.ehrClient.registerCDSHook(hook);

      // Configure hook-specific settings
      await this.configureHookSettings(hook);

      // Set up data prefetching
      if (hook.prefetch) {
        await this.setupPrefetchQueries(hook);
      }
    }
  }

  async setupDataMapping(mappings: DataMapping[]): Promise<void> {
    for (const mapping of mappings) {
      // Validate mapping rules
      await this.validateMapping(mapping);

      // Store mapping configuration
      await this.mappingEngine.storeMapping(mapping);

      // Test mapping with sample data
      await this.testMapping(mapping);
    }
  }

  async testIntegration(testCases: IntegrationTest[]): Promise<TestResults> {
    const results: TestResults = {
      passed: 0,
      failed: 0,
      total: testCases.length,
      details: []
    };

    for (const testCase of testCases) {
      try {
        const result = await this.runTestCase(testCase);
        results.details.push({
          testCase: testCase.name,
          passed: result.passed,
          duration: result.duration,
          error: result.error
        });

        if (result.passed) {
          results.passed++;
        } else {
          results.failed++;
        }
      } catch (error) {
        results.details.push({
          testCase: testCase.name,
          passed: false,
          duration: 0,
          error: error.message
        });
        results.failed++;
      }
    }

    return results;
  }

  private async testBasicConnectivity(): Promise<void> {
    // Test FHIR metadata endpoint
    const metadata = await this.ehrClient.getMetadata();
    if (!metadata) {
      throw new Error('Failed to retrieve EHR metadata');
    }

    // Test patient search
    const patients = await this.ehrClient.searchPatients({ limit: 1 });
    if (!patients || patients.length === 0) {
      throw new Error('Failed to search patients');
    }
  }

  private async verifyRequiredResources(): Promise<void> {
    const capabilities = await this.ehrClient.getCapabilities();
    const requiredResources = ['Patient', 'MedicationRequest', 'Condition', 'Observation'];

    for (const resource of requiredResources) {
      if (!capabilities.rest[0].resource.find(r => r.type === resource)) {
        throw new Error(`Required resource not available: ${resource}`);
      }
    }
  }

  private isCompatibleVersion(version: string): boolean {
    // Support FHIR R4 and R4B
    return ['4.0.1', '4.3.0'].includes(version);
  }

  private async configureHookSettings(hook: CDSHook): Promise<void> {
    // Configure hook-specific settings based on type
    switch (hook.id) {
      case 'patient-view':
        await this.configurePatientViewHook(hook);
        break;
      case 'medication-prescribe':
        await this.configureMedicationPrescribeHook(hook);
        break;
      case 'order-select':
        await this.configureOrderSelectHook(hook);
        break;
    }
  }

  private async setupPrefetchQueries(hook: CDSHook): Promise<void> {
    if (!hook.prefetch) return;

    // Validate prefetch queries
    for (const [key, query] of Object.entries(hook.prefetch)) {
      await this.validatePrefetchQuery(key, query);
    }

    // Store prefetch configuration
    await this.ehrClient.storePrefetchConfig(hook.id, hook.prefetch);
  }

  private async validateMapping(mapping: DataMapping): Promise<void> {
    // Validate source and target field compatibility
    if (!await this.mappingEngine.validateFieldCompatibility(mapping.source, mapping.target)) {
      throw new Error(`Incompatible field mapping: ${mapping.source.field} -> ${mapping.target.field}`);
    }

    // Validate transformation rules
    if (mapping.transformation) {
      await this.mappingEngine.validateTransformation(mapping.transformation);
    }
  }

  private async testMapping(mapping: DataMapping): Promise<void> {
    // Get sample data
    const sampleData = await this.getSampleData(mapping.source.resource);

    // Apply mapping
    const mappedData = await this.mappingEngine.applyMapping(mapping, sampleData);

    // Validate result
    if (!await this.validateMappedData(mappedData, mapping.target)) {
      throw new Error(`Mapping test failed for ${mapping.source.field}`);
    }
  }

  private async runTestCase(testCase: IntegrationTest): Promise<TestResult> {
    const startTime = Date.now();

    try {
      switch (testCase.type) {
        case 'hook_trigger':
          return await this.testHookTrigger(testCase);
        case 'data_mapping':
          return await this.testDataMapping(testCase);
        case 'cds_response':
          return await this.testCDSResponse(testCase);
        default:
          throw new Error(`Unknown test type: ${testCase.type}`);
      }
    } catch (error) {
      return {
        passed: false,
        duration: Date.now() - startTime,
        error: error.message
      };
    }
  }

  private async testHookTrigger(testCase: IntegrationTest): Promise<TestResult> {
    // Simulate hook trigger
    const response = await this.cdsEngine.processHook(testCase.hookRequest);

    // Validate response
    const isValid = this.validateHookResponse(response, testCase.expectedResponse);

    return {
      passed: isValid,
      duration: 0
    };
  }

  private async testDataMapping(testCase: IntegrationTest): Promise<TestResult> {
    // Test data mapping
    const mappedData = await this.mappingEngine.applyMapping(testCase.mapping, testCase.inputData);

    // Validate mapping result
    const isValid = this.compareData(mappedData, testCase.expectedOutput);

    return {
      passed: isValid,
      duration: 0
    };
  }

  private async testCDSResponse(testCase: IntegrationTest): Promise<TestResult> {
    // Test CDS response generation
    const response = await this.cdsEngine.generateResponse(testCase.cdsRequest);

    // Validate CDS response
    const isValid = this.validateCDSResponse(response, testCase.expectedCDSResponse);

    return {
      passed: isValid,
      duration: 0
    };
  }

  // Helper methods
  private async getSampleData(resourceType: string): Promise<any> {
    // Get sample data from EHR
    return await this.ehrClient.getSampleData(resourceType);
  }

  private async validateMappedData(data: any, target: DataTarget): Promise<boolean> {
    // Validate mapped data against target schema
    return await this.mappingEngine.validateTargetData(data, target);
  }

  private validateHookResponse(response: any, expected: any): boolean {
    // Validate hook response structure
    return response.cards && Array.isArray(response.cards);
  }

  private compareData(actual: any, expected: any): boolean {
    // Compare actual vs expected data
    return JSON.stringify(actual) === JSON.stringify(expected);
  }

  private validateCDSResponse(response: any, expected: any): boolean {
    // Validate CDS response structure
    return response.cards && response.cards.length > 0;
  }
}

interface EHRConfig {
  baseUrl: string;
  authMethod: 'basic' | 'oauth' | 'bearer';
  credentials?: {
    username?: string;
    password?: string;
    token?: string;
  };
  headers?: Record<string, string>;
}

interface IntegrationStatus {
  status: 'connected' | 'failed';
  ehrVersion?: string;
  capabilities?: any;
  error?: string;
  lastTested: Date;
}

interface CDSHook {
  id: string;
  title: string;
  description: string;
  prefetch?: Record<string, string>;
}

interface DataMapping {
  id: string;
  source: DataSource;
  target: DataTarget;
  transformation?: TransformationRule;
}

interface DataSource {
  resource: string;
  field: string;
}

interface DataTarget {
  resource: string;
  field: string;
}

interface TransformationRule {
  type: 'direct' | 'lookup' | 'calculation' | 'conditional';
  parameters: any;
}

interface IntegrationTest {
  name: string;
  type: 'hook_trigger' | 'data_mapping' | 'cds_response';
  hookRequest?: any;
  mapping?: DataMapping;
  inputData?: any;
  cdsRequest?: any;
  expectedResponse?: any;
  expectedOutput?: any;
  expectedCDSResponse?: any;
}

interface TestResults {
  passed: number;
  failed: number;
  total: number;
  details: TestResult[];
}

interface TestResult {
  testCase: string;
  passed: boolean;
  duration: number;
  error?: string;
}

Alert Customization and Optimization

Smart Alert Management:

// Intelligent Alert Management System
interface AlertManager {
  configureAlerts(alerts: AlertConfig[]): Promise<void>;
  optimizeAlertPerformance(): Promise<OptimizationResult>;
  monitorAlertEffectiveness(): Promise<AlertMetrics>;
  adaptAlertThresholds(): Promise<void>;
}

class IntelligentAlertManager implements AlertManager {
  private alertEngine: AlertEngine;
  private performanceMonitor: PerformanceMonitor;
  private adaptationEngine: AdaptationEngine;

  async configureAlerts(alerts: AlertConfig[]): Promise<void> {
    for (const alert of alerts) {
      // Validate alert configuration
      await this.validateAlertConfig(alert);

      // Set up alert logic
      await this.alertEngine.configureAlert(alert);

      // Configure alert overrides
      await this.setupAlertOverrides(alert);

      // Set up alert monitoring
      await this.setupAlertMonitoring(alert);
    }
  }

  async optimizeAlertPerformance(): Promise<OptimizationResult> {
    const metrics = await this.monitorAlertEffectiveness();

    const optimizations: AlertOptimization[] = [];

    // Identify high-override alerts
    const highOverrideAlerts = metrics.alerts.filter(a => a.overrideRate > 0.8);
    for (const alert of highOverrideAlerts) {
      optimizations.push({
        alertId: alert.id,
        type: 'threshold_adjustment',
        description: 'Increase alert threshold to reduce false positives',
        expectedImpact: 'reduce overrides by 30%'
      });
    }

    // Identify low-response alerts
    const lowResponseAlerts = metrics.alerts.filter(a => a.responseRate < 0.2);
    for (const alert of lowResponseAlerts) {
      optimizations.push({
        alertId: alert.id,
        type: 'alert_enhancement',
        description: 'Improve alert messaging and context',
        expectedImpact: 'increase response rate by 25%'
      });
    }

    // Identify timing issues
    const timingIssues = metrics.alerts.filter(a => a.averageResponseTime > 30);
    for (const alert of timingIssues) {
      optimizations.push({
        alertId: alert.id,
        type: 'timing_optimization',
        description: 'Adjust alert timing for better workflow integration',
        expectedImpact: 'reduce response time by 40%'
      });
    }

    // Apply optimizations
    for (const optimization of optimizations) {
      await this.applyOptimization(optimization);
    }

    return {
      optimizationsApplied: optimizations.length,
      expectedImprovements: optimizations,
      monitoringPeriod: 30 // days
    };
  }

  async monitorAlertEffectiveness(): Promise<AlertMetrics> {
    const alerts = await this.alertEngine.getAllAlerts();
    const metrics: AlertMetrics = {
      totalAlerts: alerts.length,
      overallResponseRate: 0,
      overallOverrideRate: 0,
      alerts: []
    };

    let totalResponses = 0;
    let totalOverrides = 0;
    let totalAlertsTriggered = 0;

    for (const alert of alerts) {
      const alertMetrics = await this.performanceMonitor.getAlertMetrics(alert.id);

      metrics.alerts.push({
        id: alert.id,
        name: alert.name,
        triggers: alertMetrics.triggers,
        responses: alertMetrics.responses,
        overrides: alertMetrics.overrides,
        responseRate: alertMetrics.triggers > 0 ? alertMetrics.responses / alertMetrics.triggers : 0,
        overrideRate: alertMetrics.triggers > 0 ? alertMetrics.overrides / alertMetrics.triggers : 0,
        averageResponseTime: alertMetrics.averageResponseTime
      });

      totalResponses += alertMetrics.responses;
      totalOverrides += alertMetrics.overrides;
      totalAlertsTriggered += alertMetrics.triggers;
    }

    metrics.overallResponseRate = totalAlertsTriggered > 0 ? totalResponses / totalAlertsTriggered : 0;
    metrics.overallOverrideRate = totalAlertsTriggered > 0 ? totalOverrides / totalAlertsTriggered : 0;

    return metrics;
  }

  async adaptAlertThresholds(): Promise<void> {
    const metrics = await this.monitorAlertEffectiveness();

    for (const alertMetric of metrics.alerts) {
      // Adapt thresholds based on performance
      if (alertMetric.overrideRate > 0.7) {
        // Increase threshold to reduce false positives
        await this.adaptationEngine.adjustThreshold(alertMetric.id, 'increase', 0.1);
      } else if (alertMetric.responseRate < 0.3) {
        // Decrease threshold to increase sensitivity
        await this.adaptationEngine.adjustThreshold(alertMetric.id, 'decrease', 0.1);
      }

      // Adapt timing based on response patterns
      if (alertMetric.averageResponseTime > 20) {
        await this.adaptationEngine.optimizeTiming(alertMetric.id);
      }
    }
  }

  private async validateAlertConfig(alert: AlertConfig): Promise<void> {
    // Validate alert logic
    if (!alert.condition) {
      throw new Error('Alert must have a condition');
    }

    // Validate alert message
    if (!alert.message || alert.message.length < 10) {
      throw new Error('Alert message must be descriptive');
    }

    // Validate severity level
    if (!['low', 'medium', 'high', 'critical'].includes(alert.severity)) {
      throw new Error('Invalid alert severity level');
    }

    // Validate timing
    if (alert.timing && !this.isValidTiming(alert.timing)) {
      throw new Error('Invalid alert timing configuration');
    }
  }

  private async setupAlertOverrides(alert: AlertConfig): Promise<void> {
    // Set up override reasons
    const overrideReasons = [
      'Clinician judgment',
      'Patient preference',
      'Alternative therapy planned',
      'Documentation error',
      'System error'
    ];

    await this.alertEngine.configureOverrideReasons(alert.id, overrideReasons);
  }

  private async setupAlertMonitoring(alert: AlertConfig): Promise<void> {
    // Set up performance monitoring
    await this.performanceMonitor.enableMonitoring(alert.id, {
      trackResponses: true,
      trackOverrides: true,
      trackTiming: true,
      trackContext: true
    });
  }

  private isValidTiming(timing: AlertTiming): boolean {
    // Validate timing configuration
    if (timing.immediate && timing.scheduled) {
      return false; // Cannot be both immediate and scheduled
    }

    if (timing.scheduled && !timing.schedule) {
      return false; // Scheduled alerts need schedule configuration
    }

    return true;
  }

  private async applyOptimization(optimization: AlertOptimization): Promise<void> {
    switch (optimization.type) {
      case 'threshold_adjustment':
        await this.alertEngine.adjustThreshold(optimization.alertId, 0.1);
        break;
      case 'alert_enhancement':
        await this.alertEngine.enhanceAlertMessaging(optimization.alertId);
        break;
      case 'timing_optimization':
        await this.alertEngine.optimizeAlertTiming(optimization.alertId);
        break;
    }
  }
}

interface AlertConfig {
  id: string;
  name: string;
  condition: string;
  message: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  timing: AlertTiming;
  overrides: boolean;
  context: AlertContext;
}

interface AlertTiming {
  immediate: boolean;
  scheduled: boolean;
  schedule?: {
    frequency: string;
    timeOfDay?: string;
    daysOfWeek?: number[];
  };
}

interface AlertContext {
  patientRequired: boolean;
  encounterRequired: boolean;
  userRole?: string[];
  department?: string[];
}

interface AlertMetrics {
  totalAlerts: number;
  overallResponseRate: number;
  overallOverrideRate: number;
  alerts: AlertMetric[];
}

interface AlertMetric {
  id: string;
  name: string;
  triggers: number;
  responses: number;
  overrides: number;
  responseRate: number;
  overrideRate: number;
  averageResponseTime: number;
}

interface AlertOptimization {
  alertId: string;
  type: 'threshold_adjustment' | 'alert_enhancement' | 'timing_optimization';
  description: string;
  expectedImpact: string;
}

interface OptimizationResult {
  optimizationsApplied: number;
  expectedImprovements: AlertOptimization[];
  monitoringPeriod: number;
}

Phase 3: Provider Training and Change Management

Comprehensive Training Program

Multi-Modal Training Strategy:

// CDS Training Management System
interface TrainingManager {
  designTrainingProgram(requirements: TrainingRequirements): Promise<TrainingProgram>;
  deliverTraining(program: TrainingProgram): Promise<TrainingResults>;
  assessCompetency(program: TrainingProgram): Promise<CompetencyAssessment>;
  provideOngoingSupport(): Promise<SupportMetrics>;
}

class CDSTrainingManager implements TrainingManager {
  private contentLibrary: TrainingContentLibrary;
  private learningManagement: LearningManagementSystem;
  private assessmentEngine: AssessmentEngine;

  async designTrainingProgram(requirements: TrainingRequirements): Promise<TrainingProgram> {
    const program: TrainingProgram = {
      id: this.generateProgramId(),
      title: 'Clinical Decision Support Training Program',
      modules: [],
      duration: 0,
      format: requirements.preferredFormat,
      audience: requirements.audience,
      prerequisites: requirements.prerequisites
    };

    // Core CDS concepts module
    program.modules.push(await this.designCoreConceptsModule());

    // Alert management module
    program.modules.push(await this.designAlertManagementModule());

    // Workflow integration module
    program.modules.push(await this.designWorkflowIntegrationModule());

    // Specialty-specific modules
    for (const specialty of requirements.specialties) {
      program.modules.push(await this.designSpecialtyModule(specialty));
    }

    // Advanced features module
    program.modules.push(await this.designAdvancedFeaturesModule());

    // Calculate total duration
    program.duration = program.modules.reduce((sum, module) => sum + module.duration, 0);

    return program;
  }

  async deliverTraining(program: TrainingProgram): Promise<TrainingResults> {
    const results: TrainingResults = {
      programId: program.id,
      participants: 0,
      completionRate: 0,
      averageScore: 0,
      moduleResults: []
    };

    // Deliver each module
    for (const module of program.modules) {
      const moduleResult = await this.deliverModule(module);
      results.moduleResults.push(moduleResult);
    }

    // Calculate overall results
    results.participants = program.audience.length;
    results.completionRate = results.moduleResults.reduce((sum, r) => sum + r.completionRate, 0) / results.moduleResults.length;
    results.averageScore = results.moduleResults.reduce((sum, r) => sum + r.averageScore, 0) / results.moduleResults.length;

    return results;
  }

  async assessCompetency(program: TrainingProgram): Promise<CompetencyAssessment> {
    const assessment = await this.assessmentEngine.createAssessment(program);

    // Administer assessment
    const results = await this.assessmentEngine.administerAssessment(assessment);

    // Analyze results
    const competencyLevels = await this.analyzeCompetencyResults(results);

    return {
      programId: program.id,
      overallCompetency: this.calculateOverallCompetency(competencyLevels),
      competencyByModule: competencyLevels,
      recommendations: this.generateCompetencyRecommendations(competencyLevels)
    };
  }

  async provideOngoingSupport(): Promise<SupportMetrics> {
    // Provide just-in-time support
    const jitSupport = await this.setupJITSupport();

    // Monitor support usage
    const usageMetrics = await this.monitorSupportUsage();

    // Provide refresher training
    const refresherTraining = await this.deliverRefresherTraining();

    return {
      jitSupportRequests: jitSupport.requests,
      averageResolutionTime: jitSupport.averageResolutionTime,
      userSatisfaction: usageMetrics.satisfaction,
      refresherCompletions: refresherTraining.completions
    };
  }

  private async designCoreConceptsModule(): Promise<TrainingModule> {
    return {
      id: 'core-concepts',
      title: 'CDS Core Concepts',
      content: [
        {
          type: 'video',
          title: 'Introduction to Clinical Decision Support',
          duration: 15,
          content: 'Overview of CDS purpose, benefits, and functionality'
        },
        {
          type: 'interactive',
          title: 'CDS Alert Types and Purposes',
          duration: 20,
          content: 'Interactive exploration of different alert types'
        },
        {
          type: 'scenario',
          title: 'Real-World CDS Examples',
          duration: 25,
          content: 'Case studies showing CDS in clinical practice'
        }
      ],
      duration: 60,
      assessment: {
        type: 'quiz',
        questions: 10,
        passingScore: 80
      },
      prerequisites: []
    };
  }

  private async designAlertManagementModule(): Promise<TrainingModule> {
    return {
      id: 'alert-management',
      title: 'Managing CDS Alerts',
      content: [
        {
          type: 'demonstration',
          title: 'Alert Response Workflow',
          duration: 15,
          content: 'Step-by-step guide to responding to alerts'
        },
        {
          type: 'simulation',
          title: 'Alert Override Scenarios',
          duration: 30,
          content: 'Practice scenarios for appropriate alert overrides'
        },
        {
          type: 'workshop',
          title: 'Alert Customization',
          duration: 45,
          content: 'How to customize alerts for individual preferences'
        }
      ],
      duration: 90,
      assessment: {
        type: 'scenario_based',
        scenarios: 5,
        passingScore: 85
      },
      prerequisites: ['core-concepts']
    };
  }

  private async designWorkflowIntegrationModule(): Promise<TrainingModule> {
    return {
      id: 'workflow-integration',
      title: 'CDS in Clinical Workflows',
      content: [
        {
          type: 'workflow_analysis',
          title: 'Current Workflow Assessment',
          duration: 20,
          content: 'Analyze how CDS fits into existing workflows'
        },
        {
          type: 'optimization',
          title: 'Workflow Optimization Techniques',
          duration: 35,
          content: 'Strategies for optimizing workflows with CDS'
        },
        {
          type: 'integration_practice',
          title: 'Hands-on Integration',
          duration: 40,
          content: 'Practice integrating CDS into clinical workflows'
        }
      ],
      duration: 95,
      assessment: {
        type: 'workflow_design',
        passingScore: 75
      },
      prerequisites: ['alert-management']
    };
  }

  private async designSpecialtyModule(specialty: string): Promise<TrainingModule> {
    const specialtyContent = await this.contentLibrary.getSpecialtyContent(specialty);

    return {
      id: `specialty-${specialty.toLowerCase()}`,
      title: `${specialty} CDS Applications`,
      content: specialtyContent,
      duration: 45,
      assessment: {
        type: 'specialty_quiz',
        questions: 15,
        passingScore: 80
      },
      prerequisites: ['workflow-integration']
    };
  }

  private async designAdvancedFeaturesModule(): Promise<TrainingModule> {
    return {
      id: 'advanced-features',
      title: 'Advanced CDS Features',
      content: [
        {
          type: 'deep_dive',
          title: 'Order Sets and Protocols',
          duration: 25,
          content: 'Advanced use of order sets and clinical protocols'
        },
        {
          type: 'analytics',
          title: 'CDS Performance Analytics',
          duration: 20,
          content: 'Understanding and improving CDS performance'
        },
        {
          type: 'customization',
          title: 'Advanced Customization',
          duration: 30,
          content: 'Advanced alert and workflow customization'
        }
      ],
      duration: 75,
      assessment: {
        type: 'project_based',
        passingScore: 85
      },
      prerequisites: ['workflow-integration']
    };
  }

  private async deliverModule(module: TrainingModule): Promise<ModuleResult> {
    const result: ModuleResult = {
      moduleId: module.id,
      participants: module.audience?.length || 0,
      completionRate: 0,
      averageScore: 0,
      averageTime: 0
    };

    // Deliver content based on format
    switch (module.format) {
      case 'online':
        const onlineResult = await this.deliverOnlineModule(module);
        result.completionRate = onlineResult.completionRate;
        result.averageScore = onlineResult.averageScore;
        result.averageTime = onlineResult.averageTime;
        break;
      case 'instructor_led':
        const classroomResult = await this.deliverClassroomModule(module);
        result.completionRate = classroomResult.completionRate;
        result.averageScore = classroomResult.averageScore;
        result.averageTime = classroomResult.averageTime;
        break;
      case 'blended':
        const blendedResult = await this.deliverBlendedModule(module);
        result.completionRate = blendedResult.completionRate;
        result.averageScore = blendedResult.averageScore;
        result.averageTime = blendedResult.averageTime;
        break;
    }

    return result;
  }

  private async deliverOnlineModule(module: TrainingModule): Promise<DeliveryResult> {
    // Implementation for online delivery
    return {
      completionRate: 0.85,
      averageScore: 82,
      averageTime: module.duration * 1.2
    };
  }

  private async deliverClassroomModule(module: TrainingModule): Promise<DeliveryResult> {
    // Implementation for classroom delivery
    return {
      completionRate: 0.95,
      averageScore: 88,
      averageTime: module.duration
    };
  }

  private async deliverBlendedModule(module: TrainingModule): Promise<DeliveryResult> {
    // Implementation for blended delivery
    return {
      completionRate: 0.90,
      averageScore: 85,
      averageTime: module.duration * 1.1
    };
  }

  private async analyzeCompetencyResults(results: AssessmentResult[]): Promise<CompetencyByModule> {
    const competencyByModule: CompetencyByModule = {};

    // Group results by module
    for (const result of results) {
      if (!competencyByModule[result.moduleId]) {
        competencyByModule[result.moduleId] = {
          moduleId: result.moduleId,
          averageScore: 0,
          passRate: 0,
          competencyLevel: 'beginner'
        };
      }

      competencyByModule[result.moduleId].averageScore += result.score;
      if (result.passed) {
        competencyByModule[result.moduleId].passRate++;
      }
    }

    // Calculate averages and competency levels
    for (const moduleId in competencyByModule) {
      const module = competencyByModule[moduleId];
      const resultsForModule = results.filter(r => r.moduleId === moduleId);

      module.averageScore /= resultsForModule.length;
      module.passRate /= resultsForModule.length;

      module.competencyLevel = this.determineCompetencyLevel(module.averageScore, module.passRate);
    }

    return competencyByModule;
  }

  private calculateOverallCompetency(competencyByModule: CompetencyByModule): number {
    const scores = Object.values(competencyByModule).map(m => m.averageScore);
    return scores.reduce((sum, score) => sum + score, 0) / scores.length;
  }

  private generateCompetencyRecommendations(competencyByModule: CompetencyByModule): string[] {
    const recommendations: string[] = [];

    for (const [moduleId, competency] of Object.entries(competencyByModule)) {
      if (competency.averageScore < 70) {
        recommendations.push(`Additional training needed for ${moduleId} module`);
      }

      if (competency.passRate < 0.8) {
        recommendations.push(`Remediation program required for ${moduleId} module`);
      }
    }

    return recommendations;
  }

  private determineCompetencyLevel(score: number, passRate: number): string {
    const combinedScore = (score + passRate * 100) / 2;

    if (combinedScore >= 90) return 'expert';
    if (combinedScore >= 80) return 'advanced';
    if (combinedScore >= 70) return 'intermediate';
    return 'beginner';
  }

  private async setupJITSupport(): Promise<JITSupport> {
    // Set up just-in-time support resources
    return {
      requests: 0,
      averageResolutionTime: 0
    };
  }

  private async monitorSupportUsage(): Promise<SupportUsage> {
    // Monitor ongoing support usage
    return {
      satisfaction: 0.85
    };
  }

  private async deliverRefresherTraining(): Promise<RefresherTraining> {
    // Deliver refresher training sessions
    return {
      completions: 0
    };
  }

  private generateProgramId(): string {
    return `cds-training-${Date.now()}`;
  }
}

interface TrainingRequirements {
  audience: Clinician[];
  specialties: string[];
  preferredFormat: 'online' | 'instructor_led' | 'blended';
  timeline: number; // weeks
  prerequisites: string[];
}

interface TrainingProgram {
  id: string;
  title: string;
  modules: TrainingModule[];
  duration: number; // minutes
  format: string;
  audience: Clinician[];
  prerequisites: string[];
}

interface TrainingModule {
  id: string;
  title: string;
  content: TrainingContent[];
  duration: number;
  assessment: Assessment;
  prerequisites: string[];
  audience?: Clinician[];
}

interface TrainingContent {
  type: string;
  title: string;
  duration: number;
  content: string;
}

interface Assessment {
  type: string;
  questions?: number;
  scenarios?: number;
  passingScore: number;
}

interface TrainingResults {
  programId: string;
  participants: number;
  completionRate: number;
  averageScore: number;
  moduleResults: ModuleResult[];
}

interface ModuleResult {
  moduleId: string;
  participants: number;
  completionRate: number;
  averageScore: number;
  averageTime: number;
}

interface CompetencyAssessment {
  programId: string;
  overallCompetency: number;
  competencyByModule: CompetencyByModule;
  recommendations: string[];
}

interface CompetencyByModule {
  [moduleId: string]: {
    moduleId: string;
    averageScore: number;
    passRate: number;
    competencyLevel: string;
  };
}

interface SupportMetrics {
  jitSupportRequests: number;
  averageResolutionTime: number;
  userSatisfaction: number;
  refresherCompletions: number;
}

interface DeliveryResult {
  completionRate: number;
  averageScore: number;
  averageTime: number;
}

interface JITSupport {
  requests: number;
  averageResolutionTime: number;
}

interface SupportUsage {
  satisfaction: number;
}

interface RefresherTraining {
  completions: number;
}

interface Clinician {
  id: string;
  name: string;
  specialty: string;
  role: string;
  experience: number;
}

Phase 4: Monitoring, Optimization, and Continuous Improvement

Performance Monitoring and Analytics

CDS Effectiveness Dashboard:

// CDS Performance Monitoring Dashboard
interface PerformanceDashboard {
  getKPIs(): Promise<CDSKPIs>;
  getAlertMetrics(): Promise<AlertMetrics>;
  getUserAdoptionMetrics(): Promise<AdoptionMetrics>;
  getClinicalImpactMetrics(): Promise<ClinicalImpactMetrics>;
  generateOptimizationRecommendations(): Promise<OptimizationRecommendation[]>;
}

class CDSPerformanceDashboard implements PerformanceDashboard {
  private metricsCollector: MetricsCollector;
  private analyticsEngine: AnalyticsEngine;
  private reportingEngine: ReportingEngine;

  async getKPIs(): Promise<CDSKPIs> {
    const period = this.getCurrentPeriod();

    return {
      alertMetrics: await this.getAlertKPIs(period),
      adoptionMetrics: await this.getAdoptionKPIs(period),
      clinicalMetrics: await this.getClinicalKPIs(period),
      efficiencyMetrics: await this.getEfficiencyKPIs(period),
      period
    };
  }

  async getAlertMetrics(): Promise<AlertMetrics> {
    return await this.metricsCollector.getAlertMetrics();
  }

  async getUserAdoptionMetrics(): Promise<AdoptionMetrics> {
    const adoption = await this.analyticsEngine.calculateAdoptionMetrics();

    return {
      userCoverage: adoption.userCoverage,
      featureUtilization: adoption.featureUtilization,
      trainingCompletion: adoption.trainingCompletion,
      satisfactionScores: adoption.satisfactionScores,
      resistanceIndicators: adoption.resistanceIndicators
    };
  }

  async getClinicalImpactMetrics(): Promise<ClinicalImpactMetrics> {
    const clinical = await this.analyticsEngine.calculateClinicalImpact();

    return {
      medicationErrorsPrevented: clinical.medicationErrorsPrevented,
      adverseEventsAvoided: clinical.adverseEventsAvoided,
      guidelineAdherence: clinical.guidelineAdherence,
      diagnosticAccuracy: clinical.diagnosticAccuracy,
      patientOutcomes: clinical.patientOutcomes
    };
  }

  supportChannels: SupportChannel[];
  quickReferences: QuickReference[];
  peerMentoring: PeerMentoringProgram;
  refresherTraining: RefresherTraining;
  utilizationMetrics: SupportMetrics;
}

interface KnowledgeGap {
  competency: string;
  currentLevel: number;
  requiredLevel: number;
  gapSize: number;
  priority: number;
}

interface TrainingRequirement {
  competency: string;
  trainingType: string;
  duration: number;
  frequency: string;
  deliveryMethod: string;
  prerequisites: string[];
}

type TrainingApproach =
  | "instructor_led"
  | "blended_learning"
  | "self_paced_online";

interface TrainingModule {
  title: string;
  topic: string;
  duration: number;
  objectives: string[];
  content: Content;
  assessment: Assessment;
}

interface BaselineAssessment {
  competencyLevels: { [key: string]: number };
  experienceLevels: { [key: string]: string };
  technologyComfort: number;
}

interface Competency {
  id: string;
  name: string;
  requiredLevel: number;
  importance: number;
}

interface PostTrainingAssessment {
  competencyLevels: { [key: string]: number };
  improvementAreas: string[];
}

interface BehavioralChange {
  behavior: string;
  adoptionRate: number;
  impact: number;
}

interface TrainingSchedule {
  sessions: TrainingSession[];
  timeline: string;
  milestones: string[];
}

interface Facilitator {
  id: string;
  name: string;
  expertise: string[];
  availability: string[];
}

interface DeliveryResults {
  attendance: Attendance;
  satisfaction: Satisfaction;
  feedback: Feedback[];
}

interface Attendance {
  totalRegistered: number;
  totalAttended: number;
  completionRate: number;
}

interface CompletionRates {
  overall: number;
  byModule: { [key: string]: number };
  byRole: { [key: string]: number };
}

interface SupportChannel {
  type: string;
  availability: string;
  contactInfo: string;
}

interface QuickReference {
  title: string;
  content: string;
  format: string;
}

interface PeerMentoringProgram {
  mentors: string[];
  mentees: string[];
  matchingCriteria: string[];
}

interface RefresherTraining {
  schedule: string;
  topics: string[];
  format: string;
}

interface SupportMetrics {
  totalQueries: number;
  resolutionRate: number;
  averageResponseTime: number;
  satisfactionScore: number;
}

Phase 4: Performance Monitoring and Optimization

Real-Time CDS Performance Dashboard

Comprehensive Monitoring System:

// CDS Performance Monitoring and Analytics
interface PerformanceMonitoring {
  trackCDSMetrics(): Promise<CDSMetrics>;
  monitorAlertEffectiveness(): Promise<AlertEffectiveness>;
  analyzeUserBehavior(): Promise<UserBehaviorAnalytics>;
  generateOptimizationRecommendations(): Promise<OptimizationRecommendation[]>;
  implementPerformanceOptimizations(): Promise<OptimizationResults>;
}

class CDSPerformanceMonitor implements PerformanceMonitoring {
  private metricsCollector: MetricsCollector;
  private analyticsEngine: AnalyticsEngine;
  private optimizationEngine: OptimizationEngine;

  constructor() {
    this.metricsCollector = new MetricsCollector();
    this.analyticsEngine = new AnalyticsEngine();
    this.optimizationEngine = new OptimizationEngine();
  }

  async trackCDSMetrics(): Promise<CDSMetrics> {
    // Collect real-time metrics
    const realTimeMetrics = await this.metricsCollector.collectRealTimeMetrics();

    // Calculate performance indicators
    const performanceIndicators = await this.calculatePerformanceIndicators(realTimeMetrics);

    // Generate trends analysis
    const trends = await this.analyzeTrends(realTimeMetrics);

    return {
      realTime: realTimeMetrics,
      indicators: performanceIndicators,
      trends: trends,
      alerts: await this.generatePerformanceAlerts(performanceIndicators),
      timestamp: new Date()
    };
  }

  async monitorAlertEffectiveness(): Promise<AlertEffectiveness> {
    // Collect alert interaction data
    const alertInteractions = await this.metricsCollector.collectAlertInteractions();

    // Calculate effectiveness metrics
    const effectiveness = await this.calculateAlertEffectiveness(alertInteractions);

    // Identify optimization opportunities
    const opportunities = await this.identifyAlertOptimizationOpportunities(effectiveness);

    return {
      overallEffectiveness: effectiveness.overallScore,
      acceptanceRate: effectiveness.acceptanceRate,
      overrideRate: effectiveness.overrideRate,
      clinicalImpact: effectiveness.clinicalImpact,
      fatigueIndicators: effectiveness.fatigueIndicators,
      optimizationOpportunities: opportunities
    };
  }

  async analyzeUserBehavior(): Promise<UserBehaviorAnalytics> {
    // Collect user interaction data
    const userInteractions = await this.metricsCollector.collectUserInteractions();

    // Analyze behavior patterns
    const patterns = await this.analyticsEngine.analyzeBehaviorPatterns(userInteractions);

    // Identify user segments
    const segments = await this.analyticsEngine.identifyUserSegments(patterns);

    // Generate personalization recommendations
    const recommendations = await this.generatePersonalizationRecommendations(segments);

    return {
      behaviorPatterns: patterns,
      userSegments: segments,
      personalizationRecommendations: recommendations,
      engagementMetrics: await this.calculateEngagementMetrics(userInteractions)
    };
  }

  async generateOptimizationRecommendations(): Promise<OptimizationRecommendation[]> {
    const metrics = await this.trackCDSMetrics();
    const alertEffectiveness = await this.monitorAlertEffectiveness();
    const userBehavior = await this.analyzeUserBehavior();

    const recommendations: OptimizationRecommendation[] = [];

    // Generate recommendations based on metrics
    if (metrics.indicators.alertFatigue > 0.7) {
      recommendations.push({
        type: 'alert_optimization',
        priority: 'high',
        description: 'Implement alert fatigue reduction measures',
        expectedImpact: 0.3,
        implementationEffort: 'medium',
        rationale: `Current alert fatigue level: ${(metrics.indicators.alertFatigue * 100).toFixed(1)}%`
      });
    }

    if (alertEffectiveness.acceptanceRate < 0.5) {
      recommendations.push({