@peopl-health/nexus 5.67.0-dev.11680 → 5.67.0-dev.11889

package/lib/clinical/flags/escalationFlags.js

@@ -3,7 +3,7 @@ const runtimeConfig = require('../../config/runtimeConfig');
 const flagOn = (key) => String(runtimeConfig.get(key, 'false')).trim().toLowerCase() === 'true';
 
 function escalationUpdateModeLive() {
-  return flagOn('ESCALATION_UPDATE_MODE_LIVE');
+  return String(runtimeConfig.get('ESCALATION_UPDATE_MODE_LIVE', 'true')).trim().toLowerCase() !== 'false';
 }
 
 function escalationAssessmentLive() {

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -2,6 +2,7 @@ const { pairTriageSymptoms } = require('../helpers/triageSymptomsHelper');
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
 
 const { assembleRiskHeadline } = require('../services/riskHeadlineService');
+const { resolveNutritionPlan } = require('../services/nutritionPlanService');
 const { resolvePatientIdentity, identityError } = require('../services/patientIdentityService');
 const { Follow_Up_ID } = require('../../config/airtableConfig');
 const runtimeConfig = require('../../config/runtimeConfig');
@@ -350,7 +351,8 @@ class DefaultMemoryManager extends MemoryManager {
 
       return {
         clinicalContext: [contextParts.join('. '), riskHeadline].filter(Boolean).join('\n\n'),
-        lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente'
+        lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente',
+        nutritionPlan: await resolveNutritionPlan(data.nutricion),
       };
     } catch (error) {
       logger.error('[DefaultMemoryManager] Error getting clinical data', { error: error.message });

package/lib/clinical/memory/EnhancedMemoryManager.js

@@ -49,6 +49,7 @@ class EnhancedMemoryManager extends DefaultMemoryManager {
     return {
       clinicalContext: baseClinicalData?.clinicalContext ?? '',
       lastSymptoms: baseClinicalData?.lastSymptoms ?? '',
+      nutritionPlan: baseClinicalData?.nutritionPlan ?? '',
       patientMemories: formattedMemories,
       conversationSummaries: formattedSummaries,
     };

package/lib/clinical/providers/BaseLLMProvider.js

@@ -125,13 +125,13 @@ class BaseLLMProvider {
       assistant.toolRuntimeContext.enabledSkills = enabledSkills;
     }
 
-    const resolvedSchemas = this._resolveToolSchemas({
+    const resolvedSchemas = this._scopeOutreachDecisionTool(this._resolveToolSchemas({
       assistant, toolIds: resolvedToolIds, filtered, toolDescriptions,
-    });
+    }), isOutreach);
     const { toolChoice: flooredToolChoice, toolSchemas, narrowed } = this._applyDeliveryFloor(
       toolChoice, resolvedSchemas, Boolean(assistant?.toolRuntimeContext), turnKind);
     const effectiveToolIds = toolSchemas.map(s => s.function?.name).filter(Boolean);
-    const instructionToolIds = narrowed ? effectiveToolIds : resolvedToolIds;
+    const instructionToolIds = narrowed || isOutreach ? effectiveToolIds : resolvedToolIds;
     const requestedToolChoice = prePromptResult?.toolChoice;
     const requestedToolName = requestedToolChoice?.name || requestedToolChoice?.function?.name || null;
     const supportedGenericChoices = new Set(['auto', 'none', 'required', 'any']);
@@ -234,6 +234,17 @@ class BaseLLMProvider {
     };
   }
 
+  // The decision tool belongs to the turn kind, not to a preset: without it an outreach turn cannot
+  // close and the brief is dropped, and on any other turn it would invite a decision nobody asked for.
+  _scopeOutreachDecisionTool(schemas, isOutreach) {
+    const others = schemas.filter(s => s.function?.name !== OUTREACH_DECISION_TOOL);
+    if (!isOutreach) return others;
+    const decision = schemas.find(s => s.function?.name === OUTREACH_DECISION_TOOL)
+      || getRegistrySchemas([OUTREACH_DECISION_TOOL])[0];
+    if (!decision) throw new Error('OUTREACH_DECISION_TOOL_UNAVAILABLE');
+    return [...others, decision];
+  }
+
   _resolveToolSchemas({ assistant, toolIds, filtered, toolDescriptions }) {
     const assistantSchemas = assistant?.getToolSchemas?.() || [];
     const registrySchemas = getRegistrySchemas();
@@ -305,10 +316,10 @@ class BaseLLMProvider {
       role: 'developer',
       content: [
         '## Seguimiento, recordatorio y contingencia — no son intercambiables',
-        '- SEGUIMIENTO: tú decides volver a contactar para mantener continuidad cuando ya no falta un dato clínico que pueda cambiar el riesgo. Elige cuándo y redacta la pregunta exacta para esa persona. Usa schedulePatientReminder con reminder_type seguimiento y la utility_basis concreta. No lo programes por rutina ni por inactividad sola; cualquier actividad posterior de la paciente lo cancela y entonces respondes a lo nuevo.',
+        '- SEGUIMIENTO: tú decides volver a contactar para mantener continuidad cuando ya no falta un dato clínico que pueda cambiar el riesgo. Elige cuándo y redacta la pregunta exacta para esa persona. Usa schedulePatientReminder con reminder_type seguimiento y la utility_basis concreta. Prográmalo cuando indicaste una acción (medicamento de venta libre, autocuidado, educación) cuyo efecto se ve en 24–72 h; cuando la paciente ya dio el dato y quieres saber si el síntoma vuelve o cruza un umbral que nombraste; cuando cerraste un episodio que vale la pena revisar; o cuando tiene un evento próximo (inicio de tratamiento, cita, infusión) cuyo resultado importa. No lo programes por inactividad sola; cualquier actividad posterior de la paciente lo cancela y entonces respondes a lo nuevo.',
         '- RECORDATORIO: sólo existe si la paciente pidió explícitamente que se lo recuerdes o aceptó explícitamente tu oferta de recordárselo. Usa schedulePatientReminder con el tipo concreto (medicamento, cita, examen u otros) y exactamente a la hora que pidió. No lo adelantes para que llegue antes de una cita o tarea salvo que ella haya pedido ese adelanto. No infieras un recordatorio porque mencionó o agendó algo, ni lo uses para preguntar cómo sigue o vigilar incertidumbre clínica.',
         '- CONTINGENCIA: protege una incertidumbre clínica todavía abierta; falta un dato u observación que podría cambiar el grado, la urgencia o la conducta. Usa setContingencyPlan: la contingencia define qué se espera, cuánto silencio tolerar y, si corresponde, la escalada posterior. Nunca la sustituyas por seguimiento ni por recordatorio.',
-        'Regla de desempate: si esperas saber “cómo sigue” por continuidad, es seguimiento; si la paciente pidió explícitamente o aceptó que le recuerdes hacer algo, es recordatorio; si esperas un dato porque no tenerlo podría volver insegura la conducta, es contingencia. Una tarea acordada o agendada sin esa petición no es un recordatorio. Una contingencia activa para la misma preocupación gana y no debe cruzarse con otro seguimiento.',
+        'Regla de desempate: si esperas saber “cómo sigue” por continuidad, es seguimiento; si la paciente pidió explícitamente o aceptó que le recuerdes hacer algo, es recordatorio; si esperas un dato porque no tenerlo podría volver insegura la conducta, es contingencia. Una tarea acordada o agendada sin esa petición no es un recordatorio. Una contingencia activa gana sólo mientras siga faltando su dato; cuando la resuelves porque la paciente ya lo dio, la vigilancia que queda es un seguimiento, no una red rearmada.',
       ].join('\n'),
     }];
   }
@@ -402,7 +413,7 @@ class BaseLLMProvider {
     }
     for (const net of cancelled) {
       const plan = net?.carePlan || {};
-      parts.push(`- (este turno) ${plan.planId} — la red que vigilaba "${sanitizeInlineText(plan.concern)}" se desactivó automáticamente porque el paciente escribió. Si todavía falta un dato de la rúbrica que podría subir el grado, considera rearmarla con setContingencyPlan.`);
+      parts.push(`- (este turno) ${plan.planId} — la red que vigilaba "${sanitizeInlineText(plan.concern)}" se desactivó automáticamente porque el paciente escribió. Si todavía falta un dato de la rúbrica que podría subir el grado, considera rearmarla con setContingencyPlan. Si ya no falta ese dato y sólo quieres saber cómo sigue, programa un seguimiento (schedulePatientReminder, reminder_type seguimiento) en lugar de rearmarla.`);
     }
     if (active.length) {
       parts.push('DECISIÓN ESTE TURNO: si el mensaje del paciente responde lo que una red espera observar, llama setContingencyPlan {action: \'resolve\', plan_id: \'<plan>\', resolution_reasoning: \'…\'} o cierra el caso. Si cambió la preocupación o la ventana, usa {action: \'rearm\'}. Si el mensaje trata de otra cosa, no hagas nada con la red.');
@@ -428,6 +439,10 @@ class BaseLLMProvider {
     if (symptoms && !inPrompt.has('last_symptoms')) {
       parts.push(`## Síntomas recientes\n${symptoms}`);
     }
+    const nutritionPlan = this._clinicalText(promptVariables?.nutrition_plan, 'nutrition_plan');
+    if (nutritionPlan && !inPrompt.has('nutrition_plan')) {
+      parts.push(`## Plan de nutrición indicado por el equipo (indicado; no asumas que el paciente ya lo cumple)\n${nutritionPlan}`);
+    }
     if (parts.length === 0) return [];
     // Refreshed most turns (symptoms, risks); ahead of the history it rewrote the whole cached
     // conversation. Informational only, so it rides behind it like the clock. Directives stay in system.
@@ -510,6 +525,7 @@ class BaseLLMProvider {
       const promptVariables = {
         clinical_context: clinicalData?.clinicalContext ?? '',
         last_symptoms: clinicalData?.lastSymptoms ?? '',
+        nutrition_plan: clinicalData?.nutritionPlan ?? '',
         current_date: buildDateAnchor(),
         patient_memories: clinicalData?.patientMemories ?? '',
         conversation_summaries: clinicalData?.conversationSummaries ?? '',

package/lib/clinical/services/contingencyDispatchService.js

@@ -18,8 +18,8 @@ const ESCALATION_SILENCE_MINUTES = { stat: 120, asap: 180, urgent: 240 };
 const OPEN_CEILING_SILENCE_MINUTES = 720;
 const OPEN_CEILING_ORIGIN = 'open_ceiling';
 const OPEN_CEILING_CHECK_IN = 'Hola, quería saber cómo sigues. ¿Cómo va lo que me contaste?';
-const ESCALATION_AWAITING = 'confirmación de que el equipo la contactó, y cómo evolucionó el síntoma';
-const ESCALATION_CHECK_IN = 'Hola, quería saber cómo sigues. ¿Ya te contactó el equipo médico? ¿Cómo te sientes ahora?';
+const ESCALATION_AWAITING = 'cómo evolucionó el síntoma escalado: si empeoró, mejoró o apareció un signo de alarma';
+const ESCALATION_CHECK_IN = 'Hola, quería saber cómo sigues. ¿Cómo te sientes ahora con lo que me contaste?';
 const FIRED_STATUS_BY_STAGE = { patient: 'fired_reminder', team: 'fired_team' };
 const STATUS_RANK = { armed: 0, fired_reminder: 1, fired_team: 2 };
 const TEAM_WINDOW_FRACTION = 0.5;
@@ -302,7 +302,7 @@ async function armEscalationNet({ patientCode, urgencyLevel, symptom, suspectedC
       recipient: 'patient',
       message: String(checkIn || '').trim() || ESCALATION_CHECK_IN,
       firesAfterSilenceMinutes: silence,
-      windowReasoning: `Escalación ${urgencyLevel}: se vuelve a buscar a la paciente si no hay señal suya ni constancia de contacto del equipo.`,
+      windowReasoning: `Escalación ${urgencyLevel}: se vuelve a buscar a la paciente si no hay señal suya.`,
     },
   });
 

package/lib/clinical/services/escalationDraftService.js

@@ -10,7 +10,7 @@ const { readStructuredText } = require('../helpers/structuredTextHelper');
 const { getEscalationContext } = require('../../services/escalationContextService');
 
 const { logger } = require('../../utils/logger');
-const { safeParse } = require('../../utils/jsonUtils');
+const { arrayArg, safeParse } = require('../../utils/jsonUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
 
 const { crossSymptomIssues, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
@@ -130,9 +130,15 @@ async function generateEscalationDraft({
 
   const parsed = safeParse(readStructuredText(result), null);
   const patientMessage = trimmed(parsed?.patientMessage);
-  const blocks = parsed?.symptoms === undefined ? [parsed] : parsed.symptoms;
-  if (!Array.isArray(blocks) || !blocks.length) {
-    logger.warn('[escalationDraft] generation returned a malformed symptom list', { reviewId });
+  // The schema is not strict, so the model sometimes sends the list JSON-encoded as a string.
+  const blocks = parsed?.symptoms === undefined ? [parsed] : arrayArg(parsed.symptoms);
+  if (!blocks.length) {
+    const shape = parsed.symptoms;
+    logger.warn('[escalationDraft] generation returned a malformed symptom list', {
+      reviewId,
+      symptomsType: Array.isArray(shape) ? 'array' : typeof shape,
+      symptomsLength: Array.isArray(shape) || typeof shape === 'string' ? shape.length : null,
+    });
     return { completed: false, attempted: true, reason: 'the model returned a malformed symptoms list' };
   }
   if (parsed?.symptoms !== undefined && blocks.some((block) => !trimmed(block?.symptom))) {

package/lib/clinical/services/nutritionPlanService.js

@@ -0,0 +1,82 @@
+const { safeParse, isPlainObject } = require('../../utils/jsonUtils');
+const { logger } = require('../../utils/logger');
+const { sanitizeInlineText } = require('../../utils/sanitizerUtils');
+const { composePrompt } = require('./promptComposerService');
+
+const NUTRITION_GUIDE_PROMPT_ID = 'nutrition_plan_guide';
+const PLAN_MAX_CHARS = 1500;
+const GUIDE_MAX_CHARS = 2000;
+const ISO_DATE_RX = /^\d{4}-\d{2}-\d{2}$/;
+const GUIDE_TIMEOUT_MS = 3000;
+
+// Each line of a plan or guide is one kind of indication, so the breaks survive and only each line is flattened.
+function keepLines(text, maxChars) {
+  return String(text)
+    .split('\n')
+    .map((line) => sanitizeInlineText(line, Infinity))
+    .filter(Boolean)
+    .join('\n')
+    .slice(0, maxChars);
+}
+
+// The section arrives as {plan_vigente, revisar_el}, as a {previous, current} slot, or as either one JSON-encoded.
+function readPlanSection(section) {
+  const parsed = typeof section === 'string' ? safeParse(section, section) : section;
+  if (typeof parsed === 'string') return { text: parsed, reviewBy: null };
+  if (!isPlainObject(parsed)) return { text: '', reviewBy: null };
+  const value = parsed.plan_vigente ?? parsed.current ?? parsed.nutrition_context ?? '';
+  const inner = typeof value === 'string' ? safeParse(value, null) : value;
+  const text = isPlainObject(inner) ? inner.current ?? '' : value;
+  const reviewBy = typeof parsed.revisar_el === 'string' && ISO_DATE_RX.test(parsed.revisar_el) ? parsed.revisar_el : null;
+  return { text: typeof text === 'string' ? text : '', reviewBy };
+}
+
+let lastGuide = '';
+let guideRead = null;
+
+// One shared read; a failure keeps the last guide that was read successfully.
+function readGuide() {
+  if (guideRead) return guideRead;
+  guideRead = composePrompt({ promptId: NUTRITION_GUIDE_PROMPT_ID })
+    .then(({ resolvedPrompt }) => {
+      lastGuide = keepLines(resolvedPrompt || '', GUIDE_MAX_CHARS);
+      return lastGuide;
+    })
+    .catch((error) => {
+      logger.warn('[nutritionPlanService] nutrition guide unreadable; using the last one read', { error: error.message });
+      return lastGuide;
+    })
+    .finally(() => { guideRead = null; });
+  return guideRead;
+}
+
+// The guide only adds to the plan, so a slow read must not hold the patient's turn.
+async function loadNutritionGuide() {
+  let timer;
+  const timedOut = new Promise((resolve) => { timer = setTimeout(() => resolve(null), GUIDE_TIMEOUT_MS); });
+  const guide = await Promise.race([readGuide(), timedOut]);
+  clearTimeout(timer);
+  if (guide !== null) return guide;
+  logger.warn('[nutritionPlanService] nutrition guide read timed out; using the last one read', { timeoutMs: GUIDE_TIMEOUT_MS });
+  return lastGuide;
+}
+
+async function resolveNutritionPlan(section, { now = new Date() } = {}) {
+  const { text, reviewBy } = readPlanSection(section);
+  const plan = keepLines(text, PLAN_MAX_CHARS);
+  if (!plan) return '';
+  const expired = reviewBy && reviewBy < now.toISOString().slice(0, 10);
+  const guide = await loadNutritionGuide();
+  return [
+    plan,
+    expired ? `Fecha de revisión vencida: ${reviewBy}.` : '',
+    guide,
+  ].filter(Boolean).join('\n\n');
+}
+
+module.exports = {
+  NUTRITION_GUIDE_PROMPT_ID,
+  GUIDE_TIMEOUT_MS,
+  resolveNutritionPlan,
+  _test: { reset: () => { lastGuide = ''; guideRead = null; } },
+};

package/lib/clinical/tools/reportMedicalEscalationTool.js

@@ -19,7 +19,7 @@ const { logger } = require('../../utils/logger');
 
 const definition = {
   'name': 'reportMedicalEscalation',
-  'description': '**Does:** Escalates a MEDICAL situation to the oncology care team at a chosen urgency, with an explicit justification for the level. Covers the full medical-urgency spectrum — immediate emergencies through asynchronous team review. One-way commit; the payload is INTERNAL — the patient never sees it.\n\n**Required inputs:** `urgency_level` — the FHIR request-priority code (`stat` | `asap` | `urgent` | `routine`), `urgency_justification` (one or two sentences: why this level AND why not the tier above/below — the auditable decision record), `details` (object — `symptom` + `evidence_quote` required; pass `null` when unknown for `category`, `indicators`, `suspected_condition`, `recommended_action`).\n\n**Urgency levels:** FHIR request-priority, a RELATIVE order `routine` < `urgent` < `asap` < `stat` (priority/speed, not a fixed clock). The full per-tier rubric with clinical examples lives on the `urgency_level` input enum — read it there. Out-of-enum values are coerced to `urgent` and disclosed via `coerced_urgency` on the result.\n\n**Neurological constellation override:** TWO OR MORE of — visual change, dizziness/vertigo/loss of balance, inability to walk/stand, focal weakness/numbness, acute confusion, sudden severe headache — reported this turn or across the last 2–3 turns → escalate without a further clarifying question: `asap` by default, `stat` if there is an acute deficit (can\'t walk/stand, sphincter loss, bilateral leg weakness → possible cord compression) or any instability.\n\n**When NOT to call:**\n- Unconfirmed/unspecific symptom — ask ONE characterization question via `DeliverPatientMessage` first.\n- Active mental-health crisis — use `reportCrisis`.\n- Patient shared lab/imaging/values/files — use `reportResultsReceived`.\n- Administrative / operative matter (appointments, insurance, authorizations, letters, transport, scheduling, out-of-scope request) or a non-clinical referral (psico-oncología, paliativos, non-oncology medical) — use `reportUnresolvedRequestv2`.\n- Twice in the same turn — already committed.\n\n**After the commit:** deliver a brief `DeliverPatientMessage` matched to the level — `stat`: firm, no te muevas / 911 if alone or immobile, the team was notified; `asap`: wait 15 min for the team\'s word, then acude a urgencias (ve acompañada); `urgent`: \'es importante que te valoren hoy\' + the 15-min fallback; `routine`: warm acknowledgement that the team will review. Never confirm a diagnosis; avoid alarmist language; say the team was notified.\n\n**Returns:** a RECEIPT, not a resolution — `{urgency_level, queued_for_team, safety_net_armed, safety_net_reason, team_has_reviewed, means, follow_up}`. `safety_net_armed` is `true`/`false`/`null`, where **`null` means this urgency tier gets no automatic check-in at all** (`routine`); read `follow_up` and make the fallback explicit to the patient whenever nothing is armed. `queued_for_team` says only that the ticket was written; `team_has_reviewed` is always `false` here because nothing on this path can know otherwise. Treat the escalation as OPEN and still your responsibility for the rest of the conversation: never tell the patient the team already reviewed it, and never close the topic because this call succeeded. If `queued_for_team` is `false` the team was NOT notified — say so instead of implying they were. When your `urgency_level` was out-of-enum it is coerced to `urgent` and disclosed via `{coerced_urgency, requested_urgency_level}`. A `details.category` outside the enum is dropped to `null` and disclosed via `{coerced_category, requested_category}`.\n\n**Side effects:** Emits `MEDICAL_ESCALATION_TRIGGERED`; the runtime routes it to the team by level (pages at `stat`/`asap`, ticket at `urgent`/`routine`).',
+  'description': '**Does:** Escalates a MEDICAL situation to the oncology care team at a chosen urgency, with an explicit justification for the level. Covers the full medical-urgency spectrum — immediate emergencies through asynchronous team review. One-way commit; the payload is INTERNAL — the patient never sees it.\n\n**Required inputs:** `urgency_level` — the FHIR request-priority code (`stat` | `asap` | `urgent` | `routine`), `urgency_justification` (one or two sentences: why this level AND why not the tier above/below — the auditable decision record), `details` (object — `symptom` + `evidence_quote` required; pass `null` when unknown for `category`, `indicators`, `suspected_condition`, `recommended_action`).\n\n**Urgency levels:** FHIR request-priority, a RELATIVE order `routine` < `urgent` < `asap` < `stat` (priority/speed, not a fixed clock). The full per-tier rubric with clinical examples lives on the `urgency_level` input enum — read it there. Out-of-enum values are coerced to `urgent` and disclosed via `coerced_urgency` on the result.\n\n**Neurological constellation override:** TWO OR MORE of — visual change, dizziness/vertigo/loss of balance, inability to walk/stand, focal weakness/numbness, acute confusion, sudden severe headache — reported this turn or across the last 2–3 turns → escalate without a further clarifying question: `asap` by default, `stat` if there is an acute deficit (can\'t walk/stand, sphincter loss, bilateral leg weakness → possible cord compression) or any instability.\n\n**When NOT to call:**\n- Unconfirmed/unspecific symptom — ask ONE characterization question via `DeliverPatientMessage` first.\n- Active mental-health crisis — use `reportCrisis`.\n- Patient shared lab/imaging/values/files — use `reportResultsReceived`.\n- Administrative / operative matter (appointments, insurance, authorizations, letters, transport, scheduling, out-of-scope request) or a non-clinical referral (psico-oncología, paliativos, non-oncology medical) — use `reportUnresolvedRequestv2`.\n- Twice in the same turn for the same episode — already committed; a later datum belongs to the same open escalation.\n\n**After the commit:** the escalation does not end the conversation.\n- **Patient message** (`DeliverPatientMessage`, calm, ≤60 words): acknowledge what they told you → \'Ya avisé al equipo médico\' → ONE concrete next step → a safety net specific to THIS case (1–2 observable signs and what to do if they appear) → availability. Explain the purpose in everyday words. Reassure with the plan (\'ya le avisé al equipo médico para que lo revise\', \'vamos a darle seguimiento contigo\'), never with promises (\'no es nada\', \'no te preocupes\'). No diagnosis names, no lists of alarming symptoms, no \'grave/peligroso\', no timed fallback (\'si en 15 minutos…\'), and no promised contact time — not even \'te contactan hoy en las próximas horas\'; say what the team was asked to do (\'le pedí al equipo médico que lo revise\'), never that someone is already reviewing it, and not when they will reach out.\n- **By level:** `stat` is the ONLY level that sends the patient now — calm and unambiguous: ve a urgencias ahora, acompañado; 911 (or an ambulance) if they are alone with no one to take them, cannot move safely, or are unstable — being alone counts as unsafe transport, and they never drive themselves. Fever that is `stat`: ≥38.0 °C within 8 weeks of cytotoxic chemotherapy (or a hematologic cancer, transplant, known neutropenia), any fever within 4 weeks of CAR-T or during bispecific step-up dosing, or sepsis signs with or without fever — say it calmly: "ve a urgencias ahora y di que estás en tratamiento oncológico" (CAR-T / bispecific: call the treating center first). If you don\'t know the treatment or the last dose date, ask in the same message; unknown date on chemo counts as within the window. Fever 37.5–37.9 °C in that window with the patient well is `asap`: remeasure in 30–60 min. `asap`: do NOT lead with urgencias — it appears only in the conditional safety net (if [sign] appears or they feel much worse). `urgent`: they can stay home; urgencias only as a worsening-sign safety net. `routine`: acknowledgement, what to watch, when to write again.\n- **Keep characterizing (except `stat`):** in the same message ask the ONE question that most helps the team; in later turns keep going, one question per message, and give high-value guidance that does not prescribe (comfort measures already in their plan or indicated by the team, what to have at hand, how to monitor). Each new datum goes to the SAME open escalation, not a new one: raise the level if it makes something more serious plausible; never lower it. In `stat`, after the instruction only confirm they are on their way and accompanied.\n\n**Returns:** a RECEIPT, not a resolution — `{urgency_level, queued_for_team, safety_net_armed, safety_net_reason, team_has_reviewed, means, follow_up}`. `safety_net_armed` is `true`/`false`/`null`, where **`null` means this urgency tier gets no automatic check-in at all** (`routine`); read `follow_up` and make the fallback explicit to the patient whenever nothing is armed. `queued_for_team` says only that the ticket was written; `team_has_reviewed` is always `false` here because nothing on this path can know otherwise. Treat the escalation as OPEN and still your responsibility for the rest of the conversation: never tell the patient the team already reviewed it, and never close the topic because this call succeeded. If `queued_for_team` is `false` the team was NOT notified — say so instead of implying they were. When your `urgency_level` was out-of-enum it is coerced to `urgent` and disclosed via `{coerced_urgency, requested_urgency_level}`. A `details.category` outside the enum is dropped to `null` and disclosed via `{coerced_category, requested_category}`.\n\n**Side effects:** Emits `MEDICAL_ESCALATION_TRIGGERED`; the runtime routes it to the team by level (pages at `stat`/`asap`, ticket at `urgent`/`routine`).',
   'strict': true,
   'parameters': {
     'type': 'object',
@@ -32,13 +32,13 @@ const definition = {
           'urgent',
           'routine'
         ],
-        'description': 'Tier of medical escalation — the FHIR request-priority code (RequestPriority), a RELATIVE urgency ordered routine < urgent < asap < stat. It encodes priority / speed-of-action, NOT a fixed time window — the per-case clock is safety_gate.max_action_time_hours. 1:1 with the gate route. In urgency_justification say why this level and not the one above or below.\n- `stat` (inmediato, gate emergencia) — acción inmediata, prioridad máxima, flujo de emergencia. Inestabilidad o amenaza vital: neutropenia febril CON inestabilidad, disnea severa, alteración del estado mental, sangrado mayor, compresión medular con déficit agudo.\n- `asap` (lo antes posible, gate urgencias) — máxima prioridad NO inmediata; revisión en la primera oportunidad posible porque la demora puede crear riesgo. Complicación seria sospechada pero aún no claramente inestable: dolor que empeora rápido, riesgo de infección / neutropenia febril ESTABLE, síntoma neurológico nuevo sin déficit agudo.\n- `urgent` (urgente, gate equipo_tratante_hoy) — revisión clínica acelerada, por encima de rutina porque la demora podría importar clínicamente. Mismo día, no presencial-ahora: síntoma nuevo moderado, anormalidad de laboratorio preocupante pero estable, toxicidad de tratamiento que necesita input oportuno.\n- `routine` (rutina, sin gate o verdict suavizado) — prioridad normal, vía de atención habitual. Sin riesgo por demora: seguimiento, aclaración de medicación, síntoma >72h sin empeorar, contexto clínico desactualizado.'
+        'description': 'Tier of medical escalation — the FHIR request-priority code (RequestPriority), a RELATIVE urgency ordered routine < urgent < asap < stat. It encodes priority / speed-of-action, NOT a fixed time window — the per-case clock is safety_gate.max_action_time_hours. 1:1 with the gate route. In urgency_justification say why this level and not the one above or below.\n- `stat` (inmediato, gate emergencia) — acción inmediata, prioridad máxima, flujo de emergencia. Inestabilidad o amenaza vital: neutropenia febril CON inestabilidad, fiebre ≥38.0 °C en la ventana de quimioterapia descrita en la regla de fiebre, disnea severa, alteración del estado mental, sangrado mayor, compresión medular con déficit agudo.\n- `asap` (lo antes posible, gate urgencias) — máxima prioridad NO inmediata; objetivo interno de valoración en horas (no se le promete al paciente), porque la demora puede crear riesgo; el paciente no va a urgencias salvo que aparezca una señal de la red de seguridad. Complicación seria sospechada pero aún no claramente inestable: dolor que empeora rápido, riesgo de infección sin fiebre ≥38.0 °C en esa ventana (p. ej. 37.5–37.9 °C con el paciente bien), síntoma neurológico nuevo sin déficit agudo.\n- `urgent` (urgente, gate equipo_tratante_hoy) — objetivo interno de revisión en 24 h (no se le promete al paciente), por encima de rutina porque la demora podría importar clínicamente; el paciente puede seguir en casa con una red de seguridad: síntoma nuevo moderado, anormalidad de laboratorio preocupante pero estable, toxicidad de tratamiento que necesita input oportuno.\n- `routine` (rutina, sin gate o verdict suavizado) — prioridad normal, vía de atención habitual. Sin riesgo por demora: seguimiento, aclaración de medicación, síntoma >72h sin empeorar, contexto clínico desactualizado.'
       },
       'patient_check_in': {
         'anyOf': [
           {
             'type': 'string',
-            'description': 'Nullable. The check-in this patient receives ONLY IF they go silent for hours after this escalation — the safety net writes to them again so the thread is not lost. Write it now, for delivery later: in their voice and language, short, warm, asking how they are and whether the team reached them. Reference what they told you in their own words. NO diagnosis, NO grades or CTCAE terms, NO internal phrasing — they never see `details`. Always send the key: pass `null` when you have nothing better than the neutral fallback, which is what gets used then — a bad check-in is worse than none.'
+            'description': 'Nullable. The check-in this patient receives ONLY IF they go silent for hours after this escalation — the safety net writes to them again so the thread is not lost. Write it now, for delivery later: in their voice and language, short, warm, asking how they are and how the symptom has evolved since. Reference what they told you in their own words. NO diagnosis, NO grades or CTCAE terms, NO internal phrasing — they never see `details`. Always send the key: pass `null` when you have nothing better than the neutral fallback, which is what gets used then — a bad check-in is worse than none.'
           },
           {
             'type': 'null'

package/lib/clinical/tools/schedulePatientReminderTool.js

@@ -10,7 +10,7 @@ const { DEFAULT_TIMEZONE } = require('../../utils/scheduleUtils');
 
 const definition = {
   name: 'schedulePatientReminder',
-  description: '**Does:** Creates or updates one agent-authored WhatsApp reminder. An ordinary reminder (medication, appointment, exam, or other task) is allowed only when the patient explicitly asks for or explicitly accepts that reminder. Do not infer a reminder merely because the patient mentioned or scheduled something. Schedule it at the exact date and time the patient requested. Never move it earlier to precede an appointment or task unless the patient explicitly requested that offset. On any patient conversation—not only a triage—or on a proactive review, use reminder_type seguimiento when this turn decides both when to check in again and the exact patient-facing words. Do not schedule one by default: use it only when a later contact materially helps continuity or engagement and has a concrete utility_basis.\\n\\nA seguimiento is a lightweight engagement plan: it is capped at 600 characters, never truncated, expires 24 hours after its chosen fire time, and cannot be created while another seguimiento is active. Any patient activity cancels it.\\n\\n**When NOT to call:** when the reminder guards unresolved clinical uncertainty, use setContingencyPlan instead; that plan owns its silence window and lifecycle. Never update a contingency-owned `plan_…-patient` reminder here.\\n\\nRequired: future patient-local reminder_date, reminder_description, reminder_type, action type, reminder_id for updates, and utility_basis for seguimiento.',
+  description: '**Does:** Creates or updates one agent-authored WhatsApp reminder. An ordinary reminder (medication, appointment, exam, or other task) is allowed only when the patient explicitly asks for or explicitly accepts that reminder. Do not infer a reminder merely because the patient mentioned or scheduled something. Schedule it at the exact date and time the patient requested. Never move it earlier to precede an appointment or task unless the patient explicitly requested that offset. On any patient conversation—not only a triage—or on a proactive review, use reminder_type seguimiento when this turn decides both when to check in again and the exact patient-facing words. Schedule one whenever a later contact materially helps continuity and has a concrete utility_basis — typically: you recommended an action (OTC medication, self-care, education) whose effect shows within 24–72h; the patient already gave the deciding datum and you want to know whether the symptom comes back or crosses a threshold you named; you closed a symptom episode worth checking on; or the patient has an upcoming event (starting a treatment, an appointment, an infusion) whose outcome matters. Inactivity alone is not a basis.\\n\\nA seguimiento is a lightweight engagement plan: it is capped at 600 characters, never truncated, expires 24 hours after its chosen fire time, and cannot be created while another seguimiento is active. Any patient activity cancels it.\\n\\n**When NOT to call:** when the reminder guards unresolved clinical uncertainty, use setContingencyPlan instead; that plan owns its silence window and lifecycle. Never update a contingency-owned `plan_…-patient` reminder here.\\n\\nRequired: future patient-local reminder_date, reminder_description, reminder_type, action type, reminder_id for updates, and utility_basis for seguimiento.',
   strict: true,
   parameters: {
     type: 'object',
@@ -26,7 +26,7 @@ const definition = {
       reminder_type: {
         type: 'string',
         enum: ['medicamento', 'exámen', 'examen', 'cita', 'check_in', 'seguimiento', 'otros'],
-        description: '\'seguimiento\' = the agent chooses to contact later with an exact continuity/engagement question after clinical uncertainty is resolved; patient activity cancels it. \'medicamento\', \'cita\', \'examen\'/\'exámen\', and \'otros\' require an explicit patient request or acceptance to be reminded. A mention or scheduled event alone is insufficient. \'check_in\' is legacy compatibility; use seguimiento for new agent-owned follow-ups. Never use this tool to guard unresolved clinical uncertainty—use setContingencyPlan.',
+        description: '\'seguimiento\' = the agent chooses to contact later with an exact continuity/engagement question once no datum that could raise the grade is still missing; patient activity cancels it. \'medicamento\', \'cita\', \'examen\'/\'exámen\', and \'otros\' require an explicit patient request or acceptance to be reminded. A mention or scheduled event alone is insufficient. \'check_in\' is legacy compatibility; use seguimiento for new agent-owned follow-ups. Never use this tool to guard unresolved clinical uncertainty—use setContingencyPlan.',
       },
       reminder_action_type: {
         type: 'string',

package/lib/clinical/tools/setContingencyPlanTool.js

@@ -12,7 +12,7 @@ const MAX_PATIENT_SILENCE_MIN = 1380;
 
 const definition = {
   name: 'setContingencyPlan',
-  description: `**Does:** Manages the contingency safety net guarding an open case or cluster, selected via \`action\`. A net is a single promise: if the patient goes quiet, you write to them again.\n- \`arm\` (default): arms a new net — a CarePlan anchor plus the follow-up check-in that goes out to the patient after true silence.\n- \`resolve\`: stands an active net down because this turn's conversation addressed the guarded concern, or it is no longer clinically relevant. Requires \`plan_id\` + \`resolution_reasoning\`.\n- \`rearm\`: replaces the target's active net with this new definition (fresh silence window anchored now) — same required fields as \`arm\`. Use when new information changes the concern, window, or message.\n\n**Required inputs:** \`arm\`/\`rearm\`: \`concern\`, \`awaiting_characterization\`; at least one of \`related_case_id\` / \`related_cluster_id\`; \`patient_followup_reminder\` \`${STEP_SHAPE}\` (message + a positive \`fires_after_silence_minutes\` <= ${MAX_PATIENT_SILENCE_MIN}, plus \`window_reasoning\`: one sentence on why that wait). \`resolve\`: \`plan_id\` + \`resolution_reasoning\`.\n\n**When to call:** \`arm\` when, read against the symptom's CTCAE grade scale, a datum is still missing that could put the case at a grade above your current read. If everything needed to settle the severity is already known, do not arm. The rubric is the test, not how alarming the symptom sounds.\n- Missing information could move it from G1 to G2/G3 → arm, and wait for exactly that datum.\n- Everything needed to rule out the higher grades is already known → do not arm.\n- Serious AND fully assessed → escalate. A finished assessment needs a person, not a check-in.\n\nFind the gap in the \`grade_scale\` you graded against: which clause of the next grade up can you neither confirm nor rule out? Name that datum in \`awaiting_characterization\`, concrete enough that the next turn can tell whether their message addressed it. It usually arrives as an answer you asked for, the result of something you told the patient to do, or a threshold you named — but what qualifies it is that it moves the grade, not the form it takes. A pending detail that cannot change the grade (an administrative confirmation, a name, an appointment) is not a reason to arm. Set \`resolves_on\` to match: \`reply\` for an answer they owe, \`observation\` for an event their next message may not carry.\n\nWaiting on the care team does NOT satisfy this test — a non-routine escalation normally arms its own net, so team follow-up is not this tool's job. A \`routine\` escalation does not — it routes to the team's ticket lane and leaves no net, so on those turns the ceiling test decides on its own merits. Do not condition it on predicting whether the patient will go quiet: that cannot be known, and a net they turn out not to need never reaches them — it steps aside every time they write. \`resolve\` when the patient's message answered what the net was waiting to observe; \`rearm\` when the net's definition went stale.\n\n**When NOT to call:** \`arm\` on a target that already has an active plan (fails hard — use \`resolve\` or \`rearm\`) or whose case/cluster is closed/dissolved; \`resolve\` while the concern is still unobserved (closing the case retires its net automatically). This tool does NOT notify the care team — to reach a human, use the escalation tools.\n\n**Returns:** \`arm\`/\`rearm\` → \`{plan_id}\` (\`rearm\` adds \`superseded_plan_ids\` when it replaced a net). \`resolve\` → \`{plan_id}\`, with \`already_resolved: true\` when the net was retired earlier — an idempotent success, not an error. Fails hard with \`case_not_found_or_wrong_patient\` / \`cluster_not_found_or_wrong_patient\`, \`target_not_open\`, \`active_plan_already_exists_for_case\` / \`_for_cluster\` (arm only), \`plan_not_found_or_wrong_patient\`, \`store_failed_retry_next_turn\`, or \`stand_down_failed_retry_next_turn\`.\n\n**Side effects:** records the action on the turn trace; writes the FHIR CarePlan + patient CommunicationRequest + Provenance; arms or deactivates the dispatch row — the check-in goes out over WhatsApp only if the patient stayed silent through its window, and is pushed back each time they write. Nets also stand down when their case closes or cluster dissolves, and expire on their own after a bounded multiple of the check-in window.`,
+  description: `**Does:** Manages the contingency safety net guarding an open case or cluster, selected via \`action\`. A net is a single promise: if the patient goes quiet, you write to them again.\n- \`arm\` (default): arms a new net — a CarePlan anchor plus the follow-up check-in that goes out to the patient after true silence.\n- \`resolve\`: stands an active net down because this turn's conversation addressed the guarded concern, or it is no longer clinically relevant. Requires \`plan_id\` + \`resolution_reasoning\`.\n- \`rearm\`: replaces the target's active net with this new definition (fresh silence window anchored now) — same required fields as \`arm\`. Use when new information changes the concern, window, or message.\n\n**Required inputs:** \`arm\`/\`rearm\`: \`concern\`, \`awaiting_characterization\`; at least one of \`related_case_id\` / \`related_cluster_id\`; \`patient_followup_reminder\` \`${STEP_SHAPE}\` (message + a positive \`fires_after_silence_minutes\` <= ${MAX_PATIENT_SILENCE_MIN}, plus \`window_reasoning\`: one sentence on why that wait). \`resolve\`: \`plan_id\` + \`resolution_reasoning\`.\n\n**When to call:** \`arm\` when, read against the symptom's CTCAE grade scale, a datum is still missing that could put the case at a grade above your current read. If everything needed to settle the severity is already known, do not arm. The rubric is the test, not how alarming the symptom sounds.\n- Missing information could move it from G1 to G2/G3 → arm, and wait for exactly that datum.\n- Everything needed to rule out the higher grades is already known → do not arm.\n- Serious AND fully assessed → escalate. A finished assessment needs a person, not a check-in.\n\nFind the gap in the \`grade_scale\` you graded against: which clause of the next grade up can you neither confirm nor rule out? Name that datum in \`awaiting_characterization\`, concrete enough that the next turn can tell whether their message addressed it. It is an answer the patient still owes about the symptom as it stands now — what qualifies it is that it moves the grade, not the form it takes. A pending detail that cannot change the grade (an administrative confirmation, a name, an appointment) is not a reason to arm. Neither is a watch that starts after the patient already gave that datum — whether the symptom comes back, crosses a threshold you named, or eases with what you recommended: that is continuity, not uncertainty, so schedule a \`seguimiento\` with \`schedulePatientReminder\` instead, and do not re-arm a net you just resolved to cover it. Set \`resolves_on\` to match: \`reply\` for an answer they owe, \`observation\` for an event their next message may not carry.\n\nWaiting on the care team does NOT satisfy this test — a non-routine escalation normally arms its own net, so team follow-up is not this tool's job. A \`routine\` escalation does not — it routes to the team's ticket lane and leaves no net, so on those turns the ceiling test decides on its own merits. Do not condition it on predicting whether the patient will go quiet: that cannot be known, and a net they turn out not to need never reaches them — it steps aside every time they write. \`resolve\` when the patient's message answered what the net was waiting to observe; \`rearm\` when the net's definition went stale.\n\n**When NOT to call:** \`arm\` on a target that already has an active plan (fails hard — use \`resolve\` or \`rearm\`) or whose case/cluster is closed/dissolved; \`resolve\` while the concern is still unobserved (closing the case retires its net automatically). This tool does NOT notify the care team — to reach a human, use the escalation tools.\n\n**Returns:** \`arm\`/\`rearm\` → \`{plan_id}\` (\`rearm\` adds \`superseded_plan_ids\` when it replaced a net). \`resolve\` → \`{plan_id}\`, with \`already_resolved: true\` when the net was retired earlier — an idempotent success, not an error. Fails hard with \`case_not_found_or_wrong_patient\` / \`cluster_not_found_or_wrong_patient\`, \`target_not_open\`, \`active_plan_already_exists_for_case\` / \`_for_cluster\` (arm only), \`plan_not_found_or_wrong_patient\`, \`store_failed_retry_next_turn\`, or \`stand_down_failed_retry_next_turn\`.\n\n**Side effects:** records the action on the turn trace; writes the FHIR CarePlan + patient CommunicationRequest + Provenance; arms or deactivates the dispatch row — the check-in goes out over WhatsApp only if the patient stayed silent through its window, and is pushed back each time they write. Nets also stand down when their case closes or cluster dissolves, and expire on their own after a bounded multiple of the check-in window.`,
   strict: false,
   parameters: {
     type: 'object',
@@ -41,7 +41,7 @@ const definition = {
       },
       awaiting_characterization: {
         type: 'string',
-        description: 'The datum from the term\'s grade_scale that would rule out a grade above your current read, concrete enough that the next turn can tell whether the patient\'s message addressed it — an answer they owe (\'temperature reading\'), the result of something you asked them to do (\'whether the pain eased after the analgesic\'), or a threshold you named (\'whether the fever goes past 38.5\'). It must be able to move the grade: an administrative confirmation, a name or an appointment does not qualify, and neither does a process confirmation about the care team or a restatement of the concern.',
+        description: 'The datum from the term\'s grade_scale that would rule out a grade above your current read, concrete enough that the next turn can tell whether the patient\'s message addressed it — an answer they still owe about the current presentation (\'temperature reading\', \'whether liquids also get stuck\'). It must be able to move the grade: an administrative confirmation, a name or an appointment does not qualify, and neither does a process confirmation about the care team or a restatement of the concern. A later recurrence, threshold or response to treatment once that datum is known is a seguimiento (schedulePatientReminder), not a net.',
       },
       resolves_on: {
         type: 'string',

package/lib/eval/EvalProvider.js

@@ -75,7 +75,7 @@ class EvalProvider {
       const { messages, promptVariables, lastUserMessage, contextSource } = await this._buildContext(numero, beforeCheckpoint);
 
       const {
-        devContent, assistant, toolSchemas, resolvedPromptId, presetModelConfig, resolvedPresetId,
+        devContent, assistant, toolSchemas, resolvedPromptId, presetModelConfig, resolvedPresetId, interpolatedVariables,
       } = await this._resolvePrompt(prompt, assistantId, thread, promptVariables);
 
       const request = this._buildRequest({
@@ -83,6 +83,7 @@ class EvalProvider {
         assistantId: resolvedPromptId || assistantId,
         presetId: resolvedPresetId,
         presetModelConfig,
+        interpolatedVariables,
       });
 
       const startTime = Date.now();
@@ -116,6 +117,7 @@ class EvalProvider {
     const promptVariables = {
       clinical_context: clinicalData?.clinicalContext ?? '',
       last_symptoms: clinicalData?.lastSymptoms ?? '',
+      nutrition_plan: clinicalData?.nutritionPlan ?? '',
       current_date: buildDateAnchor(),
       patient_memories: clinicalData?.patientMemories ?? '',
       conversation_summaries: clinicalData?.conversationSummaries ?? '',
@@ -132,6 +134,7 @@ class EvalProvider {
 
   async _resolvePrompt(fallbackPrompt, assistantId, thread, promptVariables) {
     let devContent;
+    let interpolatedVariables = [];
     let resolvedPromptId = assistantId;
     let presetToolIds = null;
     let presetModelConfig = null;
@@ -142,18 +145,21 @@ class EvalProvider {
     if (this.promptSource === 'airtable' && (presetId || assistantId)) {
       const {
         resolvedPrompt, promptId, presetToolIds: toolIds, modelConfig, presetId: composedPresetId,
+        interpolatedVariables: interpolated,
       } = await composePrompt({
         presetId,
         promptId: assistantId,
         variables: promptVariables,
       });
       devContent = resolvedPrompt;
+      interpolatedVariables = interpolated || [];
       resolvedPromptId = promptId || assistantId;
       presetToolIds = toolIds;
       presetModelConfig = modelConfig || null;
       resolvedPresetId = composedPresetId || resolvedPresetId;
     } else {
       devContent = fallbackPrompt;
+      interpolatedVariables = [...new Set([...(devContent || '').matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]))];
       devContent = devContent.replace(/\{\{(\w+)\}\}/g, (_, key) => promptVariables[key] ?? '');
     }
 
@@ -190,7 +196,7 @@ class EvalProvider {
       }
     }
 
-    return { devContent, assistant, toolSchemas, resolvedPromptId, presetModelConfig, resolvedPresetId };
+    return { devContent, assistant, toolSchemas, resolvedPromptId, presetModelConfig, resolvedPresetId, interpolatedVariables };
   }
 
   _modelConfig(presetModelConfig) {
@@ -203,7 +209,7 @@ class EvalProvider {
 
   _buildRequest({
     devContent, messages, promptVariables, toolSchemas, assistant, assistantId, presetId,
-    presetModelConfig = null,
+    presetModelConfig = null, interpolatedVariables = [],
   }) {
     const convertedMessages = this.provider._convertItemsToApiFormat(messages);
 
@@ -214,7 +220,11 @@ class EvalProvider {
       ? [{ role: 'developer', content: `Usa la siguiente información que conoces del paciente para personalizar tu respuesta. Adapta tu tono, contenido o recomendaciones según estas preferencias y contexto cuando sea relevante. No menciones que tienes esta información almacenada.\n\n${memoryParts.join('\n\n')}` }]
       : [];
 
-    const input = this.provider._sanitizeInput([...memoryMessage, ...convertedMessages]);
+    // The same runtime clinical block a live turn gets (context, symptoms, nutrition plan), unless the prompt interpolates it.
+    const clinicalMessage = typeof this.provider._buildClinicalMessage === 'function'
+      ? this.provider._buildClinicalMessage(promptVariables, interpolatedVariables)
+      : [];
+    const input = this.provider._sanitizeInput([...memoryMessage, ...clinicalMessage, ...convertedMessages]);
     const isContextOnly = this.mode === 'context-only';
 
     const shouldUsePromptRegistry = !presetId && this.provider.supportsPromptRegistry && !!assistantId;

package/lib/fhir/projections/symptomCaseProjection.js

@@ -188,6 +188,13 @@ function gradeExtensions(assessment) {
   return out;
 }
 
+// Triage PRO-CTCAE Conditions share the case identifier but never carry the case status.
+function isManagedCaseCondition(resource) {
+  return resource.resourceType === 'Condition'
+    && Boolean(identifierValue(resource, SYMPTOM_CASE_SLUG))
+    && SYMPTOM_CASE_EXT.STATUS in extMap(resource);
+}
+
 function fromFhir(resources, { patientId }) {
   const byReference = new Map();
   for (const resource of resources) {
@@ -196,9 +203,7 @@ function fromFhir(resources, { patientId }) {
     }
   }
   return resources
-    .filter((resource) => resource.resourceType === 'Condition'
-      && identifierValue(resource, SYMPTOM_CASE_SLUG)
-      && SYMPTOM_CASE_EXT.STATUS in extMap(resource))
+    .filter(isManagedCaseCondition)
     .map((condition) => reconstruct(condition, byReference, patientId))
     .filter(Boolean);
 }
@@ -315,4 +320,5 @@ function reconstructCondition(condition, patientId, conditionId) {
 module.exports = {
   toFhir,
   fromFhir,
+  isManagedCaseCondition,
 };

package/lib/fhir/services/symptomCaseService.js

@@ -1,7 +1,7 @@
 const { fhirId } = require('../helpers/fhirHelper');
 const { SYMPTOM_CASE_SLUG, SYMPTOM_ASSESSMENT_SLUG, SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
 const { getFhirStore } = require('../stores/fhirStore');
-const { toFhir, fromFhir } = require('../projections/symptomCaseProjection');
+const { toFhir, fromFhir, isManagedCaseCondition } = require('../projections/symptomCaseProjection');
 const { storeResources } = require('./fhirService');
 
 async function storeSymptomCase({ patientId, managedSymptom }) {
@@ -23,7 +23,8 @@ async function readSymptomCases({ patientId, ctcaeTerm = null, status = null, in
   const reconstructed = fromFhir([...conditions, ...impressions, ...grades], { patientId });
   const records = reconstructed.filter((managed) => !status || managed.condition.clinicalStatus === status);
   if (!includeDiagnostics) return records;
-  return { records, omittedCount: Math.max(0, conditions.length - reconstructed.length) };
+  const managedCases = conditions.filter(isManagedCaseCondition).length;
+  return { records, omittedCount: Math.max(0, managedCases - reconstructed.length) };
 }
 
 module.exports = {

package/lib/index.d.ts

@@ -625,6 +625,7 @@ declare module '@peopl-health/nexus' {
   export interface ClinicalDataResult {
     clinicalContext: string;
     lastSymptoms: string;
+    nutritionPlan?: string;
     patientMemories?: string;
     conversationSummaries?: string;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "5.67.0-dev.11680",
+  "version": "5.67.0-dev.11889",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",