@peopl-health/nexus 5.9.2 → 5.10.0-dev.1021

package/lib/clinical/tools/submitSafetyGateTool.js

@@ -1,207 +0,0 @@
-const { ZodError } = require('zod');
-
-const { storeSafetyGate, safetyGateExists } = require('../../fhir');
-const {
-  RecommendationSafetyGate,
-  ESCALATION_ROUTES,
-  RED_FLAG_STATUSES,
-} = require('../../shared/dtos/RecommendationSafetyGate');
-const { logger } = require('../../utils/logger');
-
-const definition = {
-  name: 'submitSafetyGate',
-  description: '**Does:** Commits the safety-gate evaluation (red flags mapped to high-risk adverse events, urgency, escalation route) for THIS turn\'s recommendation run. Call ONCE when generating a plan. Verification arithmetic and escalation-field consistency are repaired server-side (disclosed in `auto_repairs`); only a contradictory URGENT gate is rejected — an urgent gate demands `max_action_time_hours` (1-24), an `escalation_route`, and ≥1 confirmed/partially_confirmed red flag. An urgent gate does not notify anyone by itself: escalate via reportMedicalEscalation.\n\n**Required inputs:** `urgent_under_24h`, `summary`. Per red flag in `red_flags`: `name` + `verification_status`. `max_action_time_hours` / `escalation_route` / `reason_for_escalation` apply only when urgent.\n\n**Returns:** `accepted`, `run_id`, `urgent_under_24h`, `escalation_route`, `red_flags_count`, `must_escalate_now`, `auto_repairs`.\n\n**Side effects:** persists the gate as a run-scoped FHIR RiskAssessment.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      urgent_under_24h: {
-        type: 'boolean',
-        description: 'True when the situation demands action within 24h. Requires max_action_time_hours + escalation_route + a confirmed/partially_confirmed red flag.',
-      },
-      max_action_time_hours: {
-        type: 'integer',
-        description: '1-24 when urgent_under_24h=true; null otherwise. Nulled server-side on a non-urgent gate.',
-      },
-      escalation_route: {
-        type: 'string',
-        enum: ESCALATION_ROUTES,
-        description: 'Global escalation route: emergencia | urgencias | equipo_tratante_hoy. Required when urgent; nulled otherwise.',
-      },
-      reason_for_escalation: {
-        type: 'string',
-        description: 'Why this gate escalates. Nulled server-side on a non-urgent gate.',
-      },
-      summary: {
-        type: 'string',
-        description: 'Plain-language gate summary.',
-      },
-      red_flags: {
-        type: 'array',
-        description: 'Red flags evaluated this turn. Each: `{name, verification_status, escalation_route, events_confirmed[], events_denied[], related_aes[], definition[{clinical_event, ctcae_grades_reference[]}], grounded_in[]}`. verification_status is repaired from the events (denied ⇒ denied; no confirmed events ⇒ inconclusive; confirmed but a definition clinical_event is unconfirmed ⇒ partially_confirmed).',
-        items: { type: 'object' },
-      },
-    },
-    required: ['urgent_under_24h', 'summary'],
-  },
-};
-
-const str = (value) => (typeof value === 'string' ? value : '');
-const arr = (value) => (Array.isArray(value) ? value : []);
-const strList = (value) => arr(value).map(str).filter(Boolean);
-
-function derivedStatus(redFlag) {
-  if (redFlag.eventsDenied.length) return 'denied';
-  if (!redFlag.eventsConfirmed.length) return 'inconclusive';
-  if (!['confirmed', 'partially_confirmed'].includes(redFlag.verificationStatus)) return 'partially_confirmed';
-  if (redFlag.verificationStatus === 'confirmed' && redFlag.definition.length) {
-    const confirmed = new Set(redFlag.eventsConfirmed.map((event) => event.trim()));
-    if (redFlag.definition.some((event) => !confirmed.has(event.clinicalEvent.trim()))) return 'partially_confirmed';
-  }
-  return redFlag.verificationStatus;
-}
-
-function normalizeStatus(raw) {
-  const status = str(raw).trim();
-  if (status === 'suspected') return null;
-  return RED_FLAG_STATUSES.includes(status) ? status : null;
-}
-
-function normalizeRelatedAe(raw) {
-  const probability = str(raw?.probability_given_patient).trim();
-  return {
-    ctcaeTerm: str(raw?.ctcae_term).trim(),
-    probabilityGivenPatient: ['high', 'medium', 'low'].includes(probability) ? probability : 'low',
-    whyIsRelevant: str(raw?.why_is_relevant).trim(),
-    groundedIn: strList(raw?.grounded_in),
-  };
-}
-
-function normalizeRedFlagEvent(raw) {
-  return {
-    clinicalEvent: str(raw?.clinical_event).trim(),
-    ctcaeGradesReference: arr(raw?.ctcae_grades_reference)
-      .map((grade) => Number(grade))
-      .filter(Number.isInteger),
-  };
-}
-
-function buildRedFlag(raw, repairs, index) {
-  const requested = str(raw?.verification_status).trim();
-  const base = {
-    name: str(raw?.name).trim(),
-    verificationStatus: normalizeStatus(raw?.verification_status) || 'inconclusive',
-    escalationRoute: ESCALATION_ROUTES.includes(str(raw?.escalation_route).trim()) ? str(raw.escalation_route).trim() : null,
-    eventsConfirmed: strList(raw?.events_confirmed),
-    eventsDenied: strList(raw?.events_denied),
-    relatedAes: arr(raw?.related_aes).map(normalizeRelatedAe),
-    definition: arr(raw?.definition).map(normalizeRedFlagEvent).filter((event) => event.clinicalEvent),
-    groundedIn: strList(raw?.grounded_in),
-  };
-  const want = derivedStatus(base);
-  if (want !== base.verificationStatus) {
-    repairs.push(`red_flags[${index}].verification_status: '${requested || base.verificationStatus}' → '${want}' (aritmética de eventos)`);
-    base.verificationStatus = want;
-  }
-  return base;
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return JSON.stringify({ success: false, error: 'submitSafetyGate requires an active turn context (turnId, patientCode).', data: {} });
-    }
-    if (typeof args?.urgent_under_24h !== 'boolean') {
-      return JSON.stringify({ success: false, error: 'urgent_under_24h is required and must be a boolean.', data: {} });
-    }
-    const summary = str(args?.summary).trim();
-    if (!summary) {
-      return JSON.stringify({ success: false, error: 'summary is required.', data: {} });
-    }
-
-    const repairs = [];
-    const runId = `recrun-chat-${runtime.turnId}`;
-    const redFlags = arr(args?.red_flags).map((raw, index) => buildRedFlag(raw, repairs, index));
-
-    const urgent = args.urgent_under_24h;
-    let maxActionTimeHours = Number.isInteger(args?.max_action_time_hours) ? args.max_action_time_hours : null;
-    let escalationRoute = ESCALATION_ROUTES.includes(str(args?.escalation_route).trim()) ? str(args.escalation_route).trim() : null;
-    let reasonForEscalation = str(args?.reason_for_escalation).trim() || null;
-    if (!urgent) {
-      const stray = [];
-      if (maxActionTimeHours !== null) { stray.push('max_action_time_hours'); maxActionTimeHours = null; }
-      if (escalationRoute !== null) { stray.push('escalation_route'); escalationRoute = null; }
-      if (reasonForEscalation !== null) { stray.push('reason_for_escalation'); reasonForEscalation = null; }
-      if (stray.length) repairs.push(`no urgente ⇒ anulados campos de escalamiento: ${stray.join(', ')}`);
-    }
-
-    if (urgent) {
-      const basis = redFlags.some((redFlag) => ['confirmed', 'partially_confirmed'].includes(redFlag.verificationStatus));
-      const issues = [];
-      if (maxActionTimeHours === null) issues.push('max_action_time_hours (1-24)');
-      if (!escalationRoute) issues.push(`escalation_route (${ESCALATION_ROUTES.join(' | ')})`);
-      if (!basis) issues.push('≥1 red flag confirmed/partially_confirmed');
-      if (issues.length) {
-        return JSON.stringify({ success: false, error: 'gate_inconsistent', data: { urgent_gate_requires: issues } });
-      }
-    }
-
-    if (await safetyGateExists({ runId })) {
-      return JSON.stringify({ success: false, error: 'gate_already_committed_for_turn', data: { run_id: runId } });
-    }
-
-    const safetyGate = new RecommendationSafetyGate({
-      runId,
-      patientId: runtime.patientCode,
-      origin: 'chat',
-      turnId: runtime.turnId,
-      urgentUnder24h: urgent,
-      maxActionTimeHours,
-      escalationRoute,
-      reasonForEscalation,
-      summary,
-      redFlags,
-      createdAt: new Date().toISOString(),
-    });
-
-    await storeSafetyGate({ patientId: runtime.patientCode, safetyGate });
-
-    const trace = runtime.trace || null;
-    if (trace) {
-      trace.setSignals({
-        safetyGate: {
-          runId,
-          urgentUnder24h: urgent,
-          escalationRoute,
-          redFlagsCount: redFlags.length,
-        },
-      });
-    } else {
-      logger.warn('[submitSafetyGate] no trace on runtime context; safety-gate signal not recorded', { turnId: runtime.turnId });
-    }
-
-    return JSON.stringify({
-      success: true,
-      data: {
-        accepted: true,
-        run_id: runId,
-        urgent_under_24h: urgent,
-        escalation_route: escalationRoute,
-        red_flags_count: redFlags.length,
-        must_escalate_now: urgent,
-        auto_repairs: repairs,
-      },
-    });
-  } catch (err) {
-    if (err instanceof ZodError) {
-      return JSON.stringify({ success: false, error: 'gate_schema_invalid', data: { issues: err.issues.map((issue) => ({ path: issue.path.join('.'), problem: issue.message })) } });
-    }
-    return JSON.stringify({ success: false, error: err?.message || 'submitSafetyGate failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/updatePalliativeAssessmentTool.js

@@ -1,74 +0,0 @@
-const { assessmentUid, buildAssessment } = require('../helpers/palliativeAssessmentHelper');
-const { storePalliativeAssessment, readPalliativeByTurn } = require('../../fhir');
-const { fhirId } = require('../../fhir/helpers/fhirHelper');
-
-const definition = {
-  name: 'updatePalliativeAssessment',
-  description: '**Does:** Full-replacement correction path for the Phase-1 palliative assessment — issues a NEW assessment (new `assessment_id`); it is NOT a field-level patch. The prior assessment_id is returned as `replaced_prior_assessment_id` for audit lineage.\n\n**Required inputs:** `assessment` (one object, identical shape to `submitPalliativeAssessment`).\n\n**When NOT to call:**\n- Before a Phase-1 assessment exists for the turn — returns `no_assessment_to_update`; call `submitPalliativeAssessment` first.\n\n**Returns:** `accepted`, `assessment_id` (new), `replaced_prior_assessment_id`, `turn_id`.\n\n**Side effects:** persists a replacement FHIR `ClinicalImpression` (+ a `Task` per urgent finding) + `Provenance`.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      assessment: {
-        type: 'object',
-        description: 'The corrected palliative assessment — full replacement, same shape as submitPalliativeAssessment.',
-      },
-    },
-    required: ['assessment'],
-  },
-};
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return fail('updatePalliativeAssessment requires an active turn context (turnId, patientCode).');
-    }
-    const raw = args?.assessment;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-      return fail('assessment is required (non-empty object)');
-    }
-
-    const patientId = runtime.patientCode;
-    const turnId = runtime.turnId;
-
-    const prior = await readPalliativeByTurn({ patientId, turnId });
-    if (!prior) {
-      return fail('no_assessment_to_update — call submitPalliativeAssessment first', { turn_id: turnId });
-    }
-
-    const assessment = buildAssessment({
-      raw,
-      assessmentId: assessmentUid(),
-      patientId,
-      turnId,
-      committedAt: new Date().toISOString(),
-    });
-    await storePalliativeAssessment({ patientId, assessment });
-
-    const assessmentId = fhirId(assessment.assessmentId);
-    runtime.setPalliativeAssessment({ assessmentId, turnId });
-    runtime.trace.setSignals({ palliativeAssessmentId: assessmentId });
-
-    return JSON.stringify({
-      success: true,
-      data: {
-        accepted: true,
-        assessment_id: assessmentId,
-        replaced_prior_assessment_id: fhirId(prior.assessmentId),
-        turn_id: turnId,
-      },
-    });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'updatePalliativeAssessment failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/fhir/projections/palliativeProjection.js

@@ -1,37 +0,0 @@
-const { getDeviceId } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { Task } = require('../resources/Task');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'palliativeAssessment';
-const ACTIVITY_TEXT = 'palliative-assessment';
-
-function projectPalliativeAssessment(assessment) {
-  const deviceId = getDeviceId();
-  const impression = ClinicalImpression.fromPalliativeAssessment({ assessment });
-  const tasks = assessment.findings
-    .filter((finding) => finding.escalation !== null)
-    .map((finding) => Task.fromPalliativeEscalation({
-      assessmentId: assessment.assessmentId,
-      committedAt: assessment.committedAt,
-      finding,
-      deviceId,
-    }));
-  const targetRefs = [
-    { reference: `ClinicalImpression/${fhirId(assessment.assessmentId)}` },
-    ...tasks.map((task) => ({ reference: `Task/${task.id}` })),
-  ];
-  const provenance = Provenance.fromSymptomCase({
-    provenanceId: `${assessment.assessmentId}-prov`,
-    targetRefs,
-    recordedAt: assessment.committedAt,
-    activityText: ACTIVITY_TEXT,
-  });
-  return [impression, ...tasks, provenance];
-}
-
-module.exports = {
-  projectPalliativeAssessment,
-  PROJECTOR_NAME,
-};

package/lib/fhir/projections/recommendationPlanProjection.js

@@ -1,25 +0,0 @@
-const { ClinicalImpression } = require('../resources/ClinicalImpression');
-const { CarePlan } = require('../resources/CarePlan');
-const { Task } = require('../resources/Task');
-const { Provenance } = require('../resources/Provenance');
-const { recommendationId } = require('../../shared/dtos/RecommendationPlan');
-
-const PROJECTOR_NAME = 'recommendationPlan';
-
-function projectRecommendationPlan({ plan, hasSafetyGate }) {
-  const ranked = [...plan.elements].sort((a, b) => a.rank - b.rank);
-  const taskIds = ranked.map((element) => recommendationId(plan.runId, element.rank));
-  const impression = ClinicalImpression.fromRecommendationPlan({ plan });
-  const carePlan = CarePlan.fromRecommendationPlan({ plan, taskIds, hasSafetyGate });
-  const tasks = ranked.map((element, index) => Task.fromRecommendationPlan({ plan, element, taskId: taskIds[index] }));
-  const targetRefs = [impression, carePlan, ...tasks].map(
-    (resource) => ({ reference: `${resource.resourceType}/${resource.id}` }),
-  );
-  const provenance = Provenance.fromRecommendationPlan({ plan, targetRefs });
-  return [impression, carePlan, ...tasks, provenance];
-}
-
-module.exports = {
-  projectRecommendationPlan,
-  PROJECTOR_NAME,
-};

package/lib/fhir/projections/safetyGateProjection.js

@@ -1,16 +0,0 @@
-const { RiskAssessment } = require('../resources/RiskAssessment');
-const { Provenance } = require('../resources/Provenance');
-
-const PROJECTOR_NAME = 'safetyGate';
-
-function projectSafetyGate(gate) {
-  return [
-    RiskAssessment.fromSafetyGate({ gate }),
-    Provenance.fromSafetyGate({ gate }),
-  ];
-}
-
-module.exports = {
-  projectSafetyGate,
-  PROJECTOR_NAME,
-};

package/lib/fhir/services/palliativeService.js

@@ -1,121 +0,0 @@
-const { ZodError } = require('zod');
-
-const { fhirId } = require('../helpers/fhirHelper');
-const { extMap, extValues, identifierValue } = require('../helpers/fhirReadHelper');
-const { PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
-const { PROJECTOR_NAME } = require('../projections/palliativeProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { PalliativeAssessment } = require('../../shared/dtos/PalliativeAssessment');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-async function storePalliativeAssessment({ patientId, assessment }) {
-  if (assessment.patientId !== patientId) {
-    throw new Error(`storePalliativeAssessment patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: assessment }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function readPalliativeByTurn({ patientId, turnId }) {
-  const store = getFhirStore();
-  const impression = await findImpression(store, patientId, turnId);
-  if (!impression) return null;
-  const assessmentId = identifierValue(impression, PALLIATIVE_ASSESSMENT_SLUG);
-  const provenance = await store.getByReference(`Provenance/${fhirId(`${assessmentId}-prov`)}`);
-  if (!provenance) return null;
-  return reconstruct(store, impression, provenance, patientId, turnId);
-}
-
-async function findImpression(store, patientId, turnId) {
-  const patient = `Patient/${fhirId(patientId)}`;
-  const impressions = (await store.find({ patient, resourceType: 'ClinicalImpression' }))
-    .filter((resource) => identifierValue(resource, PALLIATIVE_ASSESSMENT_SLUG));
-  return impressions.find((impression) => extMap(impression)['palliative-turn-id'] === turnId) || null;
-}
-
-async function reconstruct(store, impression, provenance, patientId, turnId) {
-  const assessmentId = identifierValue(impression, PALLIATIVE_ASSESSMENT_SLUG);
-  const escalations = await readEscalations(store, provenance, patientId);
-  try {
-    return new PalliativeAssessment({
-      assessmentId,
-      patientId,
-      turnId,
-      committedAt: impression.effectiveDateTime,
-      evaluationSummary: impression.summary || '',
-      rankingRationale: impression.description || '',
-      escalationReason: (impression.note && impression.note[0] && impression.note[0].text) || null,
-      findings: (impression.finding || []).map((finding) => reconstructFinding(finding, escalations)),
-    });
-  } catch (error) {
-    if (error instanceof ZodError) {
-      logger.warn({ assessmentId: impression.id }, 'skipping malformed palliative ClinicalImpression');
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function readEscalations(store, provenance, patientId) {
-  const taskRefs = ((provenance && provenance.target) || [])
-    .map((target) => target.reference)
-    .filter((ref) => ref && ref.startsWith('Task/'));
-  const byRank = {};
-  for (const ref of taskRefs) {
-    const task = await store.getByReference(ref);
-    if (!task) continue;
-    const rank = extMap(task)['palliative-escalation-rank'];
-    if (rank === undefined || rank === null) continue;
-    byRank[rank] = reconstructEscalation(task, patientId);
-  }
-  return byRank;
-}
-
-function reconstructFinding(finding, escalations) {
-  const ext = extMap(finding);
-  const nameShort = ccText(finding.item && finding.item.concept);
-  const rank = ext['palliative-finding-rank'];
-  return {
-    rank,
-    elementType: ext['palliative-finding-element-type'],
-    nameShort,
-    timeWindow: ext['palliative-finding-time-window'] || '',
-    symptomTerms: extValues(finding, 'palliative-finding-symptom-term'),
-    clinicalDescription: ext['palliative-finding-clinical-description'] || '',
-    whyRelevant: ext['palliative-finding-why-relevant'] || '',
-    qolImpact: ext['palliative-finding-qol-impact'] || null,
-    qolCriteria: ext['palliative-finding-qol-criteria'] || '',
-    improvementCapacity: ext['palliative-finding-improvement-capacity'] || null,
-    improvementCriteria: ext['palliative-finding-improvement-criteria'] || '',
-    areMedsNeeded: ext['palliative-finding-are-meds-needed'] ?? null,
-    needsCharacterization: ext['palliative-finding-needs-characterization'] ?? null,
-    characterizationCriteria: ext['palliative-finding-characterization-criteria'] || '',
-    probeQuestions: extValues(finding, 'palliative-finding-probe-question'),
-    auditNotes: ext['palliative-finding-audit-notes'] || '',
-    clusterNote: ext['palliative-finding-cluster-note'] ?? null,
-    escalation: escalations[rank] || null,
-  };
-}
-
-function reconstructEscalation(task, patientId) {
-  const end = task.restriction && task.restriction.period && task.restriction.period.end;
-  const hours = end
-    ? Math.round((new Date(end).getTime() - new Date(task.authoredOn).getTime()) / 3600000)
-    : 24;
-  return {
-    patientId,
-    maxActionTimeHours: hours,
-    escalationRoutes: (task.requestedPerformer || []).map((performer) => ccText(performer.concept)),
-    escalationReason: task.description || '',
-  };
-}
-
-const ccText = (concept) => (concept && concept.text) || null;
-
-module.exports = {
-  storePalliativeAssessment,
-  readPalliativeByTurn,
-};

package/lib/fhir/services/recommendationService.js

@@ -1,27 +0,0 @@
-const { fhirId } = require('../helpers/fhirHelper');
-const { PROJECTOR_NAME } = require('../projections/recommendationPlanProjection');
-const { getFhirStore } = require('../stores/fhirStore');
-const { project, storeResources } = require('./fhirService');
-
-async function storeRecommendationPlan({ patientId, plan }) {
-  if (plan.patientId !== patientId) {
-    throw new Error(`storeRecommendationPlan patientId mismatch: expected ${patientId}`);
-  }
-  const store = getFhirStore();
-  const gate = await store.getByReference(`RiskAssessment/${fhirId(`${plan.runId}-safety`)}`);
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: { plan, hasSafetyGate: Boolean(gate) } }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function recommendationPlanExists({ runId }) {
-  const store = getFhirStore();
-  const resource = await store.getByReference(`Provenance/${fhirId(`${runId}-careplan-prov`)}`);
-  return Boolean(resource);
-}
-
-module.exports = {
-  storeRecommendationPlan,
-  recommendationPlanExists,
-};

package/lib/shared/dtos/PalliativeAssessment.js

@@ -1,62 +0,0 @@
-const { z } = require('zod');
-
-const { BaseDto } = require('./BaseDto');
-
-const dateTime = z.iso.datetime({ offset: true });
-
-const escalationSchema = z.strictObject({
-  patientId: z.string(),
-  maxActionTimeHours: z.number().int().min(1).max(24),
-  escalationRoutes: z.array(z.string()).default([]),
-  escalationReason: z.string(),
-});
-
-const findingSchema = z.strictObject({
-  rank: z.number().int().min(1),
-  elementType: z.enum(['cluster', 'individual']),
-  nameShort: z.string().min(1),
-  timeWindow: z.string().default(''),
-  symptomTerms: z.array(z.string()).default([]),
-  clinicalDescription: z.string().default(''),
-  whyRelevant: z.string().default(''),
-  qolImpact: z.enum(['Low', 'Medium', 'High']).nullable().default(null),
-  qolCriteria: z.string().default(''),
-  improvementCapacity: z.enum(['Low', 'Medium', 'High']).nullable().default(null),
-  improvementCriteria: z.string().default(''),
-  areMedsNeeded: z.boolean().nullable().default(null),
-  needsCharacterization: z.boolean().nullable().default(null),
-  characterizationCriteria: z.string().default(''),
-  probeQuestions: z.array(z.string()).default([]),
-  auditNotes: z.string().default(''),
-  clusterNote: z.string().nullable().default(null),
-  escalation: escalationSchema.nullable().default(null),
-});
-
-const schema = z.strictObject({
-  schemaVersion: z.string().default('1'),
-  assessmentId: z.string(),
-  patientId: z.string(),
-  turnId: z.string(),
-  committedAt: dateTime,
-  evaluationSummary: z.string().default(''),
-  rankingRationale: z.string().default(''),
-  escalationReason: z.string().nullable().default(null),
-  findings: z.array(findingSchema).default([]).refine(hasContiguousRanks, {
-    message: 'findings ranks must be unique and contiguous 1..N',
-  }),
-});
-
-function hasContiguousRanks(findings) {
-  const ranks = new Set(findings.map((finding) => finding.rank));
-  if (ranks.size !== findings.length) return false;
-  for (let expected = 1; expected <= findings.length; expected += 1) {
-    if (!ranks.has(expected)) return false;
-  }
-  return true;
-}
-
-class PalliativeAssessment extends BaseDto {}
-
-PalliativeAssessment.schema = schema;
-
-module.exports = { PalliativeAssessment };

package/lib/shared/dtos/RecommendationPlan.js

@@ -1,109 +0,0 @@
-const { z } = require('zod');
-
-const { BaseDto } = require('./BaseDto');
-
-const dateTime = z.iso.datetime({ offset: true });
-
-const ELEMENT_TYPES = ['cluster', 'individual'];
-const SYMPTOM_STATUSES = ['confirmed', 'suspected', 'denied'];
-const PALLIATIVE_ROUTES = ['equipo_medico_tratante', 'abordaje_onco_nutricion', 'abordaje_psico_onco'];
-const QOL_CATEGORIES = ['low', 'moderate', 'high'];
-const EFFECTIVENESS = ['low', 'medium', 'high'];
-const FOLLOWUP_TYPES = ['checkin_48h', 'team_referral', 'none'];
-
-const symptomSchema = z.strictObject({
-  ctcaeTerm: z.string(),
-  grade: z.number().int().min(1).max(5).nullable().default(null),
-  verificationStatus: z.enum(SYMPTOM_STATUSES),
-});
-
-const escalationSchema = z.strictObject({
-  urgentUnder24h: z.boolean().default(false),
-  maxActionTimeHours: z.number().int().min(1).max(24).nullable().default(null),
-  routes: z.array(z.enum(PALLIATIVE_ROUTES)).default([]),
-  clinicalCriteria: z.string().nullable().default(null),
-});
-
-const otcOfferSchema = z.strictObject({
-  label: z.string(),
-  dose: z.string().nullable().default(null),
-  frequency: z.string().nullable().default(null),
-  duration: z.string().nullable().default(null),
-  warnings: z.string().nullable().default(null),
-});
-
-const patientSchema = z.strictObject({
-  mainRecommendation: z.string(),
-  whenToEscalate: z.string().nullable().default(null),
-  contraindications: z.string().nullable().default(null),
-  expectedEffectiveness: z.enum(EFFECTIVENESS),
-});
-
-const recommendationSchema = z.strictObject({
-  symptomsPatientFacing: z.array(z.string()).min(1).max(6),
-  isPharmacologicalMedNeeded: z.boolean(),
-  patient: patientSchema,
-  otcOffer: otcOfferSchema.nullable().default(null),
-  followup: z.enum(FOLLOWUP_TYPES).nullable().default(null),
-  followupUrgency: z.string().nullable().default(null),
-});
-
-const elementSchema = z.strictObject({
-  rank: z.number().int().min(1),
-  type: z.enum(ELEMENT_TYPES),
-  nameShort: z.string(),
-  timeWindow: z.string().nullable().default(null),
-  symptoms: z.array(symptomSchema).default([]),
-  targetedCtcaeTerms: z.array(z.string()).min(1),
-  whyRelevant: z.string(),
-  qolImpact: z.enum(QOL_CATEGORIES).nullable().default(null),
-  improvementCapacity: z.enum(QOL_CATEGORIES).nullable().default(null),
-  escalation: escalationSchema,
-  recommendation: recommendationSchema,
-  groundedIn: z.array(z.string()).default([]),
-});
-
-const takeawaysSchema = z.strictObject({
-  safetyConfirmationNeeded: z.boolean().default(false),
-  safetyConfirmationQuestion: z.string().nullable().default(null),
-  vitalRiskPossibleNow: z.boolean().default(false),
-  summaryPatientFacing: z.string(),
-  summaryInternal: z.string(),
-})
-  .refine(
-    (t) => !t.safetyConfirmationNeeded || Boolean(t.safetyConfirmationQuestion && t.safetyConfirmationQuestion.trim()),
-    { path: ['safetyConfirmationQuestion'], message: 'safetyConfirmationNeeded=true ⇒ exactamente 1 pregunta cerrada' },
-  )
-  .refine(
-    (t) => t.safetyConfirmationNeeded || !t.safetyConfirmationQuestion,
-    { path: ['safetyConfirmationQuestion'], message: 'safetyConfirmationNeeded=false ⇒ null' },
-  );
-
-const schema = z.strictObject({
-  schemaVersion: z.string().default('1'),
-  runId: z.string(),
-  patientId: z.string(),
-  origin: z.enum(['chat', 'triage']).default('chat'),
-  turnId: z.string(),
-  takeaways: takeawaysSchema,
-  elements: z.array(elementSchema).min(1),
-  createdAt: dateTime,
-});
-
-class RecommendationPlan extends BaseDto {}
-
-RecommendationPlan.schema = schema;
-
-const FHIR_ID_MAX = 64;
-
-const fhirSafe = (value) => String(value).replace(/[^A-Za-z0-9.-]/g, '-');
-
-const recommendationId = (runId, rank) => {
-  const suffix = `-rec${fhirSafe(rank)}`;
-  return `${fhirSafe(runId).slice(0, FHIR_ID_MAX - suffix.length)}${suffix}`;
-};
-
-module.exports = {
-  RecommendationPlan,
-  recommendationId,
-};