@peopl-health/nexus 5.52.0-dev.7711 → 5.52.0-dev.7718

package/lib/clinical/config/safetyNetConfig.js

@@ -4,6 +4,7 @@ const DEFAULT_OFFER_WINDOW_MS = 4 * 60 * 60 * 1000;
 const DEFAULT_HUMAN_QUIET_MS = 60 * 60 * 1000;
 const DEFAULT_TAP_WINDOW_MS = 30 * 60 * 1000;
 const DEFAULT_PLEDGE_MS = 30 * 60 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
 
 const CONTACT_WINDOW = { timeZone: 'America/Mexico_City', startHour: 8, endHour: 21 };
 
@@ -58,5 +59,6 @@ module.exports = {
   getOfferWindowMs: () => duration('offerWindowMs', 'PAUSED_SAFETY_NET_WINDOW_MS', DEFAULT_OFFER_WINDOW_MS),
   getHumanQuietMs: () => duration('humanQuietMs', 'SAFETY_NET_HUMAN_QUIET_MS', DEFAULT_HUMAN_QUIET_MS),
   getTapWindowMs: () => duration('tapWindowMs', 'SAFETY_NET_TAP_WINDOW_MS', DEFAULT_TAP_WINDOW_MS),
-  getPledgeMs: () => duration('pledgeMs', 'SAFETY_NET_PLEDGE_MS', DEFAULT_PLEDGE_MS)
+  getPledgeMs: () => duration('pledgeMs', 'SAFETY_NET_PLEDGE_MS', DEFAULT_PLEDGE_MS),
+  getSweepIntervalMs: () => duration('sweepIntervalMs', 'SAFETY_NET_SWEEP_INTERVAL_MS', DEFAULT_SWEEP_INTERVAL_MS)
 };

package/lib/clinical/services/pausedSafetyNetService.js

@@ -11,14 +11,15 @@ const {
 } = require('../config/safetyNetConfig');
 const { logger } = require('../../utils/logger');
 
-const { acquireSendClaim, completeSendClaim } = require('../../helpers/sendClaimHelper');
+const { acquireSendClaim, completeSendClaim, releaseSendClaim } = require('../../helpers/sendClaimHelper');
 
-const { registerInteractiveRoute } = require('../../core/interactiveRouteService');
+const { clearInteractiveRoutes, normalizePayload: normalize, registerInteractiveRoute } = require('../../core/interactiveRouteService');
+const { getMessages } = require('../../services/messageService');
 const { getPatientTasks, updatePatientTask } = require('../../services/patientTaskService');
 
 const { WriteClaimStore } = require('./writeClaimStore');
 const { PAUSED_THREAD_DETAILS_PREFIX, recordUnresolvedRequest } = require('./clinicalAirtableService');
-const { humanRepliedSince, openPledge } = require('./safetyNetPledgeService');
+const { humanRepliedSince, openPledge, stopSafetyNetSweep } = require('./safetyNetPledgeService');
 
 const getMessaging = () => require('../../core/NexusMessaging');
 
@@ -44,8 +45,6 @@ let offerClaimStore = null;
 let tapClaimStore = null;
 let phoneCheckedFor = null;
 
-const normalize = (value) => String(value ?? '').trim().toLowerCase();
-
 const offerClaims = () => {
   if (!offerClaimStore) offerClaimStore = new WriteClaimStore({ namespace: 'paused-safety-net', ttlMs: getOfferWindowMs() });
   return offerClaimStore;
@@ -56,6 +55,11 @@ const tapClaims = () => {
   return tapClaimStore;
 };
 
+const disarmSafetyNet = () => {
+  clearInteractiveRoutes();
+  stopSafetyNetSweep();
+};
+
 const _resetSafetyNetState = () => {
   offerClaimStore = null;
   tapClaimStore = null;
@@ -96,7 +100,7 @@ async function warnIfPhoneDiffersFromTemplate(contentSid) {
 async function offerSafetyNet({ code }) {
   try {
     const contentSid = getSafetyNetContentSid();
-    if (!code || !contentSid) return { sent: false, reason: 'not_configured' };
+    if (!code || !contentSid || !getSafetyNetPhone()) return { sent: false, reason: 'not_configured' };
     if (await offerClaims().get(code)) return { sent: false, reason: 'recent_offer' };
     if (await humanRepliedSince(code, new Date(Date.now() - getHumanQuietMs()))) return { sent: false, reason: 'human_active' };
 
@@ -114,6 +118,20 @@ async function offerSafetyNet({ code }) {
   }
 }
 
+async function offerIsLive(code) {
+  try {
+    const since = new Date(Date.now() - getOfferWindowMs());
+    const [sent] = await getMessages(
+      { numero: code, from_me: true, content_sid: getSafetyNetContentSid(), createdAt: { $gt: since } },
+      { sort: { createdAt: -1 }, limit: 1 }
+    );
+    return Boolean(sent);
+  } catch (error) {
+    logger.error('[PausedSafetyNet] Could not read the offer history; honouring the tap', { code, error: error.message });
+    return true;
+  }
+}
+
 async function fileUrgentRequest(code, choice) {
   const copy = REQUEST_COPY[choice];
   return recordUnresolvedRequest({
@@ -131,7 +149,7 @@ async function markCanWait(code) {
   const target = requests.find((request) => request.status === ATTENDED_STATUS
     && request.category === REQUEST_CATEGORY
     && String(request.details || '').startsWith(PAUSED_THREAD_DETAILS_PREFIX));
-  if (!target) return true;
+  if (!target) return false;
 
   await updatePatientTask({
     code,
@@ -148,7 +166,7 @@ async function markCanWait(code) {
 }
 
 async function applyChoice(code, choice) {
-  if (choice === 'later') return { queued: await markCanWait(code), pledge: null };
+  if (choice === 'later') return { queued: true, downgraded: await markCanWait(code), pledge: null };
 
   const queued = await fileUrgentRequest(code, choice);
   if (choice !== 'callback') return { queued, pledge: null };
@@ -181,7 +199,9 @@ function ackFor(choice, outcome) {
   }
 
   if (choice === 'later') {
-    return withPhone('Gracias, lo anotamos. El equipo revisará tu mensaje.', 'Si necesitas ayuda antes, llámanos al {phone}.');
+    return outcome.downgraded
+      ? withPhone('Gracias, lo anotamos. El equipo revisará tu mensaje.', 'Si necesitas ayuda antes, llámanos al {phone}.')
+      : withPhone('Gracias. El equipo revisará tu mensaje.', 'Si necesitas ayuda antes, llámanos al {phone}.');
   }
 
   if (!outcome.pledge) {
@@ -205,8 +225,10 @@ function ackFor(choice, outcome) {
 async function sendAck(code, choice, outcome) {
   try {
     await getMessaging().sendMessage({ code, body: ackFor(choice, outcome), triggeredBy: SOURCE });
+    return true;
   } catch (error) {
     logger.error('[PausedSafetyNet] Could not acknowledge the tap', { code, choice, error: error.message });
+    return false;
   }
 }
 
@@ -217,36 +239,44 @@ async function handleSafetyNetTap({ code, payload, title }) {
   const claim = await acquireSendClaim({ idempotencyKey: `safetynet:${code}:${choice}` });
   if (!claim.acquired) return { handled: true, choice, reason: 'concurrent_tap' };
 
+  let acknowledged = false;
   try {
-    if (!await offerClaims().get(code)) {
-      await sendAck(code, choice, { queued: true, pledge: null, repeated: false, stale: true });
+    if (!await offerIsLive(code)) {
+      acknowledged = await sendAck(code, choice, { queued: true, pledge: null, repeated: false, stale: true });
       return { handled: true, choice, queued: false, stale: true };
     }
     await offerClaims().set(code, true);
 
-    const tapKey = `${code}:${choice}`;
-    const repeated = Boolean(await tapClaims().get(tapKey));
+    const chosen = await tapClaims().get(code);
+    const repeated = Boolean(chosen);
+    const effective = repeated ? chosen : choice;
 
     let outcome = { queued: true, pledge: null, repeated };
     if (!repeated) {
       try {
         outcome = { ...await applyChoice(code, choice), repeated: false };
-        await tapClaims().set(tapKey, true);
+        await tapClaims().set(code, choice);
       } catch (error) {
         logger.error('[PausedSafetyNet] Could not record the tap', { code, choice, error: error.message });
         outcome = { queued: false, pledge: null, repeated: false };
       }
     }
 
-    await sendAck(code, choice, outcome);
-    return { handled: true, choice, ...outcome };
+    acknowledged = await sendAck(code, effective, outcome);
+    return { handled: true, choice: effective, ...outcome };
   } finally {
-    await completeSendClaim(claim.claimId);
+    if (acknowledged) await completeSendClaim(claim.claimId);
+    else await releaseSendClaim(claim.claimId);
   }
 }
 
 function registerSafetyNetRoutes() {
-  if (!getSafetyNetContentSid()) return false;
+  const armed = Boolean(getSafetyNetContentSid()) && Boolean(getSafetyNetPhone());
+  if (!armed) {
+    if (getSafetyNetContentSid()) logger.error('[PausedSafetyNet] A template is configured without a phone number; the safety net stays disarmed');
+    disarmSafetyNet();
+    return false;
+  }
 
   registerInteractiveRoute(PAYLOAD_PREFIX, handleSafetyNetTap);
   for (const choice of CHOICES) {
@@ -257,6 +287,7 @@ function registerSafetyNetRoutes() {
 }
 
 module.exports = {
+  disarmSafetyNet,
   offerSafetyNet,
   handleSafetyNetTap,
   matchSafetyNetChoice,

package/lib/clinical/services/safetyNetPledgeService.js

@@ -1,4 +1,4 @@
-const { CONTACT_WINDOW, getPledgeMs, humanReplyFilter } = require('../config/safetyNetConfig');
+const { CONTACT_WINDOW, getPledgeMs, getSweepIntervalMs, humanReplyFilter } = require('../config/safetyNetConfig');
 const { logger } = require('../../utils/logger');
 const { clampToHourWindow } = require('../../utils/scheduleUtils');
 
@@ -91,7 +91,27 @@ async function sweepSafetyNetPledges() {
   return breached;
 }
 
+let sweepTimer = null;
+
+function startSafetyNetSweep({ intervalMs = getSweepIntervalMs() } = {}) {
+  if (sweepTimer) return sweepTimer;
+  sweepTimer = setInterval(() => {
+    sweepSafetyNetPledges().catch((error) =>
+      logger.error('[SafetyNetPledge] Sweep failed', { error: error.message }));
+  }, intervalMs);
+  if (typeof sweepTimer.unref === 'function') sweepTimer.unref();
+  return sweepTimer;
+}
+
+function stopSafetyNetSweep() {
+  if (!sweepTimer) return;
+  clearInterval(sweepTimer);
+  sweepTimer = null;
+}
+
 module.exports = {
+  startSafetyNetSweep,
+  stopSafetyNetSweep,
   humanRepliedSince,
   openPledge,
   pledgeDueAt,

package/lib/config/lifecycle.js

@@ -7,6 +7,7 @@ const { clearInteractiveRoutes } = require('../core/interactiveRouteService');
 const { _resetDefaultInstance } = require('../core/NexusMessaging');
 const { _resetSafetyNetConfig } = require('../clinical/config/safetyNetConfig');
 const { _resetSafetyNetState } = require('../clinical/services/pausedSafetyNetService');
+const { stopSafetyNetSweep } = require('../clinical/services/safetyNetPledgeService');
 const { _clearRecentIntakeCache } = require('../clinical/services/clinicalAirtableService');
 const { _clearExtractorConfigCache } = require('../clinical/services/clinicalExtractionService');
 const { _resetRegistry } = require('../clinical/services/assistantResolver');
@@ -20,6 +21,7 @@ function resetAll() {
   clearInteractiveRoutes();
   _resetSafetyNetConfig();
   _resetSafetyNetState();
+  stopSafetyNetSweep();
   _resetOverrides();
   _resetMetaConfig();
   _clearClinicalContextCache();

package/lib/core/NexusMessaging.js

@@ -30,7 +30,6 @@ const { releaseHeldMessages, sweepHeldMessages } = require('../services/heldMess
 
 const { BatchingManager } = require('../core/BatchingManager');
 const { ProcessingPipeline } = require('../core/ProcessingPipeline');
-const { sweepSafetyNetPledges } = require('../clinical/services/safetyNetPledgeService');
 const { preProcessMessages, configureOpenAIProvider, AssistantProcessor, TURN_KIND } = require('../clinical');
 const { buildOutreachCarrier } = require('../clinical/services/outreachCarrierService');
 const { routineOutreachCollisionReason } = require('../clinical/services/outreachSweepService');
@@ -171,8 +170,7 @@ class NexusMessaging {
       ...(config.queueReconciliation || {}),
       scheduleMessage: (options) => this.scheduledMessageJob.schedule(options),
       scheduleTemplateApproval: (options) => this.scheduleTemplateApproval(options),
-      sweepHeldMessages: () => sweepHeldMessages(),
-      sweepSafetyNetPledges
+      sweepHeldMessages: () => sweepHeldMessages()
     });
 
     this._providerStores = false;

package/lib/core/interactiveRouteService.js

@@ -50,6 +50,7 @@ async function invokeInteractiveRoute(messageData) {
 }
 
 module.exports = {
+  normalizePayload,
   registerInteractiveRoute,
   clearInteractiveRoutes,
   hasInteractiveRoutes,

package/lib/index.js

@@ -29,6 +29,7 @@ const { setPreprocessingHandler, hasPreprocessingHandler, invokePreprocessingHan
 const { registerInteractiveRoute, clearInteractiveRoutes } = require('./core/interactiveRouteService');
 const { configureSafetyNet } = require('./clinical/config/safetyNetConfig');
 const { registerSafetyNetRoutes } = require('./clinical/services/pausedSafetyNetService');
+const { startSafetyNetSweep, stopSafetyNetSweep } = require('./clinical/services/safetyNetPledgeService');
 const { requestIdMiddleware, getRequestId } = require('./middleware/requestId');
 const { QueueAdapter, LocalQueueAdapter, RedisQueueAdapter, createQueueAdapter, registerQueueAdapter } = require('./queue');
 const { createWorkflowRunner } = require('./core/workflowRunner');
@@ -189,7 +190,10 @@ class Nexus {
 
     try {
       configureSafetyNet(options.safetyNet || {});
-      if (registerSafetyNetRoutes()) logger.info('[Nexus] paused-thread safety net armed');
+      if (registerSafetyNetRoutes()) {
+        startSafetyNetSweep();
+        logger.info('[Nexus] paused-thread safety net armed');
+      }
     } catch (e) {
       logger.warn('Warning: failed to arm the paused-thread safety net:', e?.message || e);
     }
@@ -248,6 +252,7 @@ class Nexus {
   }
 
   async shutdown({ drainMs, abortGraceMs, teardownMs, closeStorage = true } = {}) {
+    stopSafetyNetSweep();
     if (this._shutdownPromise) return this._shutdownPromise;
     this._shutdownPromise = (async () => {
       const result = await this.messaging.shutdown({ drainMs, abortGraceMs, teardownMs });

package/lib/services/queueReconciliationService.js

@@ -13,7 +13,6 @@ class QueueReconciliationService {
     scheduleMessage,
     scheduleTemplateApproval,
     sweepHeldMessages,
-    sweepSafetyNetPledges,
     intervalMs = DEFAULT_INTERVAL_MS,
     lookbackMs = DEFAULT_LOOKBACK_MS,
     staleAfterMs = DEFAULT_STALE_AFTER_MS,
@@ -22,7 +21,6 @@ class QueueReconciliationService {
     this.scheduleMessage = scheduleMessage;
     this.scheduleTemplateApproval = scheduleTemplateApproval;
     this.sweepHeldMessages = sweepHeldMessages;
-    this.sweepSafetyNetPledges = sweepSafetyNetPledges;
     this.intervalMs = intervalMs;
     this.lookbackMs = lookbackMs;
     this.staleAfterMs = staleAfterMs;
@@ -62,20 +60,19 @@ class QueueReconciliationService {
   }
 
   async runOnce() {
-    if (this.stopped) return { scheduledMessages: 0, recoveries: 0, heldMessages: 0, breachedPledges: 0 };
+    if (this.stopped) return { scheduledMessages: 0, recoveries: 0, heldMessages: 0 };
     const since = new Date(Date.now() - this.lookbackMs);
-    const [scheduledMessages, recoveries, heldMessages, breachedPledges] = await Promise.all([
+    const [scheduledMessages, recoveries, heldMessages] = await Promise.all([
       this._reEnqueueScheduledMessages(since),
       this._reArmTemplateApprovals(since),
-      this._releaseHeldMessages(),
-      this._resolveSafetyNetPledges()
+      this._releaseHeldMessages()
     ]);
 
-    if (scheduledMessages || recoveries || heldMessages || breachedPledges) {
-      logger.warn('[QueueReconciliation] Re-armed dropped jobs', { scheduledMessages, recoveries, heldMessages, breachedPledges });
+    if (scheduledMessages || recoveries || heldMessages) {
+      logger.warn('[QueueReconciliation] Re-armed dropped jobs', { scheduledMessages, recoveries, heldMessages });
     }
 
-    return { scheduledMessages, recoveries, heldMessages, breachedPledges };
+    return { scheduledMessages, recoveries, heldMessages };
   }
 
   async _releaseHeldMessages() {
@@ -88,16 +85,6 @@ class QueueReconciliationService {
     }
   }
 
-  async _resolveSafetyNetPledges() {
-    if (typeof this.sweepSafetyNetPledges !== 'function') return 0;
-    try {
-      return await this.sweepSafetyNetPledges();
-    } catch (error) {
-      logger.error('[QueueReconciliation] Safety-net pledge sweep failed', { error: error.message });
-      return 0;
-    }
-  }
-
   async _reEnqueueScheduledMessages(since) {
     if (typeof this.scheduleMessage !== 'function') return 0;
 

package/package.json

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