@peopl-health/nexus 5.71.1 → 5.71.3

package/lib/clinical/flags/clinicalContextFlags.js

@@ -10,12 +10,27 @@ function contextVerifierLive() {
   return flagOn('CLINICAL_CONTEXT_VERIFIER_LIVE');
 }
 
+function chemoContextLive() {
+  return flagOn('CHEMO_CONTEXT_LIVE');
+}
+
+function profileFromMongo() {
+  return flagOn('PATIENT_PROFILE_FROM_MONGO');
+}
+
+function profileSyncOn() {
+  return flagOn('PATIENT_PROFILE_SYNC');
+}
+
 function contextMirrorLive() {
   return flagOn('CLINICAL_CONTEXT_MIRROR_LIVE') && contextReadLive();
 }
 
 module.exports = {
+  chemoContextLive,
   contextReadLive,
   contextMirrorLive,
   contextVerifierLive,
+  profileFromMongo,
+  profileSyncOn,
 };

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/helpers/clinicalProfileHelper.js

@@ -1,5 +1,4 @@
-const { resolvePatientIdentity } = require('../services/patientIdentityService');
-const { Follow_Up_ID } = require('../../config/airtableConfig');
+const { resolveProfileIdentity } = require('../services/patientProfileService');
 const { safeParse } = require('../../utils/jsonUtils');
 
 const CONTEXT_FIELD = 'clinical-context-json';
@@ -35,7 +34,7 @@ function richestProfile(records) {
 
 async function readClinicalProfile(code) {
   try {
-    const identity = await resolvePatientIdentity(Follow_Up_ID, code);
+    const identity = await resolveProfileIdentity(code);
     if (identity.kind === 'missing') return null;
     if (identity.kind !== 'resolved') return undefined;
     return richestProfile([identity.record]);

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -1,9 +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 { resolvePatientIdentity, identityError } = require('../services/patientIdentityService');
+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');
 
@@ -269,7 +272,7 @@ class DefaultMemoryManager extends MemoryManager {
 
   async _getClinicalContext(whatsappId) {
     try {
-      const identity = await resolvePatientIdentity(Follow_Up_ID, whatsappId);
+      const identity = await resolveProfileIdentity(whatsappId);
       if (identity.kind === 'ambiguous') throw identityError(identity.kind);
       const record = identity.record || {};
       const symptomsRecords = await getRecordByFilter(Follow_Up_ID, 'all_triages_last_month', fieldEquals('whatsapp_id', whatsappId));
@@ -278,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;
@@ -331,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}`);
@@ -350,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/clinical/services/patientProfileService.js

@@ -0,0 +1,145 @@
+const { isShadowRun } = require('../helpers/shadowHelper');
+const { profileFromMongo } = require('../flags/clinicalContextFlags');
+const { Estado_General_ID, Follow_Up_ID } = require('../../config/airtableConfig');
+const runtimeConfig = require('../../config/runtimeConfig');
+const { MATCH_ALL } = require('../../helpers/airtableFormulaHelper');
+const { getContextSyncState } = require('../../models/contextSyncStateModel');
+const { getPatientProfile } = require('../../models/patientProfileModel');
+const { getRecordByFilter } = require('../../services/airtableService');
+const { inlineOf } = require('../../utils/coercionUtils');
+const { createIntervalSweeper } = require('../../utils/intervalSweeper');
+const { logger } = require('../../utils/logger');
+const { resolvePatientIdentity } = require('./patientIdentityService');
+
+const TABLE = 'estado_general';
+const FIELDS = ['whatsapp_id', 'clinical-context-json', 'last_modified_clinical_context', 'doctor', 'tipo', 'source', 'quimio_context'];
+const JOB = 'patient-profile';
+const MS_PER_MINUTE = 60 * 1000;
+const DEFAULT_INTERVAL_MS = 2 * MS_PER_MINUTE;
+const OVERLAP_MS = 5 * MS_PER_MINUTE;
+const RECONCILE_MS = 24 * 60 * MS_PER_MINUTE;
+const MAX_REMOVAL_SHARE = 0.05;
+const MISSING_TTL_MS = 2 * MS_PER_MINUTE;
+const missingUntil = new Map();
+
+const intervalMs = () => Number(runtimeConfig.get('PATIENT_PROFILE_SYNC_INTERVAL_MS', DEFAULT_INTERVAL_MS));
+
+function changedSince(watermark) {
+  const from = new Date(new Date(watermark).getTime() - OVERLAP_MS).toISOString();
+  return `IS_AFTER(LAST_MODIFIED_TIME(), DATETIME_PARSE('${from}'))`;
+}
+
+function toProfile(row, syncedAt) {
+  const fields = Object.fromEntries(FIELDS.filter((f) => row[f] !== undefined).map((f) => [f, row[f]]));
+  return { recordId: row._recordId, whatsappId: inlineOf(row.whatsapp_id) || null, fields, syncedAt };
+}
+
+async function readState() {
+  return (await getContextSyncState().findOne({ job: JOB }).lean()) || { job: JOB, watermark: null, fullReconciledAt: null };
+}
+
+async function saveState({ startedAt, written, reason = null, reconciled = false, advance = true }) {
+  await getContextSyncState().updateOne(
+    { job: JOB },
+    {
+      $set: { job: JOB, lastRunAt: startedAt, lastWritten: written, lastReason: reason, ...(reconciled ? { fullReconciledAt: startedAt } : {}) },
+      ...(advance ? { $max: { watermark: startedAt } } : {}),
+    },
+    { upsert: true },
+  );
+}
+
+async function upsertProfiles(rows, syncedAt) {
+  const usable = rows.filter((row) => /^rec[A-Za-z0-9]+$/.test(row._recordId || ''));
+  if (!usable.length) return 0;
+  await getPatientProfile().bulkWrite(usable.map((row) => {
+    const profile = toProfile(row, syncedAt);
+    return { updateOne: { filter: { recordId: profile.recordId }, update: { $set: profile }, upsert: true } };
+  }), { ordered: false });
+  return usable.length;
+}
+
+async function removeUnseen(seen, startedAt) {
+  const Model = getPatientProfile();
+  const unseen = { recordId: { $nin: seen }, syncedAt: { $lt: startedAt } };
+  const stale = await Model.countDocuments(unseen);
+  const stored = await Model.countDocuments({});
+  if (stale > Math.max(1, stored * MAX_REMOVAL_SHARE)) {
+    logger.error('[PatientProfileSync] A full read would remove too many profiles; nothing removed', { stale, stored });
+    return { removed: 0, reason: 'removal-skipped' };
+  }
+  return { removed: stale ? (await Model.deleteMany(unseen)).deletedCount || 0 : 0, reason: null };
+}
+
+async function syncPatientProfiles({ now = new Date() } = {}) {
+  const state = await readState();
+  const empty = (await getPatientProfile().countDocuments({})) === 0;
+  const reconcile = empty || !state.watermark || !state.fullReconciledAt || now - new Date(state.fullReconciledAt) >= RECONCILE_MS;
+  let rows;
+  try {
+    rows = await getRecordByFilter(Estado_General_ID, TABLE, reconcile ? MATCH_ALL : changedSince(state.watermark), null, FIELDS, true);
+  } catch (error) {
+    await saveState({ startedAt: now, written: 0, reason: 'airtable-unavailable', advance: false });
+    throw error;
+  }
+  const written = await upsertProfiles(rows, now);
+  const { removed, reason } = reconcile ? await removeUnseen(rows.map((row) => row._recordId).filter(Boolean), now) : { removed: 0, reason: null };
+  await saveState({ startedAt: now, written, reason, reconciled: reconcile });
+  return { ok: true, written, removed, reconciled: reconcile, reason };
+}
+
+let storeReady = false;
+
+async function profileStoreReady() {
+  if (!storeReady) storeReady = Boolean((await readState()).fullReconciledAt);
+  return storeReady;
+}
+
+async function fromAirtable(code, docs = []) {
+  const identity = await resolvePatientIdentity(Estado_General_ID, code);
+  if (identity.kind !== 'resolved' || isShadowRun()) return identity;
+  const keep = async () => {
+    await upsertProfiles([{ ...identity.record, _recordId: identity.recordId }], new Date());
+    const gone = docs.map((d) => d.recordId).filter((id) => id !== identity.recordId);
+    if (!gone.length) return;
+    logger.warn('[PatientProfile] Removing stored profiles Airtable no longer has for this number', { removed: gone, kept: identity.recordId });
+    await getPatientProfile().deleteMany({ recordId: { $in: gone } });
+  };
+  await keep().catch((error) => logger.warn('[PatientProfile] Could not keep a profile read from Airtable', { error: error.message }));
+  return identity;
+}
+
+async function resolveProfileIdentity(code) {
+  if (!profileFromMongo()) return resolvePatientIdentity(Follow_Up_ID, code);
+  if (typeof code !== 'string' || !code.trim()) return resolvePatientIdentity(Estado_General_ID, code);
+  const key = inlineOf(code);
+  if ((missingUntil.get(key) || 0) > Date.now()) return { kind: 'missing' };
+  let docs;
+  try {
+    if (!(await profileStoreReady())) return resolvePatientIdentity(Estado_General_ID, code);
+    docs = await getPatientProfile().find({ whatsappId: key }).lean();
+  } catch (error) {
+    logger.warn('[PatientProfile] Mongo unavailable; reading Airtable', { error: error.message });
+    return resolvePatientIdentity(Estado_General_ID, code);
+  }
+  if (docs.length === 1) return { kind: 'resolved', recordId: docs[0].recordId, record: { ...docs[0].fields } };
+  const identity = await fromAirtable(code, docs);
+  if (identity.kind === 'missing') missingUntil.set(key, Date.now() + MISSING_TTL_MS);
+  return identity;
+}
+
+const sweeper = createIntervalSweeper({
+  label: '[PatientProfileSync]',
+  sweep: () => syncPatientProfiles(),
+  defaultIntervalMs: intervalMs,
+});
+
+function startPatientProfileSync(options) {
+  const timer = sweeper.start(options);
+  syncPatientProfiles().catch((error) => logger.error('[PatientProfileSync] First sync failed', { error: error.message }));
+  return timer;
+}
+
+const stopPatientProfileSync = () => sweeper.stop();
+
+module.exports = { resolveProfileIdentity, syncPatientProfiles, startPatientProfileSync, stopPatientProfileSync };

package/lib/config/lifecycle.js

@@ -10,6 +10,7 @@ const { stopReviewDraftSweep } = require('../services/reviewDraftSweepService');
 const { stopReviewAlertSweep } = require('../services/reviewAlertSweepService');
 const { clearInteractiveRoutes } = require('../core/interactiveRouteService');
 const { _resetDefaultInstance } = require('../core/NexusMessaging');
+const { stopPatientProfileSync } = require('../clinical/services/patientProfileService');
 const { _resetSafetyNetConfig } = require('../clinical/config/safetyNetConfig');
 const { _resetSafetyNetState } = require('../clinical/services/pausedSafetyNetService');
 const { stopSafetyNetSweep } = require('../clinical/services/safetyNetPledgeService');
@@ -24,6 +25,7 @@ const SWEEP_STOP_MS = 2000;
 function stopAllSweeps({ timeoutMs = SWEEP_STOP_MS, label = '[lifecycle]' } = {}) {
   const stopped = Promise.allSettled([
     stopSafetyNetSweep(), stopRecommendationRecoverySweep(), stopInboundRecoverySweep(), stopReviewDraftSweep(), stopReviewAlertSweep(),
+    stopPatientProfileSync(),
   ]);
   return withTimeout(stopped, timeoutMs, 'sweeps.stop')
     .catch(error => logger.warn(`${label} A sweep was still running`, { error: error.message }));

package/lib/index.js

@@ -34,6 +34,8 @@ const { startRecommendationRecoverySweep } = require('./clinical/services/recomm
 const { startInboundRecoverySweep } = require('./services/inboundRecoveryService');
 const { startReviewDraftSweep } = require('./services/reviewDraftSweepService');
 const { startReviewAlertSweep } = require('./services/reviewAlertSweepService');
+const { startPatientProfileSync } = require('./clinical/services/patientProfileService');
+const { profileSyncOn } = require('./clinical/flags/clinicalContextFlags');
 const { requestIdMiddleware, getRequestId } = require('./middleware/requestId');
 const { QueueAdapter, LocalQueueAdapter, RedisQueueAdapter, createQueueAdapter, registerQueueAdapter } = require('./queue');
 const { DrainingError } = require('./core/BatchingManager');
@@ -215,6 +217,15 @@ class Nexus {
       logger.warn('Warning: failed to arm the clinical review draft sweep:', e?.message || e);
     }
 
+    try {
+      if (profileSyncOn()) {
+        startPatientProfileSync();
+        logger.info('[Nexus] patient profile sync armed');
+      }
+    } catch (e) {
+      logger.warn('Warning: failed to arm the patient profile sync:', e?.message || e);
+    }
+
     try {
       if (options.reviewAlerts?.enabled === true) {
         startReviewAlertSweep({ intervalMs: options.reviewAlerts.intervalMs });

package/lib/models/patientProfileModel.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+
+const { getDb, getModelDatabase } = require('../config/mongoConfig');
+
+const patientProfileSchema = new mongoose.Schema({
+  recordId: { type: String, required: true },
+  whatsappId: { type: String, default: null },
+  fields: { type: mongoose.Schema.Types.Mixed, default: {} },
+  syncedAt: { type: Date, default: null },
+}, { timestamps: true, minimize: false });
+
+patientProfileSchema.index({ recordId: 1 }, { unique: true });
+patientProfileSchema.index({ whatsappId: 1 });
+
+const getPatientProfile = () => {
+  const dbName = getModelDatabase('PatientProfile');
+  const db = dbName ? getDb(dbName) : mongoose;
+  return db.models.PatientProfile || db.model('PatientProfile', patientProfileSchema);
+};
+
+module.exports = {
+  getPatientProfile,
+  patientProfileSchema,
+};

package/package.json

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