@erosolaraijs/cure 1.0.0

package/src/ml/outcomePredictor.ts

@@ -0,0 +1,1301 @@
+/**
+ * Machine Learning Outcome Prediction Infrastructure
+ *
+ * Provides ML-based prediction models for:
+ * - Treatment response prediction
+ * - Survival probability estimation
+ * - Toxicity risk assessment
+ * - Resistance prediction
+ * - Optimal therapy selection
+ *
+ * This module provides the infrastructure for training and deploying
+ * ML models. In production, models would be trained on real patient cohorts
+ * with proper validation and FDA clearance.
+ */
+
+import { EventEmitter } from 'events';
+import { createHash } from 'crypto';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FEATURE TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface PatientFeatures {
+  // Demographics
+  age: number;
+  gender: 'male' | 'female';
+  ethnicity?: string;
+  bmi?: number;
+
+  // Disease characteristics
+  cancerType: string;
+  histology?: string;
+  stage: 'I' | 'II' | 'III' | 'IV' | 'IA' | 'IB' | 'IIA' | 'IIB' | 'IIIA' | 'IIIB' | 'IIIC' | 'IVA' | 'IVB';
+  grade?: 1 | 2 | 3;
+  tumorSize?: number; // cm
+  lymphNodeInvolvement?: number;
+  metastaticSites?: string[];
+
+  // Performance status
+  ecogStatus: 0 | 1 | 2 | 3 | 4;
+
+  // Biomarkers
+  genomicAlterations: {
+    gene: string;
+    alteration: string;
+    type: 'mutation' | 'amplification' | 'deletion' | 'fusion';
+    vaf?: number;
+  }[];
+
+  // Immunotherapy markers
+  pdl1Score?: number;
+  pdl1ScoreType?: 'TPS' | 'CPS' | 'IC';
+  msiStatus?: 'MSI-H' | 'MSI-L' | 'MSS';
+  tmbValue?: number;
+  tmbStatus?: 'high' | 'low';
+
+  // HRD status
+  hrdScore?: number;
+  hrdStatus?: 'positive' | 'negative';
+  brcaStatus?: 'BRCA1' | 'BRCA2' | 'wild-type';
+
+  // Lab values
+  ldh?: number;
+  albumin?: number;
+  hemoglobin?: number;
+  neutrophils?: number;
+  lymphocytes?: number;
+  platelets?: number;
+  creatinine?: number;
+  bilirubin?: number;
+  alkalinePhosphatase?: number;
+
+  // Prior treatments
+  priorLines?: number;
+  priorTherapies?: string[];
+  priorResponse?: 'CR' | 'PR' | 'SD' | 'PD';
+  treatmentFreeInterval?: number; // months
+
+  // Comorbidities
+  comorbidityIndex?: number;
+  organFunction?: {
+    cardiac?: 'normal' | 'impaired';
+    hepatic?: 'normal' | 'impaired';
+    renal?: 'normal' | 'impaired';
+    pulmonary?: 'normal' | 'impaired';
+  };
+}
+
+export interface TreatmentFeatures {
+  regimen: string;
+  drugs: string[];
+  treatmentType: 'chemotherapy' | 'immunotherapy' | 'targeted' | 'combination' | 'radiation' | 'surgery' | 'car-t';
+  setting: 'neoadjuvant' | 'adjuvant' | 'first-line' | 'second-line' | 'third-line-plus' | 'maintenance';
+  dosing?: 'standard' | 'reduced' | 'dose-dense';
+  schedule?: string;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PREDICTION TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface ResponsePrediction {
+  predictedResponse: 'CR' | 'PR' | 'SD' | 'PD';
+  probabilities: {
+    completeResponse: number;
+    partialResponse: number;
+    stableDisease: number;
+    progressiveDisease: number;
+  };
+  confidence: number;
+  objectiveResponseRate: number; // CR + PR probability
+  diseaseControlRate: number; // CR + PR + SD probability
+  timeToResponse?: {
+    median: number; // weeks
+    range: [number, number];
+  };
+}
+
+export interface SurvivalPrediction {
+  // Progression-Free Survival
+  pfs: {
+    median: number; // months
+    sixMonth: number; // probability
+    twelveMonth: number;
+    twentyFourMonth: number;
+    confidence: number;
+    hazardRatio?: number;
+  };
+
+  // Overall Survival
+  os: {
+    median: number;
+    twelveMonth: number;
+    twentyFourMonth: number;
+    fiveYear: number;
+    confidence: number;
+    hazardRatio?: number;
+  };
+
+  // Risk stratification
+  riskGroup: 'low' | 'intermediate-low' | 'intermediate-high' | 'high';
+  riskScore: number; // 0-100
+}
+
+export interface ToxicityPrediction {
+  overallRisk: 'low' | 'moderate' | 'high';
+  grade3PlusRisk: number; // Probability of Grade 3+ toxicity
+
+  specificRisks: {
+    toxicity: string;
+    grade: 1 | 2 | 3 | 4 | 5;
+    probability: number;
+    timeToOnset?: { median: number; unit: 'days' | 'weeks' | 'cycles' };
+    reversible: boolean;
+    management?: string;
+  }[];
+
+  // Immune-related adverse events (for immunotherapy)
+  iraeRisk?: {
+    any: number;
+    grade3Plus: number;
+    specificOrgans: { organ: string; risk: number }[];
+  };
+
+  // Dose modification recommendation
+  doseModification?: {
+    recommended: boolean;
+    reduction: number; // percentage
+    reason: string;
+  };
+}
+
+export interface ResistancePrediction {
+  intrinsicResistanceRisk: number; // Probability of primary resistance
+  acquiredResistanceRisk: number; // Probability of developing resistance
+
+  predictedMechanisms: {
+    mechanism: string;
+    probability: number;
+    monitoringBiomarker?: string;
+  }[];
+
+  timeToResistance?: {
+    median: number; // months
+    range: [number, number];
+  };
+
+  nextLineOptions: {
+    therapy: string;
+    rationale: string;
+    expectedBenefit: number; // expected months of benefit
+  }[];
+}
+
+export interface TherapyRanking {
+  therapies: {
+    regimen: string;
+    drugs: string[];
+    rank: number;
+
+    predictions: {
+      responseRate: number;
+      pfsSurvival: number;
+      osSurvival: number;
+      toxicityRisk: number;
+      qualityOfLifeScore: number;
+    };
+
+    overallScore: number;
+    confidence: number;
+
+    matchingBiomarkers: string[];
+    fdaApproved: boolean;
+    nccnRecommended: boolean;
+
+    considerations: string[];
+    contraindications?: string[];
+  }[];
+
+  bestChoice: {
+    regimen: string;
+    rationale: string[];
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MODEL TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface MLModel {
+  id: string;
+  name: string;
+  version: string;
+  type: 'classification' | 'regression' | 'survival' | 'ranking';
+  target: 'response' | 'pfs' | 'os' | 'toxicity' | 'resistance';
+  cancerTypes: string[];
+
+  performance: {
+    auc?: number;
+    accuracy?: number;
+    sensitivity?: number;
+    specificity?: number;
+    cIndex?: number; // For survival models
+    calibration?: number;
+    brier?: number;
+  };
+
+  validation: {
+    method: 'cross-validation' | 'temporal' | 'external' | 'prospective';
+    cohortSize: number;
+    testSetSize: number;
+    validationDate: Date;
+  };
+
+  features: string[];
+  importantFeatures: { feature: string; importance: number }[];
+
+  status: 'development' | 'validation' | 'clinical-use' | 'deprecated';
+  regulatoryStatus?: 'not-submitted' | 'pending' | 'cleared' | '510k' | 'de-novo';
+}
+
+export interface ModelRegistry {
+  models: MLModel[];
+  getModel(id: string): MLModel | undefined;
+  getBestModel(target: MLModel['target'], cancerType: string): MLModel | undefined;
+  registerModel(model: MLModel): void;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTCOME PREDICTOR SERVICE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class OutcomePredictorService extends EventEmitter {
+  private modelRegistry: Map<string, MLModel> = new Map();
+  private featureEncoders: Map<string, FeatureEncoder> = new Map();
+  private predictionCache: Map<string, { prediction: any; timestamp: Date }> = new Map();
+  private cacheDuration = 3600000; // 1 hour
+
+  constructor() {
+    super();
+    this.initializeDefaultModels();
+    this.initializeFeatureEncoders();
+  }
+
+  /**
+   * Predict treatment response
+   */
+  async predictResponse(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures
+  ): Promise<ResponsePrediction> {
+    const cacheKey = this.getCacheKey('response', patient, treatment);
+    const cached = this.getFromCache<ResponsePrediction>(cacheKey);
+    if (cached) return cached;
+
+    // Get appropriate model
+    const model = this.getBestModel('response', patient.cancerType);
+
+    // Encode features
+    const features = this.encodeFeatures(patient, treatment);
+
+    // Make prediction (in production, this would call a trained model)
+    const prediction = this.computeResponsePrediction(features, patient, treatment, model);
+
+    this.setCache(cacheKey, prediction);
+    this.emit('prediction-made', { type: 'response', patient, treatment, prediction });
+
+    return prediction;
+  }
+
+  /**
+   * Predict survival outcomes
+   */
+  async predictSurvival(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures
+  ): Promise<SurvivalPrediction> {
+    const cacheKey = this.getCacheKey('survival', patient, treatment);
+    const cached = this.getFromCache<SurvivalPrediction>(cacheKey);
+    if (cached) return cached;
+
+    const model = this.getBestModel('pfs', patient.cancerType);
+    const features = this.encodeFeatures(patient, treatment);
+    const prediction = this.computeSurvivalPrediction(features, patient, treatment, model);
+
+    this.setCache(cacheKey, prediction);
+    this.emit('prediction-made', { type: 'survival', patient, treatment, prediction });
+
+    return prediction;
+  }
+
+  /**
+   * Predict toxicity risk
+   */
+  async predictToxicity(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures
+  ): Promise<ToxicityPrediction> {
+    const cacheKey = this.getCacheKey('toxicity', patient, treatment);
+    const cached = this.getFromCache<ToxicityPrediction>(cacheKey);
+    if (cached) return cached;
+
+    const model = this.getBestModel('toxicity', patient.cancerType);
+    const features = this.encodeFeatures(patient, treatment);
+    const prediction = this.computeToxicityPrediction(features, patient, treatment, model);
+
+    this.setCache(cacheKey, prediction);
+    this.emit('prediction-made', { type: 'toxicity', patient, treatment, prediction });
+
+    return prediction;
+  }
+
+  /**
+   * Predict resistance development
+   */
+  async predictResistance(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures
+  ): Promise<ResistancePrediction> {
+    const cacheKey = this.getCacheKey('resistance', patient, treatment);
+    const cached = this.getFromCache<ResistancePrediction>(cacheKey);
+    if (cached) return cached;
+
+    const model = this.getBestModel('resistance', patient.cancerType);
+    const features = this.encodeFeatures(patient, treatment);
+    const prediction = this.computeResistancePrediction(features, patient, treatment, model);
+
+    this.setCache(cacheKey, prediction);
+    this.emit('prediction-made', { type: 'resistance', patient, treatment, prediction });
+
+    return prediction;
+  }
+
+  /**
+   * Rank treatment options
+   */
+  async rankTherapies(
+    patient: PatientFeatures,
+    treatmentOptions: TreatmentFeatures[],
+    preferences?: {
+      prioritizeEfficacy?: boolean;
+      prioritizeToxicity?: boolean;
+      prioritizeQoL?: boolean;
+    }
+  ): Promise<TherapyRanking> {
+    const rankings: TherapyRanking['therapies'] = [];
+
+    // Get predictions for each treatment option
+    for (const treatment of treatmentOptions) {
+      const [response, survival, toxicity] = await Promise.all([
+        this.predictResponse(patient, treatment),
+        this.predictSurvival(patient, treatment),
+        this.predictToxicity(patient, treatment)
+      ]);
+
+      // Calculate overall score based on preferences
+      const weights = {
+        efficacy: preferences?.prioritizeEfficacy ? 0.5 : 0.35,
+        toxicity: preferences?.prioritizeToxicity ? 0.3 : 0.25,
+        qol: preferences?.prioritizeQoL ? 0.3 : 0.2,
+        survival: 0.2
+      };
+
+      const efficacyScore = response.objectiveResponseRate;
+      const toxicityScore = 1 - toxicity.grade3PlusRisk;
+      const survivalScore = survival.pfs.twelveMonth;
+      const qolScore = this.estimateQoLScore(toxicity);
+
+      const overallScore =
+        efficacyScore * weights.efficacy +
+        toxicityScore * weights.toxicity +
+        survivalScore * weights.survival +
+        qolScore * weights.qol;
+
+      rankings.push({
+        regimen: treatment.regimen,
+        drugs: treatment.drugs,
+        rank: 0, // Will be set after sorting
+        predictions: {
+          responseRate: response.objectiveResponseRate,
+          pfsSurvival: survival.pfs.median,
+          osSurvival: survival.os.median,
+          toxicityRisk: toxicity.grade3PlusRisk,
+          qualityOfLifeScore: qolScore
+        },
+        overallScore,
+        confidence: (response.confidence + survival.pfs.confidence) / 2,
+        matchingBiomarkers: this.getMatchingBiomarkers(patient, treatment),
+        fdaApproved: this.checkFDAApproval(treatment, patient.cancerType),
+        nccnRecommended: this.checkNCCNRecommendation(treatment, patient.cancerType, patient.stage),
+        considerations: this.getConsiderations(patient, treatment)
+      });
+    }
+
+    // Sort by overall score
+    rankings.sort((a, b) => b.overallScore - a.overallScore);
+
+    // Assign ranks
+    rankings.forEach((r, i) => r.rank = i + 1);
+
+    const bestChoice = rankings[0];
+
+    return {
+      therapies: rankings,
+      bestChoice: {
+        regimen: bestChoice.regimen,
+        rationale: [
+          `Highest overall score (${(bestChoice.overallScore * 100).toFixed(1)}%)`,
+          `Expected response rate: ${(bestChoice.predictions.responseRate * 100).toFixed(1)}%`,
+          `Expected median PFS: ${bestChoice.predictions.pfsSurvival.toFixed(1)} months`,
+          bestChoice.fdaApproved ? 'FDA approved for this indication' : '',
+          bestChoice.nccnRecommended ? 'NCCN recommended' : '',
+          ...bestChoice.matchingBiomarkers.map(b => `Matches biomarker: ${b}`)
+        ].filter(Boolean)
+      }
+    };
+  }
+
+  /**
+   * Get comprehensive prediction report
+   */
+  async getComprehensivePrediction(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures
+  ): Promise<{
+    response: ResponsePrediction;
+    survival: SurvivalPrediction;
+    toxicity: ToxicityPrediction;
+    resistance: ResistancePrediction;
+    overallAssessment: {
+      recommendation: 'strongly-recommended' | 'recommended' | 'consider' | 'caution' | 'not-recommended';
+      rationale: string[];
+      caveats: string[];
+      alternativeOptions: string[];
+    };
+  }> {
+    const [response, survival, toxicity, resistance] = await Promise.all([
+      this.predictResponse(patient, treatment),
+      this.predictSurvival(patient, treatment),
+      this.predictToxicity(patient, treatment),
+      this.predictResistance(patient, treatment)
+    ]);
+
+    // Generate overall assessment
+    const overallAssessment = this.generateOverallAssessment(
+      patient, treatment, response, survival, toxicity, resistance
+    );
+
+    return {
+      response,
+      survival,
+      toxicity,
+      resistance,
+      overallAssessment
+    };
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // PREDICTION COMPUTATION (Placeholder implementations)
+  // In production, these would use trained ML models
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  private computeResponsePrediction(
+    features: number[],
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    model?: MLModel
+  ): ResponsePrediction {
+    // Base probabilities based on treatment type and cancer
+    let baseCR = 0.15;
+    let basePR = 0.30;
+    let baseSD = 0.30;
+
+    // Adjust based on biomarkers
+    if (this.hasBiomarkerMatch(patient, treatment)) {
+      baseCR += 0.15;
+      basePR += 0.15;
+    }
+
+    // Adjust based on stage
+    const stageModifiers: Record<string, number> = {
+      'I': 1.3, 'IA': 1.3, 'IB': 1.25,
+      'II': 1.15, 'IIA': 1.15, 'IIB': 1.1,
+      'III': 0.9, 'IIIA': 0.95, 'IIIB': 0.85, 'IIIC': 0.8,
+      'IV': 0.7, 'IVA': 0.75, 'IVB': 0.65
+    };
+    const stageMod = stageModifiers[patient.stage] || 1.0;
+
+    // Adjust based on ECOG
+    const ecogModifiers = [1.0, 0.9, 0.75, 0.5, 0.25];
+    const ecogMod = ecogModifiers[patient.ecogStatus];
+
+    // Adjust based on treatment setting
+    const settingModifiers: Record<string, number> = {
+      'first-line': 1.0,
+      'second-line': 0.75,
+      'third-line-plus': 0.5,
+      'neoadjuvant': 1.1,
+      'adjuvant': 1.05,
+      'maintenance': 0.9
+    };
+    const settingMod = settingModifiers[treatment.setting] || 1.0;
+
+    // Apply modifiers
+    const modifier = stageMod * ecogMod * settingMod;
+    const crProb = Math.min(baseCR * modifier, 0.6);
+    const prProb = Math.min(basePR * modifier, 0.5);
+    const sdProb = Math.min(baseSD * modifier, 0.4);
+    const pdProb = Math.max(1 - crProb - prProb - sdProb, 0.05);
+
+    // Normalize
+    const total = crProb + prProb + sdProb + pdProb;
+    const probabilities = {
+      completeResponse: crProb / total,
+      partialResponse: prProb / total,
+      stableDisease: sdProb / total,
+      progressiveDisease: pdProb / total
+    };
+
+    // Determine best response
+    const maxProb = Math.max(...Object.values(probabilities));
+    let predictedResponse: ResponsePrediction['predictedResponse'] = 'SD';
+    if (probabilities.completeResponse === maxProb) predictedResponse = 'CR';
+    else if (probabilities.partialResponse === maxProb) predictedResponse = 'PR';
+    else if (probabilities.progressiveDisease === maxProb) predictedResponse = 'PD';
+
+    return {
+      predictedResponse,
+      probabilities,
+      confidence: model ? model.performance.auc || 0.75 : 0.70,
+      objectiveResponseRate: probabilities.completeResponse + probabilities.partialResponse,
+      diseaseControlRate: probabilities.completeResponse + probabilities.partialResponse + probabilities.stableDisease,
+      timeToResponse: {
+        median: 8,
+        range: [4, 16]
+      }
+    };
+  }
+
+  private computeSurvivalPrediction(
+    features: number[],
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    model?: MLModel
+  ): SurvivalPrediction {
+    // Base survival estimates (in months)
+    let basePFS = 12;
+    let baseOS = 24;
+
+    // Cancer type adjustments
+    const cancerPFSModifiers: Record<string, number> = {
+      'NSCLC': 1.0, 'SCLC': 0.5, 'Breast': 1.5, 'Colorectal': 1.0,
+      'Melanoma': 1.2, 'RCC': 1.3, 'Ovarian': 0.8, 'Pancreatic': 0.4,
+      'Glioblastoma': 0.3, 'AML': 0.6, 'Multiple Myeloma': 1.5
+    };
+
+    const cancerMod = cancerPFSModifiers[patient.cancerType] || 1.0;
+    basePFS *= cancerMod;
+    baseOS *= cancerMod;
+
+    // Stage adjustments
+    const stageModifiers: Record<string, number> = {
+      'I': 3.0, 'IA': 3.5, 'IB': 2.8,
+      'II': 2.0, 'IIA': 2.2, 'IIB': 1.8,
+      'III': 1.0, 'IIIA': 1.2, 'IIIB': 0.9, 'IIIC': 0.7,
+      'IV': 0.5, 'IVA': 0.55, 'IVB': 0.4
+    };
+    const stageMod = stageModifiers[patient.stage] || 1.0;
+    basePFS *= stageMod;
+    baseOS *= stageMod;
+
+    // Biomarker-driven therapy boost
+    if (this.hasBiomarkerMatch(patient, treatment)) {
+      basePFS *= 1.5;
+      baseOS *= 1.3;
+    }
+
+    // ECOG adjustment
+    const ecogMultipliers = [1.0, 0.85, 0.65, 0.4, 0.2];
+    basePFS *= ecogMultipliers[patient.ecogStatus];
+    baseOS *= ecogMultipliers[patient.ecogStatus];
+
+    // Calculate probabilities using exponential survival model
+    const lambda_pfs = 1 / basePFS;
+    const lambda_os = 1 / baseOS;
+
+    const pfs = {
+      median: basePFS,
+      sixMonth: Math.exp(-lambda_pfs * 6),
+      twelveMonth: Math.exp(-lambda_pfs * 12),
+      twentyFourMonth: Math.exp(-lambda_pfs * 24),
+      confidence: model ? model.performance.cIndex || 0.72 : 0.68
+    };
+
+    const os = {
+      median: baseOS,
+      twelveMonth: Math.exp(-lambda_os * 12),
+      twentyFourMonth: Math.exp(-lambda_os * 24),
+      fiveYear: Math.exp(-lambda_os * 60),
+      confidence: model ? model.performance.cIndex || 0.72 : 0.68
+    };
+
+    // Calculate risk score (0-100)
+    const riskFactors = [
+      patient.stage.startsWith('IV') ? 25 : patient.stage.startsWith('III') ? 15 : 5,
+      patient.ecogStatus >= 2 ? 20 : patient.ecogStatus === 1 ? 10 : 0,
+      (patient.priorLines || 0) >= 2 ? 15 : (patient.priorLines || 0) >= 1 ? 8 : 0,
+      patient.ldh && patient.ldh > 250 ? 10 : 0,
+      patient.metastaticSites && patient.metastaticSites.length > 2 ? 15 : 0,
+      patient.age > 75 ? 10 : patient.age > 65 ? 5 : 0
+    ];
+    const riskScore = Math.min(riskFactors.reduce((a, b) => a + b, 0), 100);
+
+    let riskGroup: SurvivalPrediction['riskGroup'];
+    if (riskScore < 25) riskGroup = 'low';
+    else if (riskScore < 50) riskGroup = 'intermediate-low';
+    else if (riskScore < 75) riskGroup = 'intermediate-high';
+    else riskGroup = 'high';
+
+    return { pfs, os, riskGroup, riskScore };
+  }
+
+  private computeToxicityPrediction(
+    features: number[],
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    model?: MLModel
+  ): ToxicityPrediction {
+    const specificRisks: ToxicityPrediction['specificRisks'] = [];
+    let grade3PlusRisk = 0;
+
+    // Define toxicity profiles by drug class
+    const drugToxicities = this.getDrugToxicityProfiles(treatment.drugs);
+
+    for (const tox of drugToxicities) {
+      // Adjust risk based on patient factors
+      let adjustedRisk = tox.baseRisk;
+
+      // Age adjustment
+      if (patient.age > 70) adjustedRisk *= 1.2;
+      if (patient.age > 80) adjustedRisk *= 1.4;
+
+      // Organ function adjustment
+      if (tox.affectedOrgan === 'hepatic' && patient.organFunction?.hepatic === 'impaired') {
+        adjustedRisk *= 1.5;
+      }
+      if (tox.affectedOrgan === 'renal' && patient.organFunction?.renal === 'impaired') {
+        adjustedRisk *= 1.5;
+      }
+      if (tox.affectedOrgan === 'cardiac' && patient.organFunction?.cardiac === 'impaired') {
+        adjustedRisk *= 1.5;
+      }
+
+      // ECOG adjustment
+      adjustedRisk *= (1 + patient.ecogStatus * 0.1);
+
+      adjustedRisk = Math.min(adjustedRisk, 0.95);
+
+      specificRisks.push({
+        toxicity: tox.name,
+        grade: tox.typicalGrade,
+        probability: adjustedRisk,
+        timeToOnset: tox.timeToOnset,
+        reversible: tox.reversible,
+        management: tox.management
+      });
+
+      if (tox.typicalGrade >= 3) {
+        grade3PlusRisk += adjustedRisk * 0.3; // Weighted contribution
+      }
+    }
+
+    grade3PlusRisk = Math.min(grade3PlusRisk, 0.9);
+
+    // Immunotherapy-specific irAE prediction
+    let iraeRisk: ToxicityPrediction['iraeRisk'];
+    if (treatment.treatmentType === 'immunotherapy' || this.hasImmunotherapyDrug(treatment.drugs)) {
+      iraeRisk = {
+        any: 0.60,
+        grade3Plus: 0.15,
+        specificOrgans: [
+          { organ: 'skin', risk: 0.35 },
+          { organ: 'GI', risk: 0.20 },
+          { organ: 'endocrine', risk: 0.15 },
+          { organ: 'hepatic', risk: 0.10 },
+          { organ: 'pulmonary', risk: 0.08 }
+        ]
+      };
+    }
+
+    // Dose modification recommendation
+    let doseModification: ToxicityPrediction['doseModification'];
+    if (patient.age > 75 || patient.ecogStatus >= 2 || patient.organFunction?.renal === 'impaired') {
+      doseModification = {
+        recommended: true,
+        reduction: 20,
+        reason: patient.age > 75 ? 'Advanced age' :
+                patient.ecogStatus >= 2 ? 'Poor performance status' :
+                'Impaired organ function'
+      };
+    }
+
+    return {
+      overallRisk: grade3PlusRisk > 0.4 ? 'high' : grade3PlusRisk > 0.2 ? 'moderate' : 'low',
+      grade3PlusRisk,
+      specificRisks,
+      iraeRisk,
+      doseModification
+    };
+  }
+
+  private computeResistancePrediction(
+    features: number[],
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    model?: MLModel
+  ): ResistancePrediction {
+    let intrinsicRisk = 0.2;
+    let acquiredRisk = 0.6;
+
+    // Adjust based on prior treatments
+    if (patient.priorLines && patient.priorLines > 0) {
+      intrinsicRisk += 0.1 * patient.priorLines;
+      acquiredRisk += 0.05 * patient.priorLines;
+    }
+
+    // Adjust based on prior response
+    if (patient.priorResponse === 'PD') {
+      intrinsicRisk += 0.2;
+    } else if (patient.priorResponse === 'CR') {
+      intrinsicRisk -= 0.1;
+    }
+
+    // Get resistance mechanisms based on treatment and mutations
+    const mechanisms = this.getResistanceMechanisms(patient, treatment);
+
+    // Calculate time to resistance
+    const baseTimeToResistance = this.hasBiomarkerMatch(patient, treatment) ? 18 : 9;
+    const timeModifier = patient.priorLines ? 1 - (patient.priorLines * 0.15) : 1;
+
+    // Get next line options
+    const nextLineOptions = this.getNextLineOptions(patient, treatment, mechanisms);
+
+    return {
+      intrinsicResistanceRisk: Math.min(intrinsicRisk, 0.9),
+      acquiredResistanceRisk: Math.min(acquiredRisk, 0.95),
+      predictedMechanisms: mechanisms,
+      timeToResistance: {
+        median: baseTimeToResistance * timeModifier,
+        range: [baseTimeToResistance * timeModifier * 0.5, baseTimeToResistance * timeModifier * 2]
+      },
+      nextLineOptions
+    };
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // HELPER METHODS
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  private initializeDefaultModels(): void {
+    // Register placeholder models
+    const defaultModels: MLModel[] = [
+      {
+        id: 'response-nsclc-v1',
+        name: 'NSCLC Response Predictor',
+        version: '1.0',
+        type: 'classification',
+        target: 'response',
+        cancerTypes: ['NSCLC'],
+        performance: { auc: 0.78, accuracy: 0.72 },
+        validation: { method: 'cross-validation', cohortSize: 1500, testSetSize: 300, validationDate: new Date() },
+        features: ['age', 'stage', 'ecog', 'pdl1', 'tmb', 'egfr', 'alk', 'kras'],
+        importantFeatures: [
+          { feature: 'pdl1', importance: 0.25 },
+          { feature: 'tmb', importance: 0.20 },
+          { feature: 'egfr', importance: 0.18 }
+        ],
+        status: 'validation'
+      },
+      {
+        id: 'survival-pan-cancer-v1',
+        name: 'Pan-Cancer Survival Model',
+        version: '1.0',
+        type: 'survival',
+        target: 'os',
+        cancerTypes: ['all'],
+        performance: { cIndex: 0.72 },
+        validation: { method: 'cross-validation', cohortSize: 10000, testSetSize: 2000, validationDate: new Date() },
+        features: ['age', 'stage', 'ecog', 'cancerType', 'priorLines', 'ldh'],
+        importantFeatures: [
+          { feature: 'stage', importance: 0.30 },
+          { feature: 'ecog', importance: 0.25 },
+          { feature: 'priorLines', importance: 0.15 }
+        ],
+        status: 'validation'
+      }
+    ];
+
+    for (const model of defaultModels) {
+      this.modelRegistry.set(model.id, model);
+    }
+  }
+
+  private initializeFeatureEncoders(): void {
+    // Initialize encoders for categorical variables
+    this.featureEncoders.set('stage', new FeatureEncoder({
+      'I': 1, 'IA': 1, 'IB': 1.5,
+      'II': 2, 'IIA': 2, 'IIB': 2.5,
+      'III': 3, 'IIIA': 3, 'IIIB': 3.5, 'IIIC': 3.8,
+      'IV': 4, 'IVA': 4, 'IVB': 4.5
+    }));
+
+    this.featureEncoders.set('cancerType', new FeatureEncoder({
+      'NSCLC': 1, 'SCLC': 2, 'Breast': 3, 'Colorectal': 4,
+      'Melanoma': 5, 'RCC': 6, 'Ovarian': 7, 'Pancreatic': 8
+    }));
+  }
+
+  private encodeFeatures(patient: PatientFeatures, treatment: TreatmentFeatures): number[] {
+    const features: number[] = [];
+
+    // Numeric features (normalized)
+    features.push(patient.age / 100);
+    features.push(patient.ecogStatus / 4);
+    features.push(patient.gender === 'male' ? 1 : 0);
+
+    // Encoded categorical features
+    const stageEncoder = this.featureEncoders.get('stage');
+    features.push((stageEncoder?.encode(patient.stage) || 2) / 5);
+
+    // Biomarker features
+    features.push((patient.pdl1Score || 0) / 100);
+    features.push((patient.tmbValue || 0) / 50);
+    features.push(patient.msiStatus === 'MSI-H' ? 1 : 0);
+    features.push(patient.hrdStatus === 'positive' ? 1 : 0);
+
+    // Prior treatment features
+    features.push((patient.priorLines || 0) / 5);
+
+    // Treatment features
+    features.push(treatment.treatmentType === 'immunotherapy' ? 1 : 0);
+    features.push(treatment.treatmentType === 'targeted' ? 1 : 0);
+
+    return features;
+  }
+
+  private getBestModel(target: MLModel['target'], cancerType: string): MLModel | undefined {
+    const models = Array.from(this.modelRegistry.values())
+      .filter(m =>
+        m.target === target &&
+        (m.cancerTypes.includes(cancerType) || m.cancerTypes.includes('all')) &&
+        m.status !== 'deprecated'
+      )
+      .sort((a, b) => (b.performance.auc || b.performance.cIndex || 0) - (a.performance.auc || a.performance.cIndex || 0));
+
+    return models[0];
+  }
+
+  private hasBiomarkerMatch(patient: PatientFeatures, treatment: TreatmentFeatures): boolean {
+    // Check for biomarker-drug matches
+    const matches = [
+      { biomarker: 'EGFR', drugs: ['osimertinib', 'erlotinib', 'gefitinib', 'afatinib'] },
+      { biomarker: 'ALK', drugs: ['alectinib', 'crizotinib', 'brigatinib', 'lorlatinib'] },
+      { biomarker: 'BRAF V600', drugs: ['dabrafenib', 'vemurafenib', 'encorafenib'] },
+      { biomarker: 'HER2', drugs: ['trastuzumab', 'pertuzumab', 't-dxd'] },
+      { biomarker: 'BRCA', drugs: ['olaparib', 'rucaparib', 'niraparib', 'talazoparib'] },
+      { biomarker: 'KRAS G12C', drugs: ['sotorasib', 'adagrasib'] }
+    ];
+
+    for (const match of matches) {
+      const hasBiomarker = patient.genomicAlterations.some(g =>
+        g.gene.toUpperCase().includes(match.biomarker) ||
+        g.alteration.toUpperCase().includes(match.biomarker)
+      );
+      const hasDrug = treatment.drugs.some(d =>
+        match.drugs.some(md => d.toLowerCase().includes(md))
+      );
+      if (hasBiomarker && hasDrug) return true;
+    }
+
+    // Check immunotherapy eligibility
+    if (treatment.treatmentType === 'immunotherapy' || this.hasImmunotherapyDrug(treatment.drugs)) {
+      if (patient.msiStatus === 'MSI-H') return true;
+      if (patient.tmbStatus === 'high') return true;
+      if (patient.pdl1Score && patient.pdl1Score >= 50) return true;
+    }
+
+    return false;
+  }
+
+  private hasImmunotherapyDrug(drugs: string[]): boolean {
+    const immunoDrugs = ['pembrolizumab', 'nivolumab', 'ipilimumab', 'atezolizumab', 'durvalumab', 'avelumab'];
+    return drugs.some(d => immunoDrugs.some(id => d.toLowerCase().includes(id)));
+  }
+
+  private getDrugToxicityProfiles(drugs: string[]): {
+    name: string;
+    baseRisk: number;
+    typicalGrade: 1 | 2 | 3 | 4 | 5;
+    affectedOrgan?: string;
+    timeToOnset?: { median: number; unit: 'days' | 'weeks' | 'cycles' };
+    reversible: boolean;
+    management?: string;
+  }[] {
+    const profiles: any[] = [];
+
+    // Check for common drug classes and their toxicities
+    for (const drug of drugs) {
+      const lower = drug.toLowerCase();
+
+      // Checkpoint inhibitors
+      if (['pembrolizumab', 'nivolumab', 'ipilimumab', 'atezolizumab'].some(d => lower.includes(d))) {
+        profiles.push(
+          { name: 'Immune-related dermatitis', baseRisk: 0.35, typicalGrade: 2, affectedOrgan: 'skin', reversible: true },
+          { name: 'Immune-related colitis', baseRisk: 0.15, typicalGrade: 3, affectedOrgan: 'GI', reversible: true, management: 'Corticosteroids' },
+          { name: 'Immune-related pneumonitis', baseRisk: 0.05, typicalGrade: 3, affectedOrgan: 'pulmonary', reversible: true, management: 'Hold treatment, corticosteroids' },
+          { name: 'Immune-related hepatitis', baseRisk: 0.08, typicalGrade: 3, affectedOrgan: 'hepatic', reversible: true },
+          { name: 'Immune-related thyroiditis', baseRisk: 0.15, typicalGrade: 2, affectedOrgan: 'endocrine', reversible: false }
+        );
+      }
+
+      // Platinum agents
+      if (['carboplatin', 'cisplatin', 'oxaliplatin'].some(d => lower.includes(d))) {
+        profiles.push(
+          { name: 'Nausea/Vomiting', baseRisk: 0.60, typicalGrade: 2, affectedOrgan: 'GI', reversible: true },
+          { name: 'Nephrotoxicity', baseRisk: lower.includes('cisplatin') ? 0.25 : 0.08, typicalGrade: 2, affectedOrgan: 'renal', reversible: true },
+          { name: 'Myelosuppression', baseRisk: 0.40, typicalGrade: 3, affectedOrgan: 'hematologic', reversible: true },
+          { name: 'Peripheral neuropathy', baseRisk: 0.30, typicalGrade: 2, affectedOrgan: 'neurologic', reversible: false }
+        );
+      }
+
+      // EGFR TKIs
+      if (['osimertinib', 'erlotinib', 'gefitinib', 'afatinib'].some(d => lower.includes(d))) {
+        profiles.push(
+          { name: 'Rash', baseRisk: 0.45, typicalGrade: 2, affectedOrgan: 'skin', reversible: true },
+          { name: 'Diarrhea', baseRisk: 0.50, typicalGrade: 2, affectedOrgan: 'GI', reversible: true },
+          { name: 'Interstitial lung disease', baseRisk: 0.03, typicalGrade: 4, affectedOrgan: 'pulmonary', reversible: false }
+        );
+      }
+
+      // CDK4/6 inhibitors
+      if (['palbociclib', 'ribociclib', 'abemaciclib'].some(d => lower.includes(d))) {
+        profiles.push(
+          { name: 'Neutropenia', baseRisk: 0.70, typicalGrade: 3, affectedOrgan: 'hematologic', reversible: true },
+          { name: 'Fatigue', baseRisk: 0.40, typicalGrade: 2, reversible: true },
+          { name: 'Diarrhea', baseRisk: lower.includes('abemaciclib') ? 0.80 : 0.20, typicalGrade: 2, affectedOrgan: 'GI', reversible: true }
+        );
+      }
+    }
+
+    return profiles;
+  }
+
+  private getResistanceMechanisms(patient: PatientFeatures, treatment: TreatmentFeatures): ResistancePrediction['predictedMechanisms'] {
+    const mechanisms: ResistancePrediction['predictedMechanisms'] = [];
+
+    // EGFR TKI resistance mechanisms
+    if (treatment.drugs.some(d => ['osimertinib', 'erlotinib', 'gefitinib'].some(e => d.toLowerCase().includes(e)))) {
+      mechanisms.push(
+        { mechanism: 'MET amplification', probability: 0.20, monitoringBiomarker: 'MET FISH/NGS' },
+        { mechanism: 'EGFR C797S mutation', probability: 0.15, monitoringBiomarker: 'ctDNA EGFR' },
+        { mechanism: 'Histologic transformation (SCLC)', probability: 0.05, monitoringBiomarker: 'Tissue biopsy' },
+        { mechanism: 'HER2 amplification', probability: 0.10, monitoringBiomarker: 'HER2 NGS/FISH' }
+      );
+    }
+
+    // Immunotherapy resistance
+    if (this.hasImmunotherapyDrug(treatment.drugs)) {
+      mechanisms.push(
+        { mechanism: 'Beta-2 microglobulin loss', probability: 0.10, monitoringBiomarker: 'B2M NGS' },
+        { mechanism: 'JAK1/2 mutations', probability: 0.08, monitoringBiomarker: 'JAK1/2 NGS' },
+        { mechanism: 'Immunosuppressive TME', probability: 0.25, monitoringBiomarker: 'Tissue biopsy + IHC' },
+        { mechanism: 'Antigen loss', probability: 0.15 }
+      );
+    }
+
+    // BRAF inhibitor resistance
+    if (treatment.drugs.some(d => ['dabrafenib', 'vemurafenib', 'encorafenib'].some(b => d.toLowerCase().includes(b)))) {
+      mechanisms.push(
+        { mechanism: 'MAPK reactivation', probability: 0.30, monitoringBiomarker: 'NRAS/MEK NGS' },
+        { mechanism: 'BRAF amplification', probability: 0.15, monitoringBiomarker: 'BRAF CNV' },
+        { mechanism: 'RTK bypass (EGFR, MET)', probability: 0.20, monitoringBiomarker: 'Comprehensive NGS' }
+      );
+    }
+
+    return mechanisms;
+  }
+
+  private getNextLineOptions(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    mechanisms: ResistancePrediction['predictedMechanisms']
+  ): ResistancePrediction['nextLineOptions'] {
+    const options: ResistancePrediction['nextLineOptions'] = [];
+
+    // Based on predicted resistance mechanisms
+    for (const mech of mechanisms.slice(0, 3)) {
+      if (mech.mechanism === 'MET amplification') {
+        options.push({
+          therapy: 'Osimertinib + Savolitinib',
+          rationale: 'Targets MET bypass pathway',
+          expectedBenefit: 8
+        });
+      }
+      if (mech.mechanism === 'EGFR C797S mutation') {
+        options.push({
+          therapy: 'First-generation EGFR TKI + Third-generation EGFR TKI',
+          rationale: 'C797S may restore sensitivity to 1st-gen TKI',
+          expectedBenefit: 6
+        });
+      }
+      if (mech.mechanism === 'Histologic transformation (SCLC)') {
+        options.push({
+          therapy: 'Platinum-etoposide chemotherapy',
+          rationale: 'Standard SCLC treatment',
+          expectedBenefit: 4
+        });
+      }
+    }
+
+    // Add general next-line options
+    if (treatment.treatmentType !== 'immunotherapy' && !this.hasImmunotherapyDrug(treatment.drugs)) {
+      options.push({
+        therapy: 'Immunotherapy (if PD-L1+/TMB-H)',
+        rationale: 'Different mechanism of action',
+        expectedBenefit: 10
+      });
+    }
+
+    // Clinical trial option
+    options.push({
+      therapy: 'Clinical trial enrollment',
+      rationale: 'Access to novel agents',
+      expectedBenefit: 8
+    });
+
+    return options;
+  }
+
+  private estimateQoLScore(toxicity: ToxicityPrediction): number {
+    let score = 0.85; // Base quality of life
+
+    // Reduce based on toxicity severity
+    score -= toxicity.grade3PlusRisk * 0.3;
+
+    // Specific high-impact toxicities
+    for (const tox of toxicity.specificRisks) {
+      if (tox.toxicity.toLowerCase().includes('neuropathy') && tox.grade >= 2) {
+        score -= 0.1;
+      }
+      if (tox.toxicity.toLowerCase().includes('fatigue') && tox.grade >= 2) {
+        score -= 0.08;
+      }
+      if (tox.toxicity.toLowerCase().includes('nausea') && tox.grade >= 2) {
+        score -= 0.05;
+      }
+    }
+
+    return Math.max(score, 0.3);
+  }
+
+  private getMatchingBiomarkers(patient: PatientFeatures, treatment: TreatmentFeatures): string[] {
+    const matches: string[] = [];
+
+    for (const alt of patient.genomicAlterations) {
+      if (this.isBiomarkerRelevant(alt.gene, alt.alteration, treatment)) {
+        matches.push(`${alt.gene} ${alt.alteration}`);
+      }
+    }
+
+    if (patient.msiStatus === 'MSI-H' && this.hasImmunotherapyDrug(treatment.drugs)) {
+      matches.push('MSI-H');
+    }
+    if (patient.tmbStatus === 'high' && this.hasImmunotherapyDrug(treatment.drugs)) {
+      matches.push('TMB-High');
+    }
+    if (patient.hrdStatus === 'positive' && treatment.drugs.some(d =>
+      ['olaparib', 'rucaparib', 'niraparib', 'talazoparib'].some(p => d.toLowerCase().includes(p))
+    )) {
+      matches.push('HRD-positive');
+    }
+
+    return matches;
+  }
+
+  private isBiomarkerRelevant(gene: string, alteration: string, treatment: TreatmentFeatures): boolean {
+    const relevantPairs: Record<string, string[]> = {
+      'EGFR': ['osimertinib', 'erlotinib', 'gefitinib', 'afatinib'],
+      'ALK': ['alectinib', 'crizotinib', 'brigatinib', 'lorlatinib'],
+      'ROS1': ['crizotinib', 'entrectinib'],
+      'BRAF': ['dabrafenib', 'vemurafenib', 'encorafenib'],
+      'HER2': ['trastuzumab', 'pertuzumab', 't-dxd'],
+      'BRCA': ['olaparib', 'rucaparib', 'niraparib', 'talazoparib'],
+      'KRAS': ['sotorasib', 'adagrasib'],
+      'NTRK': ['larotrectinib', 'entrectinib'],
+      'RET': ['selpercatinib', 'pralsetinib'],
+      'MET': ['capmatinib', 'tepotinib']
+    };
+
+    const drugs = relevantPairs[gene.toUpperCase()];
+    if (!drugs) return false;
+
+    return treatment.drugs.some(d => drugs.some(rd => d.toLowerCase().includes(rd)));
+  }
+
+  private checkFDAApproval(treatment: TreatmentFeatures, cancerType: string): boolean {
+    // Simplified FDA approval check - would reference actual database in production
+    const approvedCombinations: Record<string, string[]> = {
+      'NSCLC': ['osimertinib', 'pembrolizumab', 'alectinib', 'sotorasib'],
+      'Breast': ['palbociclib', 'trastuzumab', 'olaparib', 'sacituzumab'],
+      'Melanoma': ['pembrolizumab', 'nivolumab', 'ipilimumab', 'dabrafenib'],
+      'Colorectal': ['pembrolizumab', 'cetuximab', 'bevacizumab'],
+      'RCC': ['pembrolizumab', 'nivolumab', 'cabozantinib']
+    };
+
+    const approvedDrugs = approvedCombinations[cancerType] || [];
+    return treatment.drugs.some(d => approvedDrugs.some(ad => d.toLowerCase().includes(ad)));
+  }
+
+  private checkNCCNRecommendation(treatment: TreatmentFeatures, cancerType: string, stage: string): boolean {
+    // Simplified NCCN check - would reference actual guidelines in production
+    return this.checkFDAApproval(treatment, cancerType);
+  }
+
+  private getConsiderations(patient: PatientFeatures, treatment: TreatmentFeatures): string[] {
+    const considerations: string[] = [];
+
+    if (patient.age > 75) {
+      considerations.push('Consider dose reduction for elderly patient');
+    }
+    if (patient.ecogStatus >= 2) {
+      considerations.push('Poor performance status may limit tolerability');
+    }
+    if (patient.organFunction?.renal === 'impaired') {
+      considerations.push('Dose adjustment may be needed for renal impairment');
+    }
+    if (patient.priorLines && patient.priorLines >= 2) {
+      considerations.push('Heavily pretreated - consider clinical trial');
+    }
+
+    return considerations;
+  }
+
+  private generateOverallAssessment(
+    patient: PatientFeatures,
+    treatment: TreatmentFeatures,
+    response: ResponsePrediction,
+    survival: SurvivalPrediction,
+    toxicity: ToxicityPrediction,
+    resistance: ResistancePrediction
+  ): {
+    recommendation: 'strongly-recommended' | 'recommended' | 'consider' | 'caution' | 'not-recommended';
+    rationale: string[];
+    caveats: string[];
+    alternativeOptions: string[];
+  } {
+    const rationale: string[] = [];
+    const caveats: string[] = [];
+    const alternativeOptions: string[] = [];
+
+    // Calculate recommendation score
+    let score = 50;
+
+    // Response contribution
+    if (response.objectiveResponseRate >= 0.6) { score += 20; rationale.push('High expected response rate'); }
+    else if (response.objectiveResponseRate >= 0.4) { score += 10; }
+    else if (response.objectiveResponseRate < 0.2) { score -= 20; caveats.push('Low expected response rate'); }
+
+    // Survival contribution
+    if (survival.pfs.twelveMonth >= 0.6) { score += 15; rationale.push('Favorable survival outlook'); }
+    else if (survival.pfs.twelveMonth < 0.3) { score -= 15; caveats.push('Limited expected duration of benefit'); }
+
+    // Toxicity contribution
+    if (toxicity.grade3PlusRisk < 0.2) { score += 10; rationale.push('Favorable toxicity profile'); }
+    else if (toxicity.grade3PlusRisk > 0.5) { score -= 20; caveats.push('High risk of severe toxicity'); }
+
+    // Biomarker match
+    if (this.hasBiomarkerMatch(patient, treatment)) {
+      score += 15;
+      rationale.push('Biomarker-matched therapy');
+    }
+
+    // FDA approval and guidelines
+    if (this.checkFDAApproval(treatment, patient.cancerType)) {
+      score += 10;
+      rationale.push('FDA approved for indication');
+    }
+
+    // Add alternatives
+    if (resistance.nextLineOptions.length > 0) {
+      alternativeOptions.push(...resistance.nextLineOptions.slice(0, 2).map(o => o.therapy));
+    }
+
+    // Determine recommendation
+    let recommendation: 'strongly-recommended' | 'recommended' | 'consider' | 'caution' | 'not-recommended';
+    if (score >= 80) recommendation = 'strongly-recommended';
+    else if (score >= 60) recommendation = 'recommended';
+    else if (score >= 40) recommendation = 'consider';
+    else if (score >= 20) recommendation = 'caution';
+    else recommendation = 'not-recommended';
+
+    return { recommendation, rationale, caveats, alternativeOptions };
+  }
+
+  private getCacheKey(type: string, patient: PatientFeatures, treatment: TreatmentFeatures): string {
+    const data = JSON.stringify({ type, patient, treatment });
+    return createHash('sha256').update(data).digest('hex').substring(0, 16);
+  }
+
+  private getFromCache<T>(key: string): T | null {
+    const cached = this.predictionCache.get(key);
+    if (cached && Date.now() - cached.timestamp.getTime() < this.cacheDuration) {
+      return cached.prediction as T;
+    }
+    return null;
+  }
+
+  private setCache(key: string, prediction: any): void {
+    this.predictionCache.set(key, { prediction, timestamp: new Date() });
+  }
+
+  /**
+   * Register a new model
+   */
+  registerModel(model: MLModel): void {
+    this.modelRegistry.set(model.id, model);
+    this.emit('model-registered', model);
+  }
+
+  /**
+   * Get model performance metrics
+   */
+  getModelMetrics(modelId: string): MLModel['performance'] | undefined {
+    return this.modelRegistry.get(modelId)?.performance;
+  }
+
+  /**
+   * List all available models
+   */
+  listModels(): MLModel[] {
+    return Array.from(this.modelRegistry.values());
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FEATURE ENCODER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+class FeatureEncoder {
+  private mapping: Record<string, number>;
+
+  constructor(mapping: Record<string, number>) {
+    this.mapping = mapping;
+  }
+
+  encode(value: string): number {
+    return this.mapping[value] ?? 0;
+  }
+}
+
+export default OutcomePredictorService;