@erosolaraijs/cure 1.0.0

package/src/validation/retrospectiveValidator.ts

@@ -0,0 +1,887 @@
+/**
+ * Retrospective Validation Framework
+ *
+ * Provides tools for validating the treatment recommendation system against
+ * real patient outcomes. Essential for:
+ * - Model performance assessment
+ * - Calibration checking
+ * - Concordance analysis with actual treatments
+ * - Outcome correlation studies
+ * - Continuous quality improvement
+ *
+ * IMPORTANT: All patient data used for validation must be properly de-identified
+ * or used with appropriate IRB approval and patient consent.
+ */
+
+import { EventEmitter } from 'events';
+import { createHash } from 'crypto';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VALIDATION DATA TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface ValidationPatient {
+  id: string; // De-identified ID
+  demographics: {
+    ageAtDiagnosis: number;
+    gender: 'male' | 'female';
+    ethnicity?: string;
+  };
+  diagnosis: {
+    cancerType: string;
+    histology?: string;
+    stage: string;
+    diagnosisDate: Date;
+    biomarkers?: { name: string; value: string | number; status?: string }[];
+    genomicAlterations?: { gene: string; alteration: string }[];
+    msiStatus?: 'MSI-H' | 'MSI-L' | 'MSS';
+    tmbValue?: number;
+    pdl1Score?: number;
+    hrdStatus?: boolean;
+  };
+  treatment: {
+    regimen: string;
+    drugs: string[];
+    setting: string;
+    startDate: Date;
+    endDate?: Date;
+    cycles?: number;
+    doseModifications?: boolean;
+  };
+  outcomes: {
+    bestResponse?: 'CR' | 'PR' | 'SD' | 'PD' | 'NE';
+    responseDate?: Date;
+    progressionDate?: Date;
+    deathDate?: Date;
+    lastFollowUpDate: Date;
+    causeOfDeath?: 'disease' | 'treatment' | 'other' | 'unknown';
+    toxicities?: { name: string; grade: number; date?: Date }[];
+  };
+  ecogAtBaseline?: number;
+  priorLines?: number;
+}
+
+export interface SystemRecommendation {
+  patientId: string;
+  recommendedRegimen: string;
+  recommendedDrugs: string[];
+  predictions: {
+    responseRate: number;
+    pfsMonths: number;
+    osMonths: number;
+    toxicityRisk: number;
+  };
+  matchingBiomarkers: string[];
+  confidenceScore: number;
+  timestamp: Date;
+}
+
+export interface ValidationResult {
+  patientId: string;
+  concordance: {
+    regimenMatch: boolean;
+    partialMatch: boolean; // At least one drug matches
+    matchedDrugs: string[];
+  };
+  outcomeComparison: {
+    predictedResponse: number;
+    actualResponse?: 'CR' | 'PR' | 'SD' | 'PD' | 'NE';
+    responseCorrect?: boolean;
+
+    predictedPFS: number;
+    actualPFS?: number; // months
+    pfsDifference?: number;
+
+    predictedOS: number;
+    actualOS?: number; // months
+    osDifference?: number;
+
+    predictedToxicityRisk: number;
+    actualGrade3PlusToxicity: boolean;
+  };
+  clinicalBenefit: {
+    objectiveResponse: boolean;
+    diseaseControl: boolean;
+    durableBenefit: boolean; // PFS > 6 months
+  };
+}
+
+export interface CohortAnalysis {
+  cohortId: string;
+  description: string;
+  patientCount: number;
+  dateRange: { start: Date; end: Date };
+
+  // Demographics
+  demographics: {
+    medianAge: number;
+    ageRange: [number, number];
+    genderDistribution: { male: number; female: number };
+    stageDistribution: Record<string, number>;
+  };
+
+  // Concordance metrics
+  concordance: {
+    fullConcordance: number; // Percentage
+    partialConcordance: number;
+    noConcordance: number;
+    concordanceByBiomarker: Record<string, number>;
+  };
+
+  // Prediction accuracy
+  predictionAccuracy: {
+    responseAccuracy: number;
+    responseSensitivity: number; // Ability to predict responders
+    responseSpecificity: number; // Ability to predict non-responders
+    responseAUC?: number;
+
+    pfsCIndex: number; // Concordance index for PFS
+    pfsCalibration: number; // How well predicted PFS matches actual
+
+    osCIndex: number;
+    osCalibration: number;
+
+    toxicityAccuracy: number;
+    toxicityAUC?: number;
+  };
+
+  // Clinical impact
+  clinicalImpact: {
+    objectiveResponseRate: number;
+    diseaseControlRate: number;
+    medianPFS: number;
+    medianOS: number;
+
+    // Comparison metrics
+    concordantVsDiscordant: {
+      concordantORR: number;
+      discordantORR: number;
+      concordantMedianPFS: number;
+      discordantMedianPFS: number;
+      pValue?: number;
+    };
+  };
+
+  // Subgroup analyses
+  subgroupAnalyses: {
+    subgroup: string;
+    patientCount: number;
+    concordance: number;
+    responseAccuracy: number;
+    medianPFS: number;
+  }[];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VALIDATION SERVICE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class RetrospectiveValidationService extends EventEmitter {
+  private validationCohorts: Map<string, ValidationPatient[]> = new Map();
+  private systemRecommendations: Map<string, SystemRecommendation> = new Map();
+  private validationResults: Map<string, ValidationResult> = new Map();
+
+  constructor() {
+    super();
+  }
+
+  /**
+   * Load a validation cohort
+   */
+  loadCohort(cohortId: string, patients: ValidationPatient[]): void {
+    // De-identify and validate data
+    const validatedPatients = patients.map(p => this.validateAndDeidentify(p));
+    this.validationCohorts.set(cohortId, validatedPatients);
+    this.emit('cohort-loaded', { cohortId, patientCount: validatedPatients.length });
+  }
+
+  /**
+   * Load system recommendations for comparison
+   */
+  loadRecommendations(recommendations: SystemRecommendation[]): void {
+    for (const rec of recommendations) {
+      this.systemRecommendations.set(rec.patientId, rec);
+    }
+    this.emit('recommendations-loaded', { count: recommendations.length });
+  }
+
+  /**
+   * Run validation for a cohort
+   */
+  async runValidation(cohortId: string): Promise<CohortAnalysis> {
+    const patients = this.validationCohorts.get(cohortId);
+    if (!patients) {
+      throw new Error(`Cohort ${cohortId} not found`);
+    }
+
+    const results: ValidationResult[] = [];
+
+    // Validate each patient
+    for (const patient of patients) {
+      const recommendation = this.systemRecommendations.get(patient.id);
+      const result = this.validatePatient(patient, recommendation);
+      results.push(result);
+      this.validationResults.set(patient.id, result);
+    }
+
+    // Compute cohort-level metrics
+    const analysis = this.computeCohortAnalysis(cohortId, patients, results);
+
+    this.emit('validation-complete', { cohortId, analysis });
+
+    return analysis;
+  }
+
+  /**
+   * Validate a single patient
+   */
+  private validatePatient(
+    patient: ValidationPatient,
+    recommendation?: SystemRecommendation
+  ): ValidationResult {
+    // Concordance analysis
+    const concordance = this.assessConcordance(patient, recommendation);
+
+    // Calculate actual outcomes
+    const actualPFS = this.calculatePFS(patient);
+    const actualOS = this.calculateOS(patient);
+    const actualGrade3Plus = (patient.outcomes.toxicities || []).some(t => t.grade >= 3);
+
+    // Compare predictions to outcomes
+    const outcomeComparison = {
+      predictedResponse: recommendation?.predictions.responseRate || 0,
+      actualResponse: patient.outcomes.bestResponse,
+      responseCorrect: this.assessResponseAccuracy(
+        recommendation?.predictions.responseRate || 0,
+        patient.outcomes.bestResponse
+      ),
+      predictedPFS: recommendation?.predictions.pfsMonths || 0,
+      actualPFS,
+      pfsDifference: actualPFS !== undefined ? actualPFS - (recommendation?.predictions.pfsMonths || 0) : undefined,
+      predictedOS: recommendation?.predictions.osMonths || 0,
+      actualOS,
+      osDifference: actualOS !== undefined ? actualOS - (recommendation?.predictions.osMonths || 0) : undefined,
+      predictedToxicityRisk: recommendation?.predictions.toxicityRisk || 0,
+      actualGrade3PlusToxicity: actualGrade3Plus
+    };
+
+    // Clinical benefit assessment
+    const clinicalBenefit = {
+      objectiveResponse: ['CR', 'PR'].includes(patient.outcomes.bestResponse || ''),
+      diseaseControl: ['CR', 'PR', 'SD'].includes(patient.outcomes.bestResponse || ''),
+      durableBenefit: actualPFS !== undefined && actualPFS >= 6
+    };
+
+    return {
+      patientId: patient.id,
+      concordance,
+      outcomeComparison,
+      clinicalBenefit
+    };
+  }
+
+  /**
+   * Assess concordance between recommendation and actual treatment
+   */
+  private assessConcordance(
+    patient: ValidationPatient,
+    recommendation?: SystemRecommendation
+  ): ValidationResult['concordance'] {
+    if (!recommendation) {
+      return {
+        regimenMatch: false,
+        partialMatch: false,
+        matchedDrugs: []
+      };
+    }
+
+    const actualDrugs = patient.treatment.drugs.map(d => d.toLowerCase());
+    const recommendedDrugs = recommendation.recommendedDrugs.map(d => d.toLowerCase());
+
+    const matchedDrugs = recommendedDrugs.filter(rd =>
+      actualDrugs.some(ad => this.drugsMatch(ad, rd))
+    );
+
+    const regimenMatch = matchedDrugs.length === recommendedDrugs.length &&
+                         matchedDrugs.length === actualDrugs.length;
+    const partialMatch = matchedDrugs.length > 0;
+
+    return {
+      regimenMatch,
+      partialMatch,
+      matchedDrugs
+    };
+  }
+
+  /**
+   * Check if two drug names refer to the same drug
+   */
+  private drugsMatch(drug1: string, drug2: string): boolean {
+    // Normalize names
+    const normalize = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (normalize(drug1) === normalize(drug2)) return true;
+
+    // Check brand/generic equivalents
+    const equivalents: Record<string, string[]> = {
+      'pembrolizumab': ['keytruda'],
+      'nivolumab': ['opdivo'],
+      'osimertinib': ['tagrisso'],
+      'alectinib': ['alecensa'],
+      'trastuzumab': ['herceptin'],
+      'pertuzumab': ['perjeta'],
+      'olaparib': ['lynparza'],
+      'palbociclib': ['ibrance'],
+      'carboplatin': ['paraplatin'],
+      'paclitaxel': ['taxol'],
+      'docetaxel': ['taxotere']
+    };
+
+    for (const [generic, brands] of Object.entries(equivalents)) {
+      const allNames = [generic, ...brands].map(normalize);
+      if (allNames.includes(normalize(drug1)) && allNames.includes(normalize(drug2))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Calculate PFS in months
+   */
+  private calculatePFS(patient: ValidationPatient): number | undefined {
+    const startDate = patient.treatment.startDate;
+    let endDate: Date;
+
+    if (patient.outcomes.progressionDate) {
+      endDate = patient.outcomes.progressionDate;
+    } else if (patient.outcomes.deathDate) {
+      endDate = patient.outcomes.deathDate;
+    } else {
+      // Censored at last follow-up
+      endDate = patient.outcomes.lastFollowUpDate;
+    }
+
+    const months = (endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24 * 30.44);
+    return Math.round(months * 10) / 10;
+  }
+
+  /**
+   * Calculate OS in months
+   */
+  private calculateOS(patient: ValidationPatient): number | undefined {
+    const startDate = patient.diagnosis.diagnosisDate;
+    let endDate: Date;
+
+    if (patient.outcomes.deathDate) {
+      endDate = patient.outcomes.deathDate;
+    } else {
+      // Censored at last follow-up
+      endDate = patient.outcomes.lastFollowUpDate;
+    }
+
+    const months = (endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24 * 30.44);
+    return Math.round(months * 10) / 10;
+  }
+
+  /**
+   * Assess if response prediction was accurate
+   */
+  private assessResponseAccuracy(predictedRate: number, actualResponse?: string): boolean | undefined {
+    if (!actualResponse || actualResponse === 'NE') return undefined;
+
+    const predicted = predictedRate >= 0.5 ? 'responder' : 'non-responder';
+    const actual = ['CR', 'PR'].includes(actualResponse) ? 'responder' : 'non-responder';
+
+    return predicted === actual;
+  }
+
+  /**
+   * Compute cohort-level analysis
+   */
+  private computeCohortAnalysis(
+    cohortId: string,
+    patients: ValidationPatient[],
+    results: ValidationResult[]
+  ): CohortAnalysis {
+    // Demographics
+    const ages = patients.map(p => p.demographics.ageAtDiagnosis);
+    const maleCount = patients.filter(p => p.demographics.gender === 'male').length;
+
+    const stageDistribution: Record<string, number> = {};
+    for (const p of patients) {
+      stageDistribution[p.diagnosis.stage] = (stageDistribution[p.diagnosis.stage] || 0) + 1;
+    }
+
+    // Concordance metrics
+    const fullConcordance = results.filter(r => r.concordance.regimenMatch).length / results.length;
+    const partialConcordance = results.filter(r => r.concordance.partialMatch && !r.concordance.regimenMatch).length / results.length;
+
+    // Response accuracy
+    const responseResults = results.filter(r => r.outcomeComparison.responseCorrect !== undefined);
+    const responseAccuracy = responseResults.length > 0
+      ? responseResults.filter(r => r.outcomeComparison.responseCorrect).length / responseResults.length
+      : 0;
+
+    // Sensitivity (correctly predicted responders)
+    const actualResponders = results.filter(r =>
+      ['CR', 'PR'].includes(r.outcomeComparison.actualResponse || '')
+    );
+    const responseSensitivity = actualResponders.length > 0
+      ? actualResponders.filter(r => r.outcomeComparison.predictedResponse >= 0.5).length / actualResponders.length
+      : 0;
+
+    // Specificity (correctly predicted non-responders)
+    const actualNonResponders = results.filter(r =>
+      ['SD', 'PD'].includes(r.outcomeComparison.actualResponse || '')
+    );
+    const responseSpecificity = actualNonResponders.length > 0
+      ? actualNonResponders.filter(r => r.outcomeComparison.predictedResponse < 0.5).length / actualNonResponders.length
+      : 0;
+
+    // PFS concordance index (simplified)
+    const pfsCIndex = this.calculateCIndex(
+      results.map(r => r.outcomeComparison.predictedPFS),
+      results.map(r => r.outcomeComparison.actualPFS || 0)
+    );
+
+    // PFS calibration
+    const pfsCalibration = this.calculateCalibration(
+      results.map(r => r.outcomeComparison.predictedPFS),
+      results.map(r => r.outcomeComparison.actualPFS || 0)
+    );
+
+    // OS metrics (similar calculation)
+    const osCIndex = this.calculateCIndex(
+      results.map(r => r.outcomeComparison.predictedOS),
+      results.map(r => r.outcomeComparison.actualOS || 0)
+    );
+    const osCalibration = this.calculateCalibration(
+      results.map(r => r.outcomeComparison.predictedOS),
+      results.map(r => r.outcomeComparison.actualOS || 0)
+    );
+
+    // Toxicity accuracy
+    const toxicityResults = results.filter(r => r.outcomeComparison.predictedToxicityRisk > 0);
+    const toxicityAccuracy = toxicityResults.length > 0
+      ? toxicityResults.filter(r => {
+          const predicted = r.outcomeComparison.predictedToxicityRisk >= 0.3;
+          return predicted === r.outcomeComparison.actualGrade3PlusToxicity;
+        }).length / toxicityResults.length
+      : 0;
+
+    // Clinical outcomes
+    const objectiveResponseRate = results.filter(r => r.clinicalBenefit.objectiveResponse).length / results.length;
+    const diseaseControlRate = results.filter(r => r.clinicalBenefit.diseaseControl).length / results.length;
+
+    const pfsValues = results.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[];
+    const medianPFS = this.calculateMedian(pfsValues);
+
+    const osValues = results.map(r => r.outcomeComparison.actualOS).filter(v => v !== undefined) as number[];
+    const medianOS = this.calculateMedian(osValues);
+
+    // Concordant vs discordant outcomes
+    const concordantResults = results.filter(r => r.concordance.regimenMatch || r.concordance.partialMatch);
+    const discordantResults = results.filter(r => !r.concordance.regimenMatch && !r.concordance.partialMatch);
+
+    const concordantORR = concordantResults.length > 0
+      ? concordantResults.filter(r => r.clinicalBenefit.objectiveResponse).length / concordantResults.length
+      : 0;
+    const discordantORR = discordantResults.length > 0
+      ? discordantResults.filter(r => r.clinicalBenefit.objectiveResponse).length / discordantResults.length
+      : 0;
+
+    const concordantPFS = this.calculateMedian(
+      concordantResults.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[]
+    );
+    const discordantPFS = this.calculateMedian(
+      discordantResults.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[]
+    );
+
+    // Subgroup analyses
+    const subgroupAnalyses = this.performSubgroupAnalyses(patients, results);
+
+    return {
+      cohortId,
+      description: `Validation cohort with ${patients.length} patients`,
+      patientCount: patients.length,
+      dateRange: {
+        start: new Date(Math.min(...patients.map(p => p.diagnosis.diagnosisDate.getTime()))),
+        end: new Date(Math.max(...patients.map(p => p.outcomes.lastFollowUpDate.getTime())))
+      },
+      demographics: {
+        medianAge: this.calculateMedian(ages),
+        ageRange: [Math.min(...ages), Math.max(...ages)],
+        genderDistribution: {
+          male: maleCount / patients.length,
+          female: (patients.length - maleCount) / patients.length
+        },
+        stageDistribution
+      },
+      concordance: {
+        fullConcordance,
+        partialConcordance,
+        noConcordance: 1 - fullConcordance - partialConcordance,
+        concordanceByBiomarker: this.calculateConcordanceByBiomarker(patients, results)
+      },
+      predictionAccuracy: {
+        responseAccuracy,
+        responseSensitivity,
+        responseSpecificity,
+        pfsCIndex,
+        pfsCalibration,
+        osCIndex,
+        osCalibration,
+        toxicityAccuracy
+      },
+      clinicalImpact: {
+        objectiveResponseRate,
+        diseaseControlRate,
+        medianPFS,
+        medianOS,
+        concordantVsDiscordant: {
+          concordantORR,
+          discordantORR,
+          concordantMedianPFS: concordantPFS,
+          discordantMedianPFS: discordantPFS
+        }
+      },
+      subgroupAnalyses
+    };
+  }
+
+  /**
+   * Calculate concordance index (C-index)
+   */
+  private calculateCIndex(predicted: number[], actual: number[]): number {
+    let concordant = 0;
+    let discordant = 0;
+    let tied = 0;
+
+    for (let i = 0; i < predicted.length; i++) {
+      for (let j = i + 1; j < predicted.length; j++) {
+        if (actual[i] !== actual[j]) {
+          if ((predicted[i] > predicted[j] && actual[i] > actual[j]) ||
+              (predicted[i] < predicted[j] && actual[i] < actual[j])) {
+            concordant++;
+          } else if (predicted[i] !== predicted[j]) {
+            discordant++;
+          } else {
+            tied++;
+          }
+        }
+      }
+    }
+
+    const total = concordant + discordant + tied;
+    return total > 0 ? (concordant + 0.5 * tied) / total : 0.5;
+  }
+
+  /**
+   * Calculate calibration score (0-1, higher is better)
+   */
+  private calculateCalibration(predicted: number[], actual: number[]): number {
+    if (predicted.length === 0) return 0;
+
+    // Group predictions into deciles and compare to actual
+    const combined = predicted.map((p, i) => ({ predicted: p, actual: actual[i] }))
+      .filter(c => c.actual > 0)
+      .sort((a, b) => a.predicted - b.predicted);
+
+    if (combined.length < 10) {
+      // Simple correlation for small samples
+      const meanPred = combined.reduce((s, c) => s + c.predicted, 0) / combined.length;
+      const meanActual = combined.reduce((s, c) => s + c.actual, 0) / combined.length;
+
+      const errors = combined.map(c => Math.abs(c.predicted - c.actual) / Math.max(c.actual, 1));
+      const meanError = errors.reduce((s, e) => s + e, 0) / errors.length;
+
+      return Math.max(0, 1 - meanError);
+    }
+
+    // For larger samples, use decile calibration
+    const decileSize = Math.ceil(combined.length / 10);
+    let totalError = 0;
+
+    for (let i = 0; i < 10; i++) {
+      const start = i * decileSize;
+      const end = Math.min((i + 1) * decileSize, combined.length);
+      const decile = combined.slice(start, end);
+
+      const avgPredicted = decile.reduce((s, c) => s + c.predicted, 0) / decile.length;
+      const avgActual = decile.reduce((s, c) => s + c.actual, 0) / decile.length;
+
+      const relativeError = avgActual > 0 ? Math.abs(avgPredicted - avgActual) / avgActual : 0;
+      totalError += relativeError;
+    }
+
+    return Math.max(0, 1 - totalError / 10);
+  }
+
+  /**
+   * Calculate median of an array
+   */
+  private calculateMedian(values: number[]): number {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+
+  /**
+   * Calculate concordance by biomarker subgroup
+   */
+  private calculateConcordanceByBiomarker(
+    patients: ValidationPatient[],
+    results: ValidationResult[]
+  ): Record<string, number> {
+    const biomarkerGroups: Record<string, { concordant: number; total: number }> = {};
+
+    for (let i = 0; i < patients.length; i++) {
+      const patient = patients[i];
+      const result = results[i];
+
+      // Check various biomarker categories
+      const biomarkers: string[] = [];
+
+      if (patient.diagnosis.msiStatus === 'MSI-H') biomarkers.push('MSI-H');
+      if (patient.diagnosis.tmbValue && patient.diagnosis.tmbValue >= 10) biomarkers.push('TMB-H');
+      if (patient.diagnosis.pdl1Score && patient.diagnosis.pdl1Score >= 50) biomarkers.push('PD-L1≥50%');
+      if (patient.diagnosis.hrdStatus) biomarkers.push('HRD+');
+
+      // Check genomic alterations
+      for (const alt of patient.diagnosis.genomicAlterations || []) {
+        biomarkers.push(`${alt.gene} ${alt.alteration}`);
+      }
+
+      // Record concordance for each biomarker
+      for (const biomarker of biomarkers) {
+        if (!biomarkerGroups[biomarker]) {
+          biomarkerGroups[biomarker] = { concordant: 0, total: 0 };
+        }
+        biomarkerGroups[biomarker].total++;
+        if (result.concordance.regimenMatch || result.concordance.partialMatch) {
+          biomarkerGroups[biomarker].concordant++;
+        }
+      }
+    }
+
+    // Convert to concordance rates
+    const concordanceByBiomarker: Record<string, number> = {};
+    for (const [biomarker, data] of Object.entries(biomarkerGroups)) {
+      if (data.total >= 5) { // Only include groups with meaningful sample size
+        concordanceByBiomarker[biomarker] = data.concordant / data.total;
+      }
+    }
+
+    return concordanceByBiomarker;
+  }
+
+  /**
+   * Perform subgroup analyses
+   */
+  private performSubgroupAnalyses(
+    patients: ValidationPatient[],
+    results: ValidationResult[]
+  ): CohortAnalysis['subgroupAnalyses'] {
+    const subgroups: CohortAnalysis['subgroupAnalyses'] = [];
+
+    // By cancer type
+    const cancerTypes = [...new Set(patients.map(p => p.diagnosis.cancerType))];
+    for (const cancerType of cancerTypes) {
+      const indices = patients.map((p, i) => p.diagnosis.cancerType === cancerType ? i : -1).filter(i => i >= 0);
+      if (indices.length >= 10) {
+        const subgroupResults = indices.map(i => results[i]);
+        const subgroupPatients = indices.map(i => patients[i]);
+
+        subgroups.push({
+          subgroup: cancerType,
+          patientCount: indices.length,
+          concordance: subgroupResults.filter(r => r.concordance.regimenMatch || r.concordance.partialMatch).length / indices.length,
+          responseAccuracy: this.calculateSubgroupResponseAccuracy(subgroupResults),
+          medianPFS: this.calculateMedian(
+            subgroupResults.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[]
+          )
+        });
+      }
+    }
+
+    // By stage
+    const stages = ['I', 'II', 'III', 'IV'];
+    for (const stageGroup of stages) {
+      const indices = patients.map((p, i) => p.diagnosis.stage.startsWith(stageGroup) ? i : -1).filter(i => i >= 0);
+      if (indices.length >= 10) {
+        const subgroupResults = indices.map(i => results[i]);
+
+        subgroups.push({
+          subgroup: `Stage ${stageGroup}`,
+          patientCount: indices.length,
+          concordance: subgroupResults.filter(r => r.concordance.regimenMatch || r.concordance.partialMatch).length / indices.length,
+          responseAccuracy: this.calculateSubgroupResponseAccuracy(subgroupResults),
+          medianPFS: this.calculateMedian(
+            subgroupResults.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[]
+          )
+        });
+      }
+    }
+
+    // By age group
+    const ageGroups = [
+      { name: 'Age <50', filter: (p: ValidationPatient) => p.demographics.ageAtDiagnosis < 50 },
+      { name: 'Age 50-65', filter: (p: ValidationPatient) => p.demographics.ageAtDiagnosis >= 50 && p.demographics.ageAtDiagnosis < 65 },
+      { name: 'Age 65-75', filter: (p: ValidationPatient) => p.demographics.ageAtDiagnosis >= 65 && p.demographics.ageAtDiagnosis < 75 },
+      { name: 'Age ≥75', filter: (p: ValidationPatient) => p.demographics.ageAtDiagnosis >= 75 }
+    ];
+
+    for (const ageGroup of ageGroups) {
+      const indices = patients.map((p, i) => ageGroup.filter(p) ? i : -1).filter(i => i >= 0);
+      if (indices.length >= 10) {
+        const subgroupResults = indices.map(i => results[i]);
+
+        subgroups.push({
+          subgroup: ageGroup.name,
+          patientCount: indices.length,
+          concordance: subgroupResults.filter(r => r.concordance.regimenMatch || r.concordance.partialMatch).length / indices.length,
+          responseAccuracy: this.calculateSubgroupResponseAccuracy(subgroupResults),
+          medianPFS: this.calculateMedian(
+            subgroupResults.map(r => r.outcomeComparison.actualPFS).filter(v => v !== undefined) as number[]
+          )
+        });
+      }
+    }
+
+    return subgroups;
+  }
+
+  /**
+   * Calculate response accuracy for a subgroup
+   */
+  private calculateSubgroupResponseAccuracy(results: ValidationResult[]): number {
+    const withResponse = results.filter(r => r.outcomeComparison.responseCorrect !== undefined);
+    return withResponse.length > 0
+      ? withResponse.filter(r => r.outcomeComparison.responseCorrect).length / withResponse.length
+      : 0;
+  }
+
+  /**
+   * Validate and de-identify patient data
+   */
+  private validateAndDeidentify(patient: ValidationPatient): ValidationPatient {
+    // Generate hashed de-identified ID
+    const deidentifiedId = createHash('sha256')
+      .update(patient.id + 'SALT_CHANGE_IN_PRODUCTION')
+      .digest('hex')
+      .substring(0, 12);
+
+    return {
+      ...patient,
+      id: deidentifiedId
+    };
+  }
+
+  /**
+   * Generate validation report
+   */
+  generateReport(analysis: CohortAnalysis): string {
+    const lines: string[] = [
+      '═'.repeat(70),
+      '  RETROSPECTIVE VALIDATION REPORT',
+      '═'.repeat(70),
+      '',
+      `Cohort: ${analysis.cohortId}`,
+      `Patients: ${analysis.patientCount}`,
+      `Date Range: ${analysis.dateRange.start.toISOString().split('T')[0]} to ${analysis.dateRange.end.toISOString().split('T')[0]}`,
+      '',
+      '─'.repeat(70),
+      '  CONCORDANCE METRICS',
+      '─'.repeat(70),
+      `Full Concordance: ${(analysis.concordance.fullConcordance * 100).toFixed(1)}%`,
+      `Partial Concordance: ${(analysis.concordance.partialConcordance * 100).toFixed(1)}%`,
+      `No Concordance: ${(analysis.concordance.noConcordance * 100).toFixed(1)}%`,
+      '',
+      '─'.repeat(70),
+      '  PREDICTION ACCURACY',
+      '─'.repeat(70),
+      `Response Accuracy: ${(analysis.predictionAccuracy.responseAccuracy * 100).toFixed(1)}%`,
+      `Response Sensitivity: ${(analysis.predictionAccuracy.responseSensitivity * 100).toFixed(1)}%`,
+      `Response Specificity: ${(analysis.predictionAccuracy.responseSpecificity * 100).toFixed(1)}%`,
+      `PFS C-Index: ${analysis.predictionAccuracy.pfsCIndex.toFixed(3)}`,
+      `PFS Calibration: ${(analysis.predictionAccuracy.pfsCalibration * 100).toFixed(1)}%`,
+      `OS C-Index: ${analysis.predictionAccuracy.osCIndex.toFixed(3)}`,
+      `Toxicity Accuracy: ${(analysis.predictionAccuracy.toxicityAccuracy * 100).toFixed(1)}%`,
+      '',
+      '─'.repeat(70),
+      '  CLINICAL OUTCOMES',
+      '─'.repeat(70),
+      `Objective Response Rate: ${(analysis.clinicalImpact.objectiveResponseRate * 100).toFixed(1)}%`,
+      `Disease Control Rate: ${(analysis.clinicalImpact.diseaseControlRate * 100).toFixed(1)}%`,
+      `Median PFS: ${analysis.clinicalImpact.medianPFS.toFixed(1)} months`,
+      `Median OS: ${analysis.clinicalImpact.medianOS.toFixed(1)} months`,
+      '',
+      '  Concordant vs Discordant Treatment:',
+      `    Concordant ORR: ${(analysis.clinicalImpact.concordantVsDiscordant.concordantORR * 100).toFixed(1)}%`,
+      `    Discordant ORR: ${(analysis.clinicalImpact.concordantVsDiscordant.discordantORR * 100).toFixed(1)}%`,
+      `    Concordant Median PFS: ${analysis.clinicalImpact.concordantVsDiscordant.concordantMedianPFS.toFixed(1)} months`,
+      `    Discordant Median PFS: ${analysis.clinicalImpact.concordantVsDiscordant.discordantMedianPFS.toFixed(1)} months`,
+      '',
+      '─'.repeat(70),
+      '  SUBGROUP ANALYSES',
+      '─'.repeat(70),
+      ...analysis.subgroupAnalyses.map(sg =>
+        `${sg.subgroup}: n=${sg.patientCount}, Concordance=${(sg.concordance * 100).toFixed(0)}%, ` +
+        `Accuracy=${(sg.responseAccuracy * 100).toFixed(0)}%, mPFS=${sg.medianPFS.toFixed(1)}mo`
+      ),
+      '',
+      '═'.repeat(70)
+    ];
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Export validation results
+   */
+  exportResults(cohortId: string, format: 'json' | 'csv'): string {
+    const patients = this.validationCohorts.get(cohortId);
+    if (!patients) return '';
+
+    const results: any[] = [];
+    for (const patient of patients) {
+      const result = this.validationResults.get(patient.id);
+      if (result) {
+        results.push({
+          patientId: patient.id,
+          cancerType: patient.diagnosis.cancerType,
+          stage: patient.diagnosis.stage,
+          actualRegimen: patient.treatment.regimen,
+          regimenMatch: result.concordance.regimenMatch,
+          partialMatch: result.concordance.partialMatch,
+          predictedResponse: result.outcomeComparison.predictedResponse,
+          actualResponse: result.outcomeComparison.actualResponse,
+          responseCorrect: result.outcomeComparison.responseCorrect,
+          predictedPFS: result.outcomeComparison.predictedPFS,
+          actualPFS: result.outcomeComparison.actualPFS,
+          predictedOS: result.outcomeComparison.predictedOS,
+          actualOS: result.outcomeComparison.actualOS,
+          objectiveResponse: result.clinicalBenefit.objectiveResponse,
+          diseaseControl: result.clinicalBenefit.diseaseControl
+        });
+      }
+    }
+
+    if (format === 'json') {
+      return JSON.stringify(results, null, 2);
+    }
+
+    // CSV format
+    const headers = Object.keys(results[0] || {});
+    const rows = [
+      headers.join(','),
+      ...results.map(r => headers.map(h => JSON.stringify(r[h] ?? '')).join(','))
+    ];
+
+    return rows.join('\n');
+  }
+}
+
+export default RetrospectiveValidationService;