@erosolaraijs/cure 2.3.0 → 2.4.0

package/dist/tools/index.js

@@ -0,0 +1,1373 @@
+import { UniversalCancerCureEngine } from '../capabilities/universalCancerCureEngine.js';
+import { TreatmentSequencingEngine } from '../capabilities/treatmentSequencing.js';
+import { SpecialPopulationsEngine } from '../capabilities/specialPopulationsModule.js';
+import { GlobalCancerCoverageModule } from '../capabilities/globalCancerCoverage.js';
+import { UniversalHealthEngine } from '../capabilities/universalHealthFramework.js';
+import { PrecisionMedicineEngine } from '../capabilities/precisionMedicineModule.js';
+import { CureValidationFramework } from '../capabilities/cureValidationFramework.js';
+import { PalliativeCareEngine } from '../capabilities/palliativeCareModule.js';
+import { EmergencyOncologyEngine } from '../capabilities/emergencyOncology.js';
+import { SurvivorshipCareEngine } from '../capabilities/survivorshipManagement.js';
+import { MultimodalOncologyEngine } from '../capabilities/multimodalOncologyModule.js';
+import { ResistanceManagementEngine, CureVerificationEngine } from '../capabilities/resistanceManagement.js';
+import { ClinicalTrialMatchingEngine } from '../capabilities/clinicalTrialMatchingModule.js';
+import { EmergingTherapeuticsModule } from '../capabilities/emergingTherapeutics.js';
+import { RetrospectiveValidationService } from '../validation/index.js';
+import { createRealWorldOncologyService } from '../orchestrator/realWorldOncology.js';
+import { OutcomePredictorService } from '../ml/outcomePredictor.js';
+import { DrugSafetyService } from '../safety/drugInteractions.js';
+import { HIPAAComplianceService } from '../compliance/hipaa.js';
+import { ClinicalDecisionSupportService } from '../clinician/decisionSupport.js';
+import { PatientPortalService } from '../patient/patientPortal.js';
+import { UnifiedGenomicsService, GenomicPlatformClient } from '../integrations/genomics/genomicPlatforms.js';
+const SAMPLE_PATIENT_ID = 'TOOL-001';
+const SAMPLE_CANCER_TYPE = 'NSCLC';
+const SAMPLE_STAGE = 'IV';
+function formatPercent(value) {
+    return `${(value * 100).toFixed(1)}%`;
+}
+function formatNumber(value) {
+    return Math.round(value * 10) / 10;
+}
+function runToolAction(toolId, action) {
+    const start = Date.now();
+    return action()
+        .then(payload => {
+        const checks = payload.checks;
+        const ok = payload.ok ?? (checks ? checks.every(check => check.ok) : true);
+        return {
+            toolId,
+            ok,
+            summary: payload.summary,
+            durationMs: Date.now() - start,
+            checks,
+            metrics: payload.metrics
+        };
+    })
+        .catch(error => {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            toolId,
+            ok: false,
+            summary: message,
+            durationMs: Date.now() - start
+        };
+    });
+}
+function createSampleGenomicProfile() {
+    return {
+        mutations: ['EGFR', 'TP53'],
+        biomarkers: ['EGFR+', 'PD-L1 60%'],
+        msiStatus: 'MSS',
+        tmbLevel: 'High',
+        pdl1Expression: 60,
+        hrdStatus: false
+    };
+}
+function createSampleRealWorldPatient() {
+    return {
+        id: SAMPLE_PATIENT_ID,
+        demographics: {
+            firstName: 'Alex',
+            lastName: 'Taylor',
+            dateOfBirth: new Date('1962-05-10'),
+            gender: 'male',
+            ethnicity: 'other',
+            address: {
+                city: 'Boston',
+                state: 'MA',
+                zipCode: '02115',
+                country: 'USA'
+            }
+        },
+        diagnosis: {
+            cancerType: SAMPLE_CANCER_TYPE,
+            stage: SAMPLE_STAGE,
+            diagnosisDate: new Date('2022-01-15'),
+            histology: 'Adenocarcinoma',
+            primarySite: 'Lung',
+            metastaticSites: ['Brain']
+        },
+        genomics: {
+            testDate: new Date('2022-02-01'),
+            platform: 'Foundation',
+            mutations: ['EGFR L858R', 'TP53'],
+            biomarkers: {
+                EGFR: 'positive',
+                'PD-L1': '60%'
+            },
+            msiStatus: 'MSS',
+            tmbLevel: 'High',
+            tmbValue: 12,
+            pdl1Expression: 60,
+            hrdStatus: false,
+            hrdScore: 22
+        },
+        performanceStatus: 1,
+        comorbidities: ['Hypertension']
+    };
+}
+function createSamplePatientFeatures() {
+    return {
+        age: 62,
+        gender: 'male',
+        cancerType: SAMPLE_CANCER_TYPE,
+        stage: 'IV',
+        ecogStatus: 1,
+        genomicAlterations: [
+            {
+                gene: 'EGFR',
+                alteration: 'L858R',
+                type: 'mutation',
+                vaf: 0.32
+            }
+        ],
+        pdl1Score: 60,
+        pdl1ScoreType: 'TPS',
+        msiStatus: 'MSS',
+        tmbValue: 12,
+        tmbStatus: 'high'
+    };
+}
+function createSampleTreatmentFeatures() {
+    return {
+        regimen: 'Osimertinib',
+        drugs: ['Osimertinib'],
+        treatmentType: 'targeted',
+        setting: 'first-line'
+    };
+}
+function createSampleSafetyProfile(patientId) {
+    return {
+        patientId,
+        allergies: [
+            {
+                allergen: 'Penicillin',
+                reactionType: 'rash',
+                severity: 'moderate'
+            }
+        ],
+        renalFunction: {
+            gfr: 85,
+            creatinine: 1.0,
+            dialysis: false
+        },
+        hepaticFunction: {
+            childPughClass: 'A',
+            bilirubin: 1.1,
+            albumin: 4.0,
+            inr: 1.0,
+            ascites: 'none',
+            encephalopathy: 'none'
+        },
+        cardiacStatus: {
+            qtcInterval: 440,
+            lvef: 60,
+            arrhythmiaHistory: false
+        },
+        currentMedications: [
+            {
+                drug: 'Lisinopril',
+                dose: '10mg',
+                frequency: 'daily',
+                startDate: new Date('2020-01-01')
+            }
+        ],
+        demographics: {
+            age: 62,
+            weight: 78,
+            gender: 'male'
+        }
+    };
+}
+function createSampleTrialProfile() {
+    return {
+        cancerType: SAMPLE_CANCER_TYPE,
+        histology: 'Adenocarcinoma',
+        stage: SAMPLE_STAGE,
+        biomarkers: [
+            {
+                name: 'EGFR exon 19 del or L858R',
+                status: 'Positive'
+            }
+        ],
+        priorTherapies: ['Osimertinib'],
+        currentLine: 2,
+        age: 62,
+        performanceStatus: 1,
+        organFunction: {
+            renalFunction: 'Normal',
+            hepaticFunction: 'Normal',
+            cardiacFunction: 'Normal',
+            bonemarrowFunction: 'Normal'
+        },
+        location: {
+            country: 'United States',
+            state: 'MA',
+            city: 'Boston'
+        },
+        willingToTravel: true,
+        maxTravelDistance: 100,
+        preferences: {
+            preferredPhases: ['Phase 2', 'Phase 3'],
+            acceptPlaceboArm: false,
+            preferLocalTrials: true,
+            interestedMechanisms: ['EGFR inhibitors', 'Immunotherapy']
+        }
+    };
+}
+function createSamplePainAssessment() {
+    return {
+        location: ['Lower back'],
+        intensity: 7,
+        quality: ['Burning', 'Shooting'],
+        temporalPattern: 'Constant',
+        aggravatingFactors: ['Movement'],
+        relievingFactors: ['Rest', 'Heat'],
+        functionalImpact: {
+            sleepDisturbance: 2,
+            mobilityImpairment: 1,
+            selfCareImpairment: 0,
+            socialImpairment: 1,
+            overallQoL: 6
+        },
+        psychologicalImpact: ['Anxiety'],
+        painType: ['Neuropathic-Peripheral']
+    };
+}
+function createSampleTreatmentSummary() {
+    return {
+        cancerType: 'breast',
+        stage: 'early stage',
+        summary: {
+            surgery: [
+                {
+                    procedure: 'Lumpectomy',
+                    date: '2022-06-01',
+                    findings: 'Clear margins',
+                    complications: [],
+                    longTermConsiderations: ['Lymphedema monitoring']
+                }
+            ],
+            radiation: [
+                {
+                    site: 'Breast',
+                    modality: 'IMRT',
+                    totalDose: '50 Gy',
+                    fractions: 25,
+                    completionDate: '2022-09-01',
+                    acuteToxicities: ['Fatigue'],
+                    expectedLateEffects: ['Fibrosis']
+                }
+            ],
+            systemicTherapy: [
+                {
+                    agentClass: 'Chemotherapy',
+                    specificAgents: ['Doxorubicin', 'Cyclophosphamide'],
+                    duration: '12 weeks',
+                    completionDate: '2022-05-01',
+                    significantToxicities: ['Nausea'],
+                    expectedLateEffects: ['Cardiac monitoring']
+                }
+            ],
+            otherTreatments: []
+        }
+    };
+}
+function createSamplePortalSummary(patientId) {
+    return {
+        patientId,
+        diagnosis: {
+            condition: 'Non-small cell lung cancer',
+            diagnosisDate: new Date('2022-01-15'),
+            stage: 'IV',
+            simpleExplanation: 'Lung cancer that has spread, treated with targeted therapy.'
+        },
+        currentTreatment: {
+            regimen: 'Osimertinib',
+            medications: [
+                {
+                    name: 'Osimertinib',
+                    purpose: 'Target EGFR mutation',
+                    dose: '80mg',
+                    frequency: 'Daily',
+                    instructions: 'Take with or without food',
+                    sideEffectsToWatch: ['Rash', 'Diarrhea']
+                }
+            ],
+            startDate: new Date('2022-02-01'),
+            cycleInfo: {
+                currentCycle: 3,
+                totalPlannedCycles: 12,
+                nextCycleDate: new Date('2022-05-01')
+            },
+            whatToExpect: ['Monthly labs', 'Imaging every 8-12 weeks'],
+            whenToCallDoctor: ['Fever over 100.4F', 'Shortness of breath']
+        },
+        upcomingAppointments: [
+            {
+                date: new Date('2022-05-15'),
+                type: 'CT Scan',
+                provider: 'Radiology',
+                location: 'Main Hospital'
+            }
+        ],
+        careTeam: [
+            {
+                role: 'Medical Oncologist',
+                name: 'Dr. Chen',
+                phone: '555-0101',
+                messageable: true
+            }
+        ],
+        goals: [
+            {
+                goal: 'Maintain energy levels',
+                progress: 70,
+                lastUpdated: new Date('2022-04-01')
+            }
+        ]
+    };
+}
+function buildSampleGenomicResults(patientId) {
+    return [
+        {
+            reportId: 'REP-001',
+            orderId: 'ORD-001',
+            patientId,
+            testType: 'comprehensive-genomic-profiling',
+            panelName: 'MockPanel',
+            specimenInfo: {
+                type: 'tissue',
+                collectionDate: new Date('2023-01-10'),
+                tumorPurity: 0.4
+            },
+            reportDate: new Date('2023-01-20'),
+            variants: [
+                {
+                    gene: 'EGFR',
+                    hgvsP: 'p.L858R',
+                    variantType: 'SNV',
+                    variantAlleleFrequency: 0.32,
+                    clinicalSignificance: 'pathogenic'
+                }
+            ],
+            copyNumberAlterations: [],
+            fusions: [],
+            biomarkers: [
+                {
+                    name: 'PD-L1',
+                    value: 60,
+                    unit: '%',
+                    status: 'positive',
+                    method: 'IHC'
+                }
+            ],
+            therapyMatches: [],
+            clinicalTrialMatches: [],
+            signatures: {
+                microsatelliteInstability: {
+                    status: 'MSS',
+                    method: 'NGS'
+                },
+                tumorMutationalBurden: {
+                    value: 12,
+                    unit: 'mutations/Mb',
+                    status: 'high',
+                    threshold: 10
+                }
+            },
+            qualityMetrics: {
+                meanCoverage: 500,
+                percentBases100x: 0.95
+            }
+        }
+    ];
+}
+class MockGenomicClient extends GenomicPlatformClient {
+    sampleResults;
+    constructor(config, sampleResults) {
+        super(config);
+        this.sampleResults = sampleResults;
+    }
+    async authenticate() {
+        return;
+    }
+    async submitOrder(order) {
+        return { orderId: order.orderId, status: 'completed' };
+    }
+    async getOrderStatus(orderId) {
+        return {
+            orderId,
+            patientId: SAMPLE_PATIENT_ID,
+            testType: 'comprehensive-genomic-profiling',
+            panelName: 'MockPanel',
+            specimenType: 'tissue',
+            orderDate: new Date(),
+            clinicalIndication: 'Mock indication',
+            icdCodes: ['C34.9'],
+            orderingPhysician: {
+                name: 'Dr. Smith',
+                npi: '0000000000',
+                facility: 'Mock Hospital'
+            },
+            status: 'completed'
+        };
+    }
+    async getResults(_orderId) {
+        return this.sampleResults[0];
+    }
+    async listPatientResults(patientId) {
+        return this.sampleResults.filter(result => result.patientId === patientId);
+    }
+}
+function buildSampleValidationData() {
+    const cohortId = 'sample-cohort';
+    const patients = [
+        {
+            id: 'VAL-001',
+            demographics: { ageAtDiagnosis: 67, gender: 'male' },
+            diagnosis: {
+                cancerType: 'NSCLC',
+                stage: 'IV',
+                diagnosisDate: new Date('2021-11-15'),
+                biomarkers: [{ name: 'EGFR', value: 'L858R' }]
+            },
+            treatment: {
+                regimen: 'Osimertinib',
+                drugs: ['Osimertinib'],
+                setting: 'first-line',
+                startDate: new Date('2021-12-01'),
+                endDate: new Date('2023-01-15')
+            },
+            outcomes: {
+                bestResponse: 'PR',
+                responseDate: new Date('2022-02-15'),
+                progressionDate: new Date('2023-01-15'),
+                lastFollowUpDate: new Date('2023-02-01')
+            },
+            ecogAtBaseline: 1,
+            priorLines: 0
+        },
+        {
+            id: 'VAL-002',
+            demographics: { ageAtDiagnosis: 55, gender: 'female' },
+            diagnosis: {
+                cancerType: 'Breast Cancer',
+                stage: 'II',
+                diagnosisDate: new Date('2020-03-10'),
+                biomarkers: [{ name: 'ER', value: 'positive' }, { name: 'HER2', value: 'negative' }]
+            },
+            treatment: {
+                regimen: 'AC-T',
+                drugs: ['Doxorubicin', 'Cyclophosphamide', 'Paclitaxel'],
+                setting: 'adjuvant',
+                startDate: new Date('2020-04-01'),
+                endDate: new Date('2020-09-15'),
+                cycles: 8
+            },
+            outcomes: {
+                bestResponse: 'CR',
+                responseDate: new Date('2020-09-10'),
+                lastFollowUpDate: new Date('2023-03-10')
+            },
+            ecogAtBaseline: 0,
+            priorLines: 0
+        },
+        {
+            id: 'VAL-003',
+            demographics: { ageAtDiagnosis: 48, gender: 'female' },
+            diagnosis: {
+                cancerType: 'Melanoma',
+                stage: 'III',
+                diagnosisDate: new Date('2019-06-01'),
+                biomarkers: [{ name: 'BRAF', value: 'V600E' }]
+            },
+            treatment: {
+                regimen: 'Nivolumab',
+                drugs: ['Nivolumab'],
+                setting: 'adjuvant',
+                startDate: new Date('2019-07-01'),
+                endDate: new Date('2020-02-01')
+            },
+            outcomes: {
+                bestResponse: 'SD',
+                responseDate: new Date('2019-10-01'),
+                progressionDate: new Date('2020-02-01'),
+                deathDate: new Date('2021-01-15'),
+                lastFollowUpDate: new Date('2021-01-15')
+            },
+            ecogAtBaseline: 1,
+            priorLines: 1
+        }
+    ];
+    const recommendations = [
+        {
+            patientId: 'VAL-001',
+            recommendedRegimen: 'Osimertinib',
+            recommendedDrugs: ['Osimertinib'],
+            predictions: {
+                responseRate: 0.68,
+                pfsMonths: 14,
+                osMonths: 28,
+                toxicityRisk: 0.2
+            },
+            matchingBiomarkers: ['EGFR L858R'],
+            confidenceScore: 0.82,
+            timestamp: new Date('2021-12-01')
+        },
+        {
+            patientId: 'VAL-002',
+            recommendedRegimen: 'AC-T',
+            recommendedDrugs: ['Doxorubicin', 'Cyclophosphamide', 'Paclitaxel'],
+            predictions: {
+                responseRate: 0.85,
+                pfsMonths: 30,
+                osMonths: 60,
+                toxicityRisk: 0.25
+            },
+            matchingBiomarkers: ['ER+', 'PR+', 'HER2-'],
+            confidenceScore: 0.88,
+            timestamp: new Date('2020-04-01')
+        },
+        {
+            patientId: 'VAL-003',
+            recommendedRegimen: 'Nivolumab + Ipilimumab',
+            recommendedDrugs: ['Nivolumab', 'Ipilimumab'],
+            predictions: {
+                responseRate: 0.55,
+                pfsMonths: 10,
+                osMonths: 24,
+                toxicityRisk: 0.35
+            },
+            matchingBiomarkers: ['BRAF V600E'],
+            confidenceScore: 0.7,
+            timestamp: new Date('2019-07-01')
+        }
+    ];
+    return { cohortId, patients, recommendations };
+}
+export async function runSelfTestSuite(context) {
+    const start = Date.now();
+    const checks = [];
+    const cancerTreatment = context.cancerTreatment;
+    const runCheck = async (name, task) => {
+        try {
+            const result = await task();
+            checks.push({ name, ok: result.ok, detail: result.detail });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            checks.push({ name, ok: false, detail: message });
+        }
+    };
+    await runCheck('protocols-loaded', async () => {
+        const protocols = await cancerTreatment.listTreatmentProtocols();
+        return {
+            ok: protocols.length > 0,
+            detail: `count=${protocols.length}`
+        };
+    });
+    await runCheck('drug-targets-loaded', async () => {
+        const targets = await cancerTreatment.listDrugTargets();
+        return {
+            ok: targets.length > 10,
+            detail: `count=${targets.length}`
+        };
+    });
+    await runCheck('analyze-patient', async () => {
+        const analysis = await cancerTreatment.analyzePatient('SELFTEST-001', true);
+        const cancerType = analysis?.analysis?.cancerType;
+        return {
+            ok: Boolean(cancerType),
+            detail: `cancerType=${cancerType ?? 'unknown'}`
+        };
+    });
+    await runCheck('treatment-plan', async () => {
+        const plan = await cancerTreatment.designTreatmentPlan('SELFTEST-001');
+        const protocolId = plan?.plan?.protocol?.id;
+        return {
+            ok: Boolean(protocolId),
+            detail: `protocol=${protocolId ?? 'unknown'}`
+        };
+    });
+    await runCheck('target-discovery', async () => {
+        const discovery = await cancerTreatment.discoverDrugTargets('Lung', 'EGFR');
+        const matchCount = Array.isArray(discovery?.discoveredTargets)
+            ? discovery.discoveredTargets.length
+            : 0;
+        return {
+            ok: matchCount > 0,
+            detail: `matches=${matchCount}`
+        };
+    });
+    await runCheck('cure-protocol', async () => {
+        const result = await cancerTreatment.cureCancer('SELFTEST-001', 'Lung', 'IV', {
+            mutations: ['EGFR'],
+            biomarkers: ['EGFR+'],
+            msiStatus: 'MSS',
+            tmbLevel: 'High',
+            pdl1Expression: 60,
+            hrdStatus: false
+        });
+        const confidence = result?.projectedOutcome?.cureConfidence;
+        return {
+            ok: typeof confidence === 'number',
+            detail: confidence !== undefined ? `confidence=${formatPercent(confidence)}` : 'confidence=unknown'
+        };
+    });
+    const ok = checks.every(check => check.ok);
+    const summary = ok
+        ? `All ${checks.length} checks passed`
+        : `${checks.filter(check => !check.ok).length} checks failed`;
+    return {
+        toolId: 'selftest',
+        ok,
+        summary,
+        durationMs: Date.now() - start,
+        checks
+    };
+}
+export async function runValidationSample() {
+    const start = Date.now();
+    try {
+        const service = new RetrospectiveValidationService();
+        const { cohortId, patients, recommendations } = buildSampleValidationData();
+        service.loadCohort(cohortId, patients);
+        service.loadRecommendations(recommendations);
+        const analysis = await service.runValidation(cohortId);
+        const metrics = {
+            patients: analysis.patientCount,
+            fullConcordance: formatPercent(analysis.concordance.fullConcordance),
+            partialConcordance: formatPercent(analysis.concordance.partialConcordance),
+            responseAccuracy: formatPercent(analysis.predictionAccuracy.responseAccuracy),
+            medianPfsMonths: formatNumber(analysis.clinicalImpact.medianPFS),
+            medianOsMonths: formatNumber(analysis.clinicalImpact.medianOS)
+        };
+        return {
+            toolId: 'validate',
+            ok: analysis.patientCount === patients.length,
+            summary: `Validated ${analysis.patientCount} patients`,
+            durationMs: Date.now() - start,
+            metrics
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            toolId: 'validate',
+            ok: false,
+            summary: message,
+            durationMs: Date.now() - start
+        };
+    }
+}
+async function runCancerCore(context) {
+    return runToolAction('cancer-core', async () => {
+        const protocols = await context.cancerTreatment.listTreatmentProtocols();
+        const targets = await context.cancerTreatment.listDrugTargets();
+        const immunotherapies = await context.cancerTreatment.listImmunotherapyProtocols();
+        const combos = await context.cancerTreatment.listCombinationTherapies();
+        const checks = [
+            { name: 'protocols', ok: protocols.length > 0, detail: `count=${protocols.length}` },
+            { name: 'targets', ok: targets.length > 0, detail: `count=${targets.length}` },
+            { name: 'immunotherapy', ok: immunotherapies.length > 0, detail: `count=${immunotherapies.length}` },
+            { name: 'combinations', ok: combos.length > 0, detail: `count=${combos.length}` }
+        ];
+        return {
+            summary: `Protocols ${protocols.length}, targets ${targets.length}`,
+            checks,
+            metrics: {
+                protocols: protocols.length,
+                drugTargets: targets.length,
+                immunotherapyProtocols: immunotherapies.length,
+                combinationTherapies: combos.length
+            }
+        };
+    });
+}
+async function runCancerAnalyze(context) {
+    return runToolAction('cancer-analyze', async () => {
+        const result = await context.cancerTreatment.analyzePatient(SAMPLE_PATIENT_ID, true);
+        const analysis = result.analysis;
+        return {
+            summary: `Analyzed ${analysis.cancerType} ${analysis.stage}`,
+            metrics: {
+                cancerType: analysis.cancerType,
+                stage: analysis.stage,
+                biomarkers: analysis.biomarkers.join(', '),
+                survivalProbability: formatPercent(analysis.riskAssessment.survivalProbability)
+            }
+        };
+    });
+}
+async function runCancerPlan(context) {
+    return runToolAction('cancer-plan', async () => {
+        const result = await context.cancerTreatment.designTreatmentPlan(SAMPLE_PATIENT_ID);
+        const protocolName = result.plan.protocol.name;
+        return {
+            summary: `Plan ${protocolName}`,
+            metrics: {
+                protocol: protocolName,
+                estimatedEfficacy: formatPercent(result.estimatedEfficacy)
+            }
+        };
+    });
+}
+async function runCancerCure(context) {
+    return runToolAction('cancer-cure', async () => {
+        const profile = createSampleGenomicProfile();
+        const result = await context.cancerTreatment.cureCancer(SAMPLE_PATIENT_ID, SAMPLE_CANCER_TYPE, SAMPLE_STAGE, profile);
+        return {
+            summary: `Status ${result.status}`,
+            metrics: {
+                cureConfidence: formatPercent(result.projectedOutcome.cureConfidence),
+                responseRate: formatPercent(result.projectedOutcome.responseRate),
+                fiveYearSurvival: formatPercent(result.projectedOutcome.fiveYearSurvival)
+            }
+        };
+    });
+}
+async function runCancerDiscover(context) {
+    return runToolAction('cancer-discover', async () => {
+        const discovery = await context.cancerTreatment.discoverDrugTargets('Lung', 'EGFR');
+        const matchCount = Array.isArray(discovery?.discoveredTargets)
+            ? discovery.discoveredTargets.length
+            : 0;
+        const topTarget = discovery?.discoveredTargets?.[0]?.gene || 'none';
+        return {
+            summary: `Discovered ${matchCount} targets`,
+            metrics: {
+                matches: matchCount,
+                topTarget
+            }
+        };
+    });
+}
+async function runUniversalCure() {
+    return runToolAction('universal-cure', async () => {
+        const engine = new UniversalCancerCureEngine();
+        const result = await engine.cureAnyCancer('U-001', {
+            cancerType: 'NSCLC',
+            stage: 'IV',
+            histology: 'Adenocarcinoma'
+        }, {
+            age: 62,
+            gender: 'male',
+            performanceStatus: 1,
+            comorbidities: ['Hypertension'],
+            priorTreatments: ['Osimertinib']
+        }, {
+            mutations: ['EGFR'],
+            msiStatus: 'MSS',
+            tmbScore: 12,
+            immuneScore: 'Hot',
+            pdl1TPS: 60
+        });
+        return {
+            summary: `Universal cure status ${result.status}`,
+            metrics: {
+                cureProbability: formatPercent(result.cureProbability),
+                primaryStrategy: result.treatmentPlan.primaryStrategy,
+                trialMatches: result.clinicalTrialMatches.highPriority.length +
+                    result.clinicalTrialMatches.alternatives.length +
+                    result.clinicalTrialMatches.emergingTrials.length
+            }
+        };
+    });
+}
+async function runGlobalCoverage() {
+    return runToolAction('global-coverage', async () => {
+        const module = new GlobalCancerCoverageModule();
+        const stats = module.getCoverageStatistics();
+        return {
+            summary: `Guidelines ${stats.totalGlobalGuidelines}`,
+            metrics: {
+                guidelines: stats.totalGlobalGuidelines,
+                regions: stats.regionsRepresented.join(', '),
+                rareCancers: stats.totalRareCancers,
+                pediatricProtocols: stats.totalPediatricProtocols,
+                supportiveCare: stats.totalSupportiveCareProtocols,
+                specialPopulations: stats.totalSpecialPopulations
+            }
+        };
+    });
+}
+async function runTreatmentSequencing() {
+    return runToolAction('treatment-sequencing', async () => {
+        const engine = new TreatmentSequencingEngine();
+        const recommendations = engine.getNextLineRecommendation('NSCLC', 'EGFR-mutant (exon 19 del or L858R)', '1L', ['nsclc-egfr-1l-osi'], { 'EGFR exon 19 del or L858R': 'positive' });
+        return {
+            summary: `Next-line regimens ${recommendations.length}`,
+            metrics: {
+                recommendations: recommendations.length,
+                topRegimen: recommendations[0]?.name || 'none'
+            }
+        };
+    });
+}
+async function runPrecisionMedicine() {
+    return runToolAction('precision-medicine', async () => {
+        const engine = new PrecisionMedicineEngine();
+        const report = engine.generatePrecisionReport(SAMPLE_PATIENT_ID, [
+            { gene: 'EGFR', alteration: 'L858R', type: 'mutation' },
+            { gene: 'PIK3CA', alteration: 'E545K', type: 'mutation' }
+        ], ['DPYD']);
+        return {
+            summary: report.summary,
+            metrics: {
+                actionableTargets: report.actionableTargets.length,
+                pharmacogenomics: report.pgxRecommendations.length,
+                clinicalTrialTargets: report.clinicalTrialTargets.length
+            }
+        };
+    });
+}
+async function runEmergingTherapeutics() {
+    return runToolAction('emerging-therapeutics', async () => {
+        const module = new EmergingTherapeuticsModule();
+        const stats = module.getStatistics();
+        return {
+            summary: `Emerging targets ${stats.totalNovelTargets}`,
+            metrics: {
+                cellularTherapies: stats.totalCellularTherapies,
+                proteinDegraders: stats.totalProteinDegraders,
+                radiopharmaceuticals: stats.totalRadiopharmaceuticals,
+                novelTargets: stats.totalNovelTargets,
+                aiDrugs: stats.totalAIDrugs,
+                stageBreakdown: JSON.stringify(stats.breakdownByStage)
+            }
+        };
+    });
+}
+async function runMultimodalOncology() {
+    return runToolAction('multimodal-oncology', async () => {
+        const engine = new MultimodalOncologyEngine();
+        const sequence = engine.getMultimodalSequence('HER2+ Breast Cancer', 'Stage II-III');
+        const bed = engine.calculateBED(60, 30, 10);
+        return {
+            summary: sequence ? `Sequence found for ${sequence.cancerType}` : 'Sequence not found',
+            metrics: {
+                sequencePhases: sequence ? sequence.sequence.length : 0,
+                bed: formatNumber(bed)
+            }
+        };
+    });
+}
+async function runSpecialPopulations() {
+    return runToolAction('special-populations', async () => {
+        const engine = new SpecialPopulationsEngine();
+        const pediatric = engine.calculatePediatricDose('Vincristine', 18, 110, 6);
+        const geriatric = engine.performGeriatricAssessment({
+            adl: 4,
+            iadl: 5,
+            comorbidity: 2
+        });
+        return {
+            summary: `Pediatric dose ${pediatric.dose}`,
+            metrics: {
+                pediatricDose: pediatric.dose,
+                geriatricRisk: geriatric.riskCategory,
+                monitoringItems: pediatric.monitoring.length
+            }
+        };
+    });
+}
+async function runResistanceManagement() {
+    return runToolAction('resistance-management', async () => {
+        const engine = new ResistanceManagementEngine();
+        const analysis = engine.analyzeResistance('Osimertinib', 'EGFR', 'T790M', { age: 63, ps: 1, priorLines: 1 });
+        const prevention = engine.generatePreventionPlan('NSCLC', 'EGFR TKI', ['EGFR']);
+        return {
+            summary: `Resistance urgency ${analysis.urgency}`,
+            metrics: {
+                strategies: analysis.recommendedStrategies.length,
+                preventionStrategies: prevention.strategies.length,
+                combinationOptions: prevention.combinationOptions.length
+            }
+        };
+    });
+}
+async function runCureVerification() {
+    return runToolAction('cure-verification', async () => {
+        const engine = new CureVerificationEngine();
+        const result = engine.verifyCureStatus('Breast Cancer', 24, 'CR', 'negative', 'undetectable', 18, 18);
+        return {
+            summary: `Verification ${result.status}`,
+            metrics: {
+                confidence: formatPercent(result.confidence),
+                evidenceItems: result.evidence.length
+            }
+        };
+    });
+}
+async function runCureValidation() {
+    return runToolAction('cure-validation', async () => {
+        const framework = new CureValidationFramework();
+        const report = await framework.validateCoverageCompleteness();
+        return {
+            summary: `Coverage ${formatNumber(report.coveragePercentage)}%`,
+            metrics: {
+                totalCancerTypes: report.totalCancerTypes,
+                coveredCancerTypes: report.coveredCancerTypes,
+                coveragePercent: `${formatNumber(report.coveragePercentage)}%`,
+                gapCount: report.gaps.length
+            }
+        };
+    });
+}
+async function runClinicalTrialMatching() {
+    return runToolAction('clinical-trial-matching', async () => {
+        const engine = new ClinicalTrialMatchingEngine();
+        const matches = engine.findMatchingTrials(createSampleTrialProfile());
+        const topMatch = matches[0];
+        return {
+            summary: `Matches ${matches.length}`,
+            metrics: {
+                matches: matches.length,
+                topTrial: topMatch?.trial?.nctId || 'none',
+                topScore: topMatch ? formatNumber(topMatch.matchScore) : 0
+            }
+        };
+    });
+}
+async function runPalliativeCare() {
+    return runToolAction('palliative-care', async () => {
+        const engine = new PalliativeCareEngine();
+        const protocol = engine.assessPain(createSamplePainAssessment());
+        const conversion = engine.calculateOpioidConversion('Morphine', 30, 'PO', 'Oxycodone', 'PO');
+        return {
+            summary: protocol ? `Pain protocol ${protocol.severity}` : 'No pain protocol matched',
+            metrics: {
+                severity: protocol?.severity || 'unknown',
+                opioidConversionDose: conversion.dose,
+                conversionNotes: conversion.notes.length
+            }
+        };
+    });
+}
+async function runEmergencyOncology() {
+    return runToolAction('emergency-oncology', async () => {
+        const engine = new EmergencyOncologyEngine();
+        const matches = engine.identifyPotentialEmergency(['Back pain', 'Weakness', 'Urinary retention'], { calcium: 13.2, potassium: 6.1 });
+        const top = matches[0];
+        return {
+            summary: `Potential emergencies ${matches.length}`,
+            metrics: {
+                matches: matches.length,
+                topEmergency: top?.name || 'none',
+                topUrgency: top?.urgency || 'n/a'
+            }
+        };
+    });
+}
+async function runSurvivorshipCare() {
+    return runToolAction('survivorship-care', async () => {
+        const engine = new SurvivorshipCareEngine();
+        const sample = createSampleTreatmentSummary();
+        const plan = engine.generateSurvivorshipCarePlan(sample.cancerType, sample.stage, sample.summary);
+        return {
+            summary: `Survivorship plan for ${plan.cancerType}`,
+            metrics: {
+                surveillanceDuration: plan.surveillanceProtocol.duration,
+                lateEffects: plan.lateEffectsScreening.length,
+                secondaryMalignancy: plan.secondaryMalignancyScreening.length
+            }
+        };
+    });
+}
+async function runUniversalHealth() {
+    return runToolAction('universal-health', async () => {
+        const engine = new UniversalHealthEngine();
+        const plan = engine.generateHealthPlan(45, 'Male', ['hypertension'], ['smoking', 'obesity']);
+        return {
+            summary: `Health plan with ${plan.conditionManagement.length} conditions`,
+            metrics: {
+                preventiveCare: plan.preventiveCare.length,
+                conditionManagement: plan.conditionManagement.length,
+                riskModifications: plan.riskModification.length,
+                specialistReferrals: plan.specialistReferrals.length
+            }
+        };
+    });
+}
+async function runClinicalDecisionSupport() {
+    return runToolAction('clinical-decision-support', async () => {
+        const service = new ClinicalDecisionSupportService();
+        const recommendation = await service.generateRecommendation({
+            patientId: SAMPLE_PATIENT_ID,
+            cancerType: SAMPLE_CANCER_TYPE,
+            stage: SAMPLE_STAGE,
+            biomarkers: [
+                { name: 'EGFR', value: 'L858R', status: 'positive' },
+                { name: 'PD-L1', value: 60, status: 'positive' }
+            ],
+            genomicAlterations: [
+                { gene: 'EGFR', alteration: 'L858R' },
+                { gene: 'TP53', alteration: 'loss' }
+            ],
+            priorTherapies: ['Osimertinib'],
+            performanceStatus: 1,
+            comorbidities: ['Hypertension']
+        });
+        return {
+            summary: `Recommendation ${recommendation.primaryRecommendation.regimen}`,
+            metrics: {
+                primaryRegimen: recommendation.primaryRecommendation.regimen,
+                alternatives: recommendation.alternativeOptions.length,
+                responseRate: formatPercent(recommendation.predictions.responseRate.value)
+            }
+        };
+    });
+}
+async function runPatientPortal() {
+    return runToolAction('patient-portal', async () => {
+        const portal = new PatientPortalService();
+        const accountData = {
+            mrn: 'MRN-001',
+            email: 'patient@example.com',
+            preferredLanguage: 'en',
+            preferredContactMethod: 'portal',
+            accessLevel: 'full',
+            notificationPreferences: {
+                appointments: true,
+                labResults: true,
+                messages: true,
+                medications: true,
+                educational: true
+            }
+        };
+        const account = await portal.createAccount(accountData);
+        const summary = createSamplePortalSummary(account.id);
+        portal.setTreatmentSummary(summary);
+        const simple = portal.generateSimpleSummary('NSCLC', 'IV', 'Osimertinib');
+        return {
+            summary: `Portal account ${account.id}`,
+            metrics: {
+                summaryLines: simple.whatItMeans.length,
+                careTeam: summary.careTeam.length,
+                upcomingAppointments: summary.upcomingAppointments.length
+            }
+        };
+    });
+}
+async function runMLOutcome() {
+    return runToolAction('ml-outcome', async () => {
+        const predictor = new OutcomePredictorService();
+        const patient = createSamplePatientFeatures();
+        const treatment = createSampleTreatmentFeatures();
+        const response = await predictor.predictResponse(patient, treatment);
+        const survival = await predictor.predictSurvival(patient, treatment);
+        return {
+            summary: `Predicted response ${response.predictedResponse}`,
+            metrics: {
+                objectiveResponseRate: formatPercent(response.objectiveResponseRate),
+                medianPfsMonths: formatNumber(survival.pfs.median),
+                medianOsMonths: formatNumber(survival.os.median)
+            }
+        };
+    });
+}
+async function runDrugSafety() {
+    return runToolAction('drug-safety', async () => {
+        const safety = new DrugSafetyService();
+        const patient = createSampleSafetyProfile(SAMPLE_PATIENT_ID);
+        const result = await safety.performSafetyCheck(patient, [
+            { drug: 'Pembrolizumab', dose: '200mg', route: 'IV' },
+            { drug: 'Ipilimumab', dose: '3mg/kg', route: 'IV' }
+        ]);
+        return {
+            summary: `Safety risk ${result.summary.overallRisk}`,
+            metrics: {
+                criticalAlerts: result.summary.criticalAlerts,
+                highAlerts: result.summary.highAlerts,
+                overallRisk: result.summary.overallRisk
+            }
+        };
+    });
+}
+async function runHipaaCompliance() {
+    return runToolAction('hipaa-compliance', async () => {
+        const hipaa = new HIPAAComplianceService();
+        const phi = {
+            ssn: '123-45-6789',
+            dob: '1980-01-01',
+            phone: '555-123-4567',
+            address: {
+                street: '100 Main St',
+                city: 'Boston',
+                state: 'MA',
+                zip: '02115'
+            },
+            mrn: 'MRN-001',
+            genomics: { EGFR: 'L858R' }
+        };
+        const masked = hipaa.maskPHI(phi, 'clinical');
+        const encrypted = await hipaa.encryptPHI(phi);
+        const decrypted = await hipaa.decryptPHI(encrypted);
+        const checks = [
+            { name: 'mask-ssn', ok: masked.ssn !== phi.ssn, detail: String(masked.ssn) },
+            { name: 'encrypt-roundtrip', ok: decrypted.ssn === phi.ssn, detail: String(decrypted.ssn) }
+        ];
+        return {
+            summary: 'HIPAA masking/encryption complete',
+            checks,
+            metrics: {
+                encryptedFields: encrypted._encrypted ? Object.keys(encrypted._encrypted).length : 0,
+                maskedDob: String(masked.dob)
+            }
+        };
+    });
+}
+async function runRealWorldOrchestrator(context) {
+    return runToolAction('real-world-orchestrator', async () => {
+        const service = context.oncologyService ?? createRealWorldOncologyService(context.serviceConfig);
+        if (!context.oncologyService) {
+            await service.initialize();
+        }
+        const plan = await service.generateComprehensivePlan(createSampleRealWorldPatient(), 'DR-001', {
+            includeTrials: true,
+            includePredictions: true,
+            includeSafetyCheck: true
+        });
+        return {
+            summary: `Plan ${plan.planId}`,
+            metrics: {
+                status: plan.coreRecommendation.status,
+                cureConfidence: formatPercent(plan.coreRecommendation.projectedOutcome.cureConfidence),
+                ehrSource: plan.ehrData?.source || 'none'
+            }
+        };
+    });
+}
+async function runGenomicsAggregation() {
+    return runToolAction('genomics-aggregation', async () => {
+        const service = new UnifiedGenomicsService();
+        const sampleResults = buildSampleGenomicResults(SAMPLE_PATIENT_ID);
+        const mockClient = new MockGenomicClient({ platform: 'generic', apiBaseUrl: 'https://example.org' }, sampleResults);
+        service.registerClient('mock', mockClient);
+        const aggregated = await service.getAggregatedVariants(SAMPLE_PATIENT_ID);
+        const matches = await service.matchToTherapies(SAMPLE_PATIENT_ID, SAMPLE_CANCER_TYPE);
+        return {
+            summary: `Aggregated ${aggregated.variants.length} variants`,
+            metrics: {
+                variants: aggregated.variants.length,
+                cnvs: aggregated.cnvs.length,
+                fusions: aggregated.fusions.length,
+                therapyMatches: matches.length,
+                tmbStatus: aggregated.biomarkers.tmb?.status || 'unknown'
+            }
+        };
+    });
+}
+async function runEhrReadiness(context) {
+    return runToolAction('ehr-readiness', async () => {
+        const ehrConfig = context.serviceConfig?.ehr;
+        const enabled = ehrConfig?.enabled ?? false;
+        const baseUrl = process.env.FHIR_BASE_URL || ehrConfig?.baseUrl || '';
+        const clientId = process.env.FHIR_CLIENT_ID || ehrConfig?.clientId || '';
+        const clientSecret = process.env.FHIR_CLIENT_SECRET || '';
+        const checks = [
+            { name: 'ehr-enabled', ok: true, detail: enabled ? 'enabled' : 'disabled' },
+            { name: 'FHIR_BASE_URL', ok: !enabled || Boolean(baseUrl), detail: baseUrl || 'missing' },
+            { name: 'FHIR_CLIENT_ID', ok: !enabled || Boolean(clientId), detail: clientId ? 'set' : 'missing' },
+            { name: 'FHIR_CLIENT_SECRET', ok: !enabled || Boolean(clientSecret), detail: clientSecret ? 'set' : 'missing' }
+        ];
+        return {
+            summary: enabled ? 'EHR integration enabled' : 'EHR integration disabled',
+            checks,
+            metrics: {
+                vendor: ehrConfig?.vendor || 'unknown'
+            }
+        };
+    });
+}
+const CLI_TOOLS = [
+    {
+        id: 'selftest',
+        description: 'Run core capability smoke tests',
+        usage: '/tool selftest',
+        run: (context) => runSelfTestSuite(context)
+    },
+    {
+        id: 'validate',
+        description: 'Run retrospective validation on a sample cohort',
+        usage: '/tool validate',
+        run: () => runValidationSample()
+    },
+    {
+        id: 'cancer-core',
+        description: 'Summarize cancer treatment core datasets',
+        usage: '/tool cancer-core',
+        run: (context) => runCancerCore(context)
+    },
+    {
+        id: 'cancer-analyze',
+        description: 'Run sample patient analysis',
+        usage: '/tool cancer-analyze',
+        run: (context) => runCancerAnalyze(context)
+    },
+    {
+        id: 'cancer-plan',
+        description: 'Generate sample treatment plan',
+        usage: '/tool cancer-plan',
+        run: (context) => runCancerPlan(context)
+    },
+    {
+        id: 'cancer-cure',
+        description: 'Generate sample cure protocol',
+        usage: '/tool cancer-cure',
+        run: (context) => runCancerCure(context)
+    },
+    {
+        id: 'cancer-discover',
+        description: 'Run sample drug target discovery',
+        usage: '/tool cancer-discover',
+        run: (context) => runCancerDiscover(context)
+    },
+    {
+        id: 'universal-cure',
+        description: 'Run universal cancer cure engine',
+        usage: '/tool universal-cure',
+        run: () => runUniversalCure()
+    },
+    {
+        id: 'global-coverage',
+        description: 'Summarize global guideline coverage',
+        usage: '/tool global-coverage',
+        run: () => runGlobalCoverage()
+    },
+    {
+        id: 'treatment-sequencing',
+        description: 'Recommend next-line therapy sequencing',
+        usage: '/tool treatment-sequencing',
+        run: () => runTreatmentSequencing()
+    },
+    {
+        id: 'precision-medicine',
+        description: 'Generate precision medicine report',
+        usage: '/tool precision-medicine',
+        run: () => runPrecisionMedicine()
+    },
+    {
+        id: 'emerging-therapeutics',
+        description: 'Summarize emerging therapy portfolio',
+        usage: '/tool emerging-therapeutics',
+        run: () => runEmergingTherapeutics()
+    },
+    {
+        id: 'multimodal-oncology',
+        description: 'Generate multimodal oncology sample output',
+        usage: '/tool multimodal-oncology',
+        run: () => runMultimodalOncology()
+    },
+    {
+        id: 'special-populations',
+        description: 'Run pediatric/geriatric special population checks',
+        usage: '/tool special-populations',
+        run: () => runSpecialPopulations()
+    },
+    {
+        id: 'resistance-management',
+        description: 'Analyze resistance and prevention plan',
+        usage: '/tool resistance-management',
+        run: () => runResistanceManagement()
+    },
+    {
+        id: 'cure-verification',
+        description: 'Verify cure status criteria',
+        usage: '/tool cure-verification',
+        run: () => runCureVerification()
+    },
+    {
+        id: 'cure-validation',
+        description: 'Validate coverage completeness',
+        usage: '/tool cure-validation',
+        run: () => runCureValidation()
+    },
+    {
+        id: 'clinical-trial-matching',
+        description: 'Match trials against sample profile',
+        usage: '/tool clinical-trial-matching',
+        run: () => runClinicalTrialMatching()
+    },
+    {
+        id: 'palliative-care',
+        description: 'Assess pain and opioid conversion',
+        usage: '/tool palliative-care',
+        run: () => runPalliativeCare()
+    },
+    {
+        id: 'emergency-oncology',
+        description: 'Identify potential oncology emergencies',
+        usage: '/tool emergency-oncology',
+        run: () => runEmergencyOncology()
+    },
+    {
+        id: 'survivorship-care',
+        description: 'Generate survivorship care plan',
+        usage: '/tool survivorship-care',
+        run: () => runSurvivorshipCare()
+    },
+    {
+        id: 'universal-health',
+        description: 'Generate general health plan',
+        usage: '/tool universal-health',
+        run: () => runUniversalHealth()
+    },
+    {
+        id: 'clinical-decision-support',
+        description: 'Generate clinician decision support output',
+        usage: '/tool clinical-decision-support',
+        run: () => runClinicalDecisionSupport()
+    },
+    {
+        id: 'patient-portal',
+        description: 'Create patient portal artifacts',
+        usage: '/tool patient-portal',
+        run: () => runPatientPortal()
+    },
+    {
+        id: 'ml-outcome',
+        description: 'Run ML outcome prediction',
+        usage: '/tool ml-outcome',
+        run: () => runMLOutcome()
+    },
+    {
+        id: 'drug-safety',
+        description: 'Run drug safety check',
+        usage: '/tool drug-safety',
+        run: () => runDrugSafety()
+    },
+    {
+        id: 'hipaa-compliance',
+        description: 'Run HIPAA masking and encryption checks',
+        usage: '/tool hipaa-compliance',
+        run: () => runHipaaCompliance()
+    },
+    {
+        id: 'real-world-orchestrator',
+        description: 'Generate comprehensive plan via orchestrator',
+        usage: '/tool real-world-orchestrator',
+        run: (context) => runRealWorldOrchestrator(context)
+    },
+    {
+        id: 'genomics-aggregation',
+        description: 'Aggregate genomics (mock platform)',
+        usage: '/tool genomics-aggregation',
+        run: () => runGenomicsAggregation()
+    },
+    {
+        id: 'ehr-readiness',
+        description: 'Check EHR integration readiness',
+        usage: '/tool ehr-readiness',
+        run: (context) => runEhrReadiness(context)
+    }
+];
+export function listCliTools() {
+    return CLI_TOOLS;
+}
+export function getCliTool(id) {
+    return CLI_TOOLS.find(tool => tool.id === id);
+}
+//# sourceMappingURL=index.js.map