@peopl-health/nexus 5.71.2 → 5.71.4

package/lib/clinical/flags/clinicalContextFlags.js

@@ -10,6 +10,10 @@ function contextVerifierLive() {
   return flagOn('CLINICAL_CONTEXT_VERIFIER_LIVE');
 }
 
+function chemoContextLive() {
+  return flagOn('CHEMO_CONTEXT_LIVE');
+}
+
 function profileFromMongo() {
   return flagOn('PATIENT_PROFILE_FROM_MONGO');
 }
@@ -23,6 +27,7 @@ function contextMirrorLive() {
 }
 
 module.exports = {
+  chemoContextLive,
   contextReadLive,
   contextMirrorLive,
   contextVerifierLive,

package/lib/clinical/helpers/chemoContextHelper.js

@@ -0,0 +1,165 @@
+const { mexicoDay } = require('../../utils/dateUtils');
+const { foldAccents } = require('../../utils/formatUtils');
+const { safeParse, isPlainObject } = require('../../utils/jsonUtils');
+const { logger } = require('../../utils/logger');
+
+const ACTIVE_DAYS = 35;
+const HEADER = 'Quimioterapia (registro de la unidad de quimioterapia; úsalo para contextualizar y priorizar síntomas, nunca para bajar la urgencia; no comuniques dosis ni ajustes de tratamiento; si el paciente dice otra cosa, créele y avisa al equipo)';
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+const NO_ALLERGY = /^(ninguna?s?|no|negadas?|desconocidas?|(niega|no refiere|sin|no tiene|no presenta) alergias?( conocidas| a medicamentos)?)$/;
+const NEGATION = /\b(sin|niega|no|ninguna?)\b/;
+
+const isDay = (value) => typeof value === 'string' && ISO_DAY.test(value) && !Number.isNaN(Date.parse(`${value}T00:00:00Z`));
+const dmy = (iso) => `${iso.slice(8, 10)}/${iso.slice(5, 7)}/${iso.slice(0, 4)}`;
+const daysBetween = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86400000);
+const addDays = (iso, days) => new Date(Date.parse(`${iso}T00:00:00Z`) + days * 86400000).toISOString().slice(0, 10);
+const fold = (value) => foldAccents(String(value || '')).toLowerCase().trim();
+const text = (value) => (typeof value === 'string' ? value.trim() : '');
+const list = (value) => (Array.isArray(value) ? value : []);
+const texts = (value) => list(value).map(text).filter(Boolean);
+const dayOr = (value) => (isDay(value) ? value : null);
+
+function normalize(raw) {
+  const last = isPlainObject(raw.ultimaAplicacion) && isDay(raw.ultimaAplicacion.fecha) ? raw.ultimaAplicacion : null;
+  const nadir = Array.isArray(raw.nadirDias) && raw.nadirDias.length === 2 && raw.nadirDias.every(Number.isInteger) ? raw.nadirDias : null;
+  const dated = (value, keys) => (isPlainObject(value) && isDay(value.fecha) && keys.every((k) => k in value) ? value : null);
+  return {
+    ultimaAplicacion: last,
+    esquema: list(raw.esquema).filter(isPlainObject).filter((e) => text(e.farmaco)),
+    vigilancia: texts(raw.vigilancia),
+    nadirDias: nadir,
+    premedicacion: texts(raw.premedicacion),
+    enCasa: list(raw.enCasa).filter(isPlainObject).filter((m) => text(m.farmaco)),
+    inicioEsquema: dated(raw.inicioEsquema, ['anteriorAlRegistro']),
+    proximaSesion: dated(raw.proximaSesion, ['tipo']),
+    noAplicadas: list(raw.noAplicadas).filter(isDay),
+    reaccionInfusion: dated(raw.reaccionInfusion, ['texto']),
+    alergias: dated(raw.alergias, ['estado', 'texto']),
+    acceso: text(raw.acceso),
+    peso: dated(raw.peso, ['kg']),
+    signosAnormales: dated(raw.signosAnormales, ['hallazgos']),
+    ajusteProximoCiclo: dated(raw.ajusteProximoCiclo, ['valor']),
+    esquemaPrevio: isPlainObject(raw.esquemaPrevio) && isDay(raw.esquemaPrevio.hasta) ? { farmacos: texts(raw.esquemaPrevio.farmacos), hasta: raw.esquemaPrevio.hasta } : null,
+    visitaSoporte: dated(raw.visitaSoporte, ['farmacos']),
+    antecedentes: dated(raw.antecedentes, []),
+  };
+}
+
+function parseChemoContext(raw) {
+  const parsed = safeParse(raw, null);
+  return isPlainObject(parsed) && parsed.version === 1 ? normalize(parsed) : null;
+}
+
+function chemoStatus(context, today) {
+  const last = context.ultimaAplicacion?.fecha;
+  if (!last) return { active: false, days: null };
+  const days = daysBetween(last, today);
+  if (days < 0) return { active: true, days: null };
+  const scheduled = context.proximaSesion && context.proximaSesion.fecha >= today;
+  return { active: days <= ACTIVE_DAYS || Boolean(scheduled), days };
+}
+
+function regimenText(context) {
+  return context.esquema.map((e) => [e.farmaco, e.via, e.tiempo].map(text).filter(Boolean).join(' ')).join('; ');
+}
+
+function statusLine(last, active, days) {
+  const cycle = [last.ciclo ? `ciclo ${last.ciclo}` : '', last.sesion ? `sesión ${last.sesion}${last.total ? `/${last.total}` : ''}` : ''].filter(Boolean).join(', ');
+  const when = days === null ? `última aplicación registrada ${dmy(last.fecha)}` : `última aplicación ${dmy(last.fecha)} (hace ${days} días)`;
+  return active
+    ? `Estado: en quimioterapia activa; ${when}${cycle ? `, ${cycle}` : ''}`
+    : `Estado: sin aplicaciones registradas en la unidad desde ${dmy(last.fecha)} (hace ${days} días); confirma con el paciente si sigue en tratamiento`;
+}
+
+function chemoLines(context, today) {
+  const lines = [];
+  const last = context.ultimaAplicacion;
+  const { active, days } = chemoStatus(context, today);
+  if (last) {
+    lines.push(statusLine(last, active, days));
+    const regimen = regimenText(context);
+    if (regimen) lines.push(`${active ? 'Esquema actual' : 'Último esquema'}: ${regimen}`);
+    if (context.vigilancia.length) lines.push(`Vigilar por sus fármacos: ${context.vigilancia.join('; ')}`);
+    if (active && days !== null && context.nadirDias && days <= context.nadirDias[1]) {
+      const [from, to] = context.nadirDias;
+      lines.push(`Mayor riesgo de defensas bajas: días ${from} a ${to} después de la aplicación (${dmy(addDays(last.fecha, from))} al ${dmy(addDays(last.fecha, to))}); hoy es el día ${days}. Fiebre de 38 °C o más es urgente cualquier día`);
+    }
+  }
+  if (context.enCasa.length) {
+    lines.push(`Se fue a casa con: ${context.enCasa.map((m) => `${text(m.farmaco)}${text(m.indicacion) ? ` (${text(m.indicacion)})` : ''}${m.esteroide ? ' [esteroide: puede ocultar la fiebre]' : ''}`).join('; ')}`);
+  }
+  if (context.premedicacion.length) lines.push(`Premedicación en la unidad: ${context.premedicacion.join(', ')}`);
+  if (context.inicioEsquema) {
+    lines.push(context.inicioEsquema.anteriorAlRegistro
+      ? `Inicio de este esquema: antes del ${dmy(context.inicioEsquema.fecha)} (inicio del registro)`
+      : `Inicio de este esquema: ${dmy(context.inicioEsquema.fecha)}`);
+  }
+  if (context.proximaSesion) {
+    lines.push(context.proximaSesion.tipo === 'agendada'
+      ? `Próxima sesión: ${dmy(context.proximaSesion.fecha)} (agendada)`
+      : `Próxima sesión: ${dmy(context.proximaSesion.fecha)} (estimada; no la confirmes como cita)`);
+  }
+  if (context.noAplicadas.length) lines.push(`Sesiones no aplicadas en los últimos 90 días: ${context.noAplicadas.map(dmy).join(', ')}`);
+  if (text(context.reaccionInfusion?.texto)) lines.push(`Reacción durante la infusión registrada: ${text(context.reaccionInfusion.texto)} (${dmy(context.reaccionInfusion.fecha)})`);
+  if (context.acceso) lines.push(`Acceso venoso: ${context.acceso}`);
+  if (Number.isFinite(context.peso?.kg)) {
+    const pct = context.peso.cambioPct;
+    const change = Number.isFinite(pct) && isDay(context.peso.desde) ? `; cambio ${pct > 0 ? '+' : ''}${pct}% desde ${dmy(context.peso.desde)}` : '';
+    lines.push(`Peso: ${context.peso.kg} kg (${dmy(context.peso.fecha)})${change}`);
+  }
+  const findings = texts(context.signosAnormales?.hallazgos);
+  if (findings.length) lines.push(`Signos fuera de rango en la última sesión (${dmy(context.signosAnormales.fecha)}): ${findings.join(', ')}`);
+  if (context.ajusteProximoCiclo?.valor === true) lines.push(`El médico indicó un ajuste para el próximo ciclo (${dmy(context.ajusteProximoCiclo.fecha)}): no lo comuniques, lo explica el médico`);
+  if (context.esquemaPrevio?.farmacos.length) lines.push(`Esquema previo: ${context.esquemaPrevio.farmacos.join(', ')}, hasta ${dmy(context.esquemaPrevio.hasta)}`);
+  if (context.visitaSoporte) {
+    const drugs = texts(context.visitaSoporte.farmacos);
+    lines.push(`Última visita a la unidad sin quimioterapia: ${dmy(context.visitaSoporte.fecha)}${drugs.length ? ` (${drugs.join(', ')})` : ''}`);
+  }
+  const h = context.antecedentes;
+  if (h) {
+    const parts = [['diabetes', h.diabetes], ['hipertensión', h.hipertension], ['otros', h.otros], ['histología', h.histologia], ['tratamiento previo', h.tratamientoPrevio]]
+      .filter(([, value]) => text(value)).map(([label, value]) => `${label}: ${text(value)}`);
+    if (parts.length) lines.push(`Antecedentes (historia de primera vez, enfermería, ${dmy(h.fecha)}): ${parts.join('; ')}`);
+  }
+  return lines;
+}
+
+function renderChemoContext(context, today = mexicoDay(new Date())) {
+  if (!context) return '';
+  try {
+    const lines = chemoLines(context, today);
+    return lines.length ? `${HEADER}:\n- ${lines.join('\n- ')}` : '';
+  } catch (error) {
+    logger.warn('[chemoContext] section left out', { error: error.message });
+    return '';
+  }
+}
+
+function listsAllergy(existing, allergy) {
+  const held = fold(existing);
+  if (NEGATION.test(held)) return false;
+  return new RegExp(`(^|[^a-z0-9])${fold(allergy).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9]|$)`).test(held);
+}
+
+function withChemoContext(clinical, context, today = mexicoDay(new Date())) {
+  if (!context) return clinical || {};
+  try {
+    const merged = { ...(clinical || {}) };
+    if (!text(merged.tratamiento_actual) && chemoStatus(context, today).active && context.esquema.length) {
+      merged.tratamiento_actual = `${regimenText(context)} (según la unidad de quimioterapia)`;
+    }
+    const allergies = context.alergias;
+    const nursing = text(allergies?.texto);
+    if (allergies?.estado === 'si' && nursing && !listsAllergy(merged.alergias_medicamentos, nursing)) {
+      const recorded = `${nursing} (registrado por enfermería, ${dmy(allergies.fecha)})`;
+      const held = text(merged.alergias_medicamentos);
+      merged.alergias_medicamentos = !held || NO_ALLERGY.test(fold(held)) ? recorded : `${held}; ${recorded}`;
+    }
+    return merged;
+  } catch (error) {
+    logger.warn('[chemoContext] merge skipped', { error: error.message });
+    return clinical || {};
+  }
+}
+
+module.exports = { parseChemoContext, renderChemoContext, withChemoContext };

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -1,10 +1,12 @@
 const { pairTriageSymptoms } = require('../helpers/triageSymptomsHelper');
+const { parseChemoContext, renderChemoContext, withChemoContext } = require('../helpers/chemoContextHelper');
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
 
 const { assembleRiskHeadline } = require('../services/riskHeadlineService');
 const { resolveNutritionPlan } = require('../services/nutritionPlanService');
 const { identityError } = require('../services/patientIdentityService');
 const { resolveProfileIdentity } = require('../services/patientProfileService');
+const { chemoContextLive } = require('../flags/clinicalContextFlags');
 const { Follow_Up_ID } = require('../../config/airtableConfig');
 const runtimeConfig = require('../../config/runtimeConfig');
 
@@ -279,13 +281,14 @@ class DefaultMemoryManager extends MemoryManager {
         ? JSON.parse(record['clinical-context-json'])
         : null;
       const treatingPhysician = sanitizeInlineText(record.doctor || '', Infinity);
+      const chemo = chemoContextLive() ? parseChemoContext(record.quimio_context) : null;
 
       const sortedSymptoms = symptomsRecords?.filter(r => r.Date)
         .sort((a, b) => new Date(b.Date) - new Date(a.Date)).slice(0, 3) || [];
 
       const symptoms = this._parseSymptoms(sortedSymptoms);
 
-      return { ...clinicalContext, symptoms, treatingPhysician };
+      return { ...clinicalContext, symptoms, treatingPhysician, chemo };
     } catch (error) {
       logger.error('[DefaultMemoryManager] Error fetching clinical context', { error: error.message });
       return null;
@@ -332,7 +335,7 @@ class DefaultMemoryManager extends MemoryManager {
 
       const contextParts = [];
       const d = data.demografia;
-      const c = data.datos_clinicos;
+      const c = withChemoContext(data.datos_clinicos, data.chemo);
       if (d?.edad) contextParts.push(`Edad: ${d.edad}`);
       if (d?.sexo) contextParts.push(`Sexo: ${d.sexo}`);
       if (data.treatingPhysician) contextParts.push(`Médico tratante: ${data.treatingPhysician}`);
@@ -351,7 +354,7 @@ class DefaultMemoryManager extends MemoryManager {
       }).filter(Boolean);
 
       return {
-        clinicalContext: [contextParts.join('. '), riskHeadline].filter(Boolean).join('\n\n'),
+        clinicalContext: [contextParts.join('. '), renderChemoContext(data.chemo), riskHeadline].filter(Boolean).join('\n\n'),
         lastSymptoms: symptomParts.join('; ') || 'Sin síntomas reportados recientemente',
         nutritionPlan: await resolveNutritionPlan(data.nutricion),
       };

package/lib/services/inboundRecoveryService.js

@@ -33,6 +33,8 @@ const ticketClaims = new WriteClaimStore({ namespace: 'inbound-recovery-ticket',
 const coldTicketClaims = new WriteClaimStore({ namespace: 'inbound-recovery-cold-ticket', ttlMs: COLD_TICKET_TTL_MS, maxSize: 2000 });
 
 const FAILED_SEND = { 'statusInfo.status': 'failed', message_id: null };
+// A holding bubble sent mid-turn, not an answer: a turn that dies after it leaves the patient waiting.
+const BRIDGE = { 'raw.bridge': true };
 const UNANSWERED_QUESTION = 'El paciente escribió y no recibió respuesta.';
 
 async function unansweredThreads(now, { minAgeMs = MIN_AGE_MS, maxAgeMs = MAX_AGE_MS, limit = SCAN_LIMIT } = {}) {
@@ -47,24 +49,26 @@ async function unansweredThreads(now, { minAgeMs = MIN_AGE_MS, maxAgeMs = MAX_AG
   ).sort({ lastMessageAt: 1 }).limit(limit).lean();
 }
 
-async function codesWithAFailedSend(now, { maxAgeMs = MAX_AGE_MS, limit = SCAN_LIMIT } = {}) {
+async function codesWithOutbound(match, now, { maxAgeMs = MAX_AGE_MS, limit = SCAN_LIMIT } = {}) {
   const rows = await aggregateMessages([
-    { $match: { ...FAILED_SEND, from_me: true, createdAt: { $gte: new Date(now.getTime() - maxAgeMs) } } },
-    { $group: { _id: '$numero', firstFailedAt: { $min: '$createdAt' } } },
+    { $match: { ...match, from_me: true, createdAt: { $gte: new Date(now.getTime() - maxAgeMs) } } },
+    { $group: { _id: '$numero', firstAt: { $min: '$createdAt' } } },
     // _id breaks the tie: without it a page of shared timestamps orders differently each pass.
-    { $sort: { firstFailedAt: 1, _id: 1 } },
+    { $sort: { firstAt: 1, _id: 1 } },
     { $limit: limit },
   ]);
   return rows.map((row) => row._id);
 }
 
-async function candidateCodes(now, { threadBand = null, failedMaxAgeMs = MAX_AGE_MS, limit = SCAN_LIMIT } = {}) {
-  const [threads, failedSends] = await Promise.all([
+async function candidateCodes(now, { threadBand = null, outboundMaxAgeMs = MAX_AGE_MS, limit = SCAN_LIMIT } = {}) {
+  const outbound = { maxAgeMs: outboundMaxAgeMs, limit };
+  const [threads, failedSends, bridges] = await Promise.all([
     unansweredThreads(now, { ...(threadBand || {}), limit }),
-    codesWithAFailedSend(now, { maxAgeMs: failedMaxAgeMs, limit }),
+    codesWithOutbound(FAILED_SEND, now, outbound),
+    codesWithOutbound(BRIDGE, now, outbound),
   ]);
-  const atCeiling = threads.length >= limit || failedSends.length >= limit;
-  const codes = [...new Set([...threads.map((thread) => thread.code), ...failedSends].filter(Boolean))];
+  const atCeiling = threads.length >= limit || failedSends.length >= limit || bridges.length >= limit;
+  const codes = [...new Set([...threads.map((thread) => thread.code), ...failedSends, ...bridges].filter(Boolean))];
   return { codes, atCeiling };
 }
 
@@ -81,7 +85,7 @@ async function stillUnanswered(code, now = new Date(), { minAgeMs = MIN_AGE_MS,
   const ageMs = now.getTime() - new Date(newest.createdAt).getTime();
   if (!Number.isFinite(ageMs) || ageMs < minAgeMs || ageMs > maxAgeMs) return null;
 
-  const replies = await countMessages({ numero: code, from_me: true, createdAt: { $gt: newest.createdAt }, $nor: [FAILED_SEND] });
+  const replies = await countMessages({ numero: code, from_me: true, createdAt: { $gt: newest.createdAt }, $nor: [FAILED_SEND, BRIDGE] });
   return replies === 0 ? newest : null;
 }
 
@@ -235,7 +239,7 @@ async function sweepColdUnansweredInbound({
   if (mode === 'off') return { waiting: 0, alerted: 0 };
 
   const { codes, atCeiling } = await candidateCodes(now, {
-    threadBand: COLD_BAND, failedMaxAgeMs: COLD_MAX_AGE_MS, limit: COLD_SCAN_LIMIT,
+    threadBand: COLD_BAND, outboundMaxAgeMs: COLD_MAX_AGE_MS, limit: COLD_SCAN_LIMIT,
   });
   // Answered conversations are filtered below, after the page is cut, so a full page is a page
   // that may be hiding patients behind it. Say so rather than let the tail go unseen quietly.

package/package.json

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