@peopl-health/nexus 5.71.0 → 5.71.2

package/lib/clinical/flags/clinicalContextFlags.js

@@ -10,6 +10,14 @@ function contextVerifierLive() {
   return flagOn('CLINICAL_CONTEXT_VERIFIER_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();
 }
@@ -18,4 +26,6 @@ module.exports = {
   contextReadLive,
   contextMirrorLive,
   contextVerifierLive,
+  profileFromMongo,
+  profileSyncOn,
 };

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

@@ -27,6 +27,7 @@ function flagsByStatus(sections) {
     absent: named(false),
     unassessed: pending.map((flag) => inlineOf(flag.flag)),
     drugSafety: pending.filter((flag) => flag.blocksDrug !== false).map((flag) => inlineOf(flag.flag)),
+    urgent: pending.filter((flag) => flag.urgentIfPositive === true).map((flag) => inlineOf(flag.flag)),
   };
 }
 
@@ -60,13 +61,16 @@ function proposalLine({ proposal, withheldReason, conduct, sections }) {
   const declared = [...(proposal.conditions ?? []), ...(proposal.ruledOut ?? []).map((key) => `descartado ${key}`)]
     .map((key) => inlineOf(key)?.replace(/_/g, ' ')).filter(Boolean);
   const table = formularyFor(proposal.symptom)?.label;
-  const { unassessed, drugSafety } = flagsByStatus(sections);
-  const lead = drugSafety.length
-    ? `→ Propuesta para su aprobación si se confirma sin ${drugSafety.join(', ')} (tabla ${table})`
+  const { unassessed, drugSafety, urgent } = flagsByStatus(sections);
+  const gate = unassessed.filter((flag) => drugSafety.includes(flag) || urgent.includes(flag));
+  const call = urgent.length ? `Llamar antes de indicar: ${urgent.join(', ')}. ` : '';
+  const lead = gate.length
+    ? `→ ${call}Propuesta para su aprobación si se confirma sin ${gate.join(', ')} (tabla ${table})`
     : `→ Propuesta para su aprobación (tabla ${table})`;
+  const armedConduct = urgent.length ? inlineOf(conduct) : null;
   return [
     `${lead}: ${sentence(drugs.join('; '))}`,
-    unassessed.length && 'Si algo de lo pendiente es positivo: valoración presencial.',
+    armedConduct ? sentence(armedConduct) : unassessed.length && 'Si algo de lo pendiente es positivo: valoración presencial.',
     declared.length && `Verificar: ${sentence(declared.join(', '))}`,
   ].filter(Boolean).join(' ');
 }

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -3,7 +3,8 @@ const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('
 
 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 { Follow_Up_ID } = require('../../config/airtableConfig');
 const runtimeConfig = require('../../config/runtimeConfig');
 
@@ -269,7 +270,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));

package/lib/clinical/services/escalationDraftService.js

@@ -36,14 +36,16 @@ function settleProposal(parsed) {
   const items = Array.isArray(raw?.items) ? raw.items : [];
   const stated = trimmed(parsed?.proposalWithheldReason);
   const conduct = stated && !drugsNamedIn(stated).length ? stated : null;
-  if (withheld) return { proposal: null, withheldReason: withheld, conduct, strippedItems: items.length };
-  if (!items.length) return { proposal: null, withheldReason: null, conduct, strippedItems: 0 };
+  const { present, urgent } = flagsByStatus(parsed);
+  const callFirst = urgent.length && !present.length ? `llamar antes de indicar: ${urgent.join(', ')}` : null;
+  if (withheld) return { proposal: null, withheldReason: [withheld, callFirst].filter(Boolean).join('; '), conduct, strippedItems: items.length };
+  if (!items.length) return { proposal: null, withheldReason: callFirst, conduct, strippedItems: 0 };
 
   const conditions = Array.isArray(raw.conditions) ? raw.conditions : [];
   const ruledOut = Array.isArray(raw.ruledOut) ? raw.ruledOut : [];
   const proposal = { symptom: raw.symptom, items, conditions, ruledOut };
   const { valid, issues } = validateProposal(proposal, { conditions, ruledOut });
-  return valid ? { proposal, withheldReason: null, strippedItems: 0 } : { invalid: issues };
+  return valid ? { proposal, withheldReason: null, conduct, strippedItems: 0 } : { invalid: issues };
 }
 
 const textList = (value) => (Array.isArray(value) ? value.map(trimmed).filter(Boolean) : []);
@@ -155,7 +157,11 @@ async function generateEscalationDraft({
 
   const issues = settled.flatMap((entry) => entry.invalid ?? []);
   if (!issues.length) issues.push(...crossSymptomIssues(proposals));
-  const confirmed = settled.filter((entry) => entry.proposal && !flagsByStatus(entry.block).drugSafety.length).map((entry) => entry.proposal);
+  const isConfirmed = ({ block, proposal }) => {
+    const { drugSafety, urgent } = flagsByStatus(block);
+    return proposal && !drugSafety.length && !urgent.length;
+  };
+  const confirmed = settled.filter(isConfirmed).map((entry) => entry.proposal);
   const patientDrugs = unproposedDrugsIn(patientMessage, confirmed);
   if (!issues.length && patientDrugs.length) {
     issues.push(`el mensaje al paciente menciona ${patientDrugs.join(', ')}, que no está en la propuesta de tratamiento`);

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.0",
+  "version": "5.71.2",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",