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

package/lib/clinical/flags/recommendationRecoveryFlags.js

@@ -0,0 +1,9 @@
+const runtimeConfig = require('../../config/runtimeConfig');
+
+function recommendationRetryLive() {
+  return String(runtimeConfig.get('RECOMMENDATION_RETRY_LIVE', 'true')).trim().toLowerCase() === 'true';
+}
+
+module.exports = {
+  recommendationRetryLive,
+};

package/lib/clinical/helpers/triageRetriggerHelper.js

@@ -0,0 +1,85 @@
+const { Symptoms_ID } = require('../../config/airtableConfig');
+const { logger } = require('../../utils/logger');
+const { getRecordByFilter } = require('../../services/airtableService');
+const { buildPayloadFromTriageRow } = require('../../fhir/helpers/triagePayloadHelper');
+
+const RECORD_ID_RX = /^rec[A-Za-z0-9]+$/;
+const ITEM_TABLE = 'pro_ctcae_questions';
+const ITEM_FIELD = 'item_proctcae';
+
+const linkIdsOf = (value) => (Array.isArray(value) ? value : []).filter((id) => RECORD_ID_RX.test(String(id || '')));
+
+const fail = (reason, message) => ({ ok: false, reason, message });
+
+async function resolveLinkedItems(links, triageRecordId) {
+  const resolved = Object.fromEntries(Object.keys(links).map((field) => [field, []]));
+  const ids = [...new Set(Object.values(links).flatMap(linkIdsOf))];
+  const byId = new Map();
+  if (ids.length) {
+    const filter = `OR(${ids.map((id) => `RECORD_ID()='${id}'`).join(',')})`;
+    let rows;
+    try {
+      rows = await getRecordByFilter(Symptoms_ID, ITEM_TABLE, filter, null, [ITEM_FIELD], true);
+    } catch {
+      return null;
+    }
+    for (const row of (Array.isArray(rows) ? rows : [])) byId.set(row._recordId, row[ITEM_FIELD]);
+  }
+  for (const [field, value] of Object.entries(links)) {
+    const linked = (Array.isArray(value) ? value : []).length;
+    const wanted = linkIdsOf(value);
+    const items = wanted.map((id) => byId.get(id)).filter((item) => item != null && String(item).trim() !== '');
+    if (items.length !== linked) {
+      logger.warn('[TriageRecommendationController] unresolved triage item links', {
+        triageRecordId, field, linked, matchedIdShape: wanted.length, resolved: items.length,
+      });
+    }
+    resolved[field] = items;
+  }
+  return resolved;
+}
+
+async function buildRetriggerPayload({ triageRecordId, code }) {
+  if (typeof triageRecordId !== 'string' || !RECORD_ID_RX.test(triageRecordId.trim())) {
+    return fail('invalid_triage_id', 'triage_record_id must be an Airtable record id');
+  }
+  if (!code || typeof code !== 'string') return fail('missing_code', 'code is required');
+
+  const safeId = triageRecordId.trim();
+  const rows = await getRecordByFilter(Symptoms_ID, 'triaje_symptoms', `RECORD_ID()='${safeId}'`).catch(() => undefined);
+  if (!Array.isArray(rows)) return fail('triage_read_failed', 'triage record read failed');
+  const row = rows[0];
+  if (!row) return fail('triage_not_found', 'triage record not found');
+
+  const patientLink = Array.isArray(row.patient_id) ? row.patient_id[0] : row.patient_id;
+  if (!patientLink) return fail('no_patient_link', 'triage row has no patient link');
+
+  const patients = await getRecordByFilter(Symptoms_ID, 'estado_general', `RECORD_ID()='${patientLink}'`).catch(() => undefined);
+  if (!Array.isArray(patients)) return fail('patient_read_failed', 'patient record read failed');
+  if (!patients[0]) return fail('patient_not_found', 'patient record not found');
+  if (patients[0].whatsapp_id !== code) return fail('code_mismatch', 'code does not match the triage row patient');
+
+  const linkedItems = await resolveLinkedItems({
+    additional_symptoms_select: row.additional_symptoms_select,
+    pain_multiselect: row.pain_multiselect,
+  }, safeId);
+  if (!linkedItems) return fail('item_read_failed', 'triage item read failed');
+
+  const cadence = row['type_quest (from questionnaire_id)'];
+  const {
+    additional_symptoms_select: additionalSymptoms,
+    pain_multiselect: painOptions,
+  } = linkedItems;
+
+  return {
+    ok: true,
+    payload: buildPayloadFromTriageRow(
+      { ...row, type_quest: Array.isArray(cadence) ? cadence[0] : cadence ?? row.type_quest },
+      { patientCode: code, triageRecordId: safeId, additionalSymptoms, painOptions },
+    ),
+  };
+}
+
+module.exports = {
+  buildRetriggerPayload,
+};

package/lib/clinical/services/assistantService.js

@@ -16,19 +16,9 @@ const { getMessages, countMessages } = require('../../services/messageService');
 
 const { getAssistantById } = require('./assistantResolver');
 const { recordPausedThreadMessage } = require('./clinicalAirtableService');
-const { offerSafetyNet } = require('./pausedSafetyNetService');
 
 const MEDIA_BACKLOG_LIMIT = 10;
 
-const pausedAlertText = async (code, newest) => {
-  if (!newest.interactive_type) return newest.plainBody || newest.body;
-  const [written] = await getMessages(
-    { numero: code, from_me: false, interactive_type: null, createdAt: { $lte: newest.createdAt } },
-    { sort: { createdAt: -1 }, limit: 1 }
-  );
-  return written ? written.plainBody || written.body : null;
-};
-
 const fetchMediaBacklog = async (code, trigger) => {
   const [lastOutbound] = await getMessages(
     { numero: code, from_me: true, createdAt: { $lt: trigger.createdAt } },
@@ -122,12 +112,7 @@ const preProcessMessagesCore = async (code, message_ = null, thread) => {
       return { shouldProcess: false, messages: null, timings, pendingMediaUpdates: [] };
     }
 
-    if (thread.stopped) {
-      await Promise.allSettled([
-        recordPausedThreadMessage({ code, text: await pausedAlertText(code, lastMessage[0]) }),
-        offerSafetyNet({ code })
-      ]);
-    }
+    if (thread.stopped) await recordPausedThreadMessage({ code, text: lastMessage[0].plainBody || lastMessage[0].body });
 
     const backlog = await fetchMediaBacklog(code, lastMessage[0]);
     const replies = [...backlog, ...lastMessage];

package/lib/clinical/services/clinicalAirtableService.js

@@ -14,7 +14,6 @@ const recentIntakeCache = new WriteClaimStore({ namespace: 'intake', ttlMs: INTA
 const EMERGENCY_MERGE_WINDOW_MS = 5 * 60 * 1000;
 const EMERGENCY_URGENCY_RANK = { routine: 0, urgent: 1, asap: 2, stat: 3 };
 const recentEmergencyCache = new WriteClaimStore({ namespace: 'emergency', ttlMs: EMERGENCY_MERGE_WINDOW_MS, maxSize: 500 });
-const PAUSED_THREAD_DETAILS_PREFIX = 'Bot en pausa:';
 const PAUSED_ALERT_WINDOW_MS = 4 * 60 * 60 * 1000;
 const recentPausedAlertCache = new WriteClaimStore({ namespace: 'paused-alert', ttlMs: PAUSED_ALERT_WINDOW_MS, maxSize: 1000 });
 const UNRESOLVED_WINDOW_MS = 30 * 60 * 1000;
@@ -120,7 +119,7 @@ async function recordPausedThreadMessage({ code, text }) {
     code,
     trace: null,
     question: text || 'El paciente envió un archivo sin texto.',
-    details: `${PAUSED_THREAD_DETAILS_PREFIX} el paciente ${code} escribió y nadie ha respondido. Revisar la conversación.`,
+    details: `Bot en pausa: el paciente ${code} escribió y nadie ha respondido. Revisar la conversación.`,
     category: 'contact_team_member',
     urgency: 'soon',
   });
@@ -502,7 +501,6 @@ async function recordClusterRecommendationsMirror({ code, triageRecordId, step1
 }
 
 module.exports = {
-  PAUSED_THREAD_DETAILS_PREFIX,
   recordUnresolvedRequest,
   recordPausedThreadMessage,
   recordEmergency,

package/lib/clinical/services/recommendationRecoveryService.js

@@ -0,0 +1,175 @@
+const { buildRetriggerPayload } = require('../helpers/triageRetriggerHelper');
+const { Symptoms_ID } = require('../../config/airtableConfig');
+const { logger } = require('../../utils/logger');
+const { getRecordByFilter } = require('../../services/airtableService');
+const { recommendationRetryLive } = require('../flags/recommendationRecoveryFlags');
+const { Thread } = require('../../models/threadModel');
+const { recordUnresolvedRequest } = require('./clinicalAirtableService');
+const { handleTriageCompleted } = require('./triageRecommendationService');
+const { WriteClaimStore } = require('./writeClaimStore');
+
+const TRIAGE_TABLE = 'triaje_symptoms';
+const SCAN_WINDOW_MS = 24 * 60 * 60 * 1000;
+const MIN_AGE_MS = 15 * 60 * 1000;
+const RETRY_MAX_AGE_MS = 60 * 60 * 1000;
+const MAX_CANDIDATES = 20;
+const MAX_RETRIES_PER_PASS = 3;
+const CLAIM_TTL_MS = 60 * 60 * 1000;
+
+const retryClaims = new WriteClaimStore({ namespace: 'recom-orphan-retry', ttlMs: CLAIM_TTL_MS, maxSize: 500 });
+const ticketClaims = new WriteClaimStore({ namespace: 'recom-orphan-ticket', ttlMs: SCAN_WINDOW_MS, maxSize: 500 });
+
+const FIELDS = ['Created', 'triaje_symptoms_id', 'whatsapp_id', 'symptom_name_positive'];
+
+function orphanFormula(now) {
+  const newest = new Date(now.getTime() - MIN_AGE_MS).toISOString();
+  const oldest = new Date(now.getTime() - SCAN_WINDOW_MS).toISOString();
+  return [
+    'AND(',
+    'ARRAYJOIN({source})=\'auna\',',
+    'COUNTA({symptom_name_positive})>0,',
+    'COUNTA({cluster_recommendations})=0,',
+    `IS_AFTER({Created}, '${oldest}'),`,
+    `IS_BEFORE({Created}, '${newest}')`,
+    ')',
+  ].join('');
+}
+
+function firstValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function describe(row) {
+  return {
+    triageRecordId: row._recordId,
+    triageId: firstValue(row.triaje_symptoms_id) ?? null,
+    code: firstValue(row.whatsapp_id) ?? null,
+    createdAt: row.Created ?? null,
+    positiveSymptoms: (Array.isArray(row.symptom_name_positive) ? row.symptom_name_positive : []).length,
+  };
+}
+
+async function botIsPaused(code) {
+  if (!code) return false;
+  try {
+    const paused = await Thread.findOne({ code, stopped: true }, { _id: 1 }).lean();
+    return Boolean(paused);
+  } catch (error) {
+    logger.warn('[recommendationRecovery] thread state unreadable; treating the bot as paused', { code, error: error.message });
+    return true;
+  }
+}
+
+async function fileOpsTicket(orphan) {
+  if (!orphan.code) return false;
+  return recordUnresolvedRequest({
+    code: orphan.code,
+    trace: null,
+    question: 'El triaje de la paciente no generó recomendaciones.',
+    details: `Triaje ${orphan.triageId ?? orphan.triageRecordId} (${orphan.createdAt}) con ${orphan.positiveSymptoms} síntomas positivos no tiene recomendaciones. Revisar si procede reenviarlas.`,
+    category: 'contact_team_member',
+    urgency: 'soon',
+  });
+}
+
+async function retriggerTriage(orphan) {
+  const built = await buildRetriggerPayload({ triageRecordId: orphan.triageRecordId, code: orphan.code });
+  if (!built.ok) throw new Error(built.reason);
+  handleTriageCompleted(built.payload, { trigger: 'retry' });
+}
+
+async function sweepUnrecoveredTriages({
+  now = new Date(),
+  retrigger = retriggerTriage,
+  alert = fileOpsTicket,
+  retryLive = recommendationRetryLive,
+  claims = retryClaims,
+  ticketGate = ticketClaims,
+  isPaused = botIsPaused,
+} = {}) {
+  let rows;
+  try {
+    rows = await getRecordByFilter(Symptoms_ID, TRIAGE_TABLE, orphanFormula(now), null, FIELDS, true);
+  } catch (error) {
+    logger.error('[recommendationRecovery] orphan scan failed', { error: error.message });
+    return { scanned: 0, retried: 0, alerted: 0, skipped: 0 };
+  }
+
+  const orphans = (Array.isArray(rows) ? rows : []).map(describe).filter((orphan) => orphan.triageRecordId);
+  if (!orphans.length) return { scanned: 0, retried: 0, alerted: 0, skipped: 0 };
+
+  if (orphans.length > MAX_CANDIDATES) {
+    logger.error('[recommendationRecovery] too many triages without recommendations to act on', {
+      found: orphans.length, ceiling: MAX_CANDIDATES,
+    });
+    return { scanned: orphans.length, retried: 0, alerted: 0, skipped: orphans.length };
+  }
+
+  const canRetry = retryLive() && typeof retrigger === 'function';
+  let retried = 0;
+  let alerted = 0;
+  let skipped = 0;
+
+  for (const orphan of orphans) {
+    const ageMs = now.getTime() - new Date(orphan.createdAt).getTime();
+    const fresh = Number.isFinite(ageMs) && ageMs <= RETRY_MAX_AGE_MS;
+
+    const paused = (fresh && canRetry) ? await isPaused(orphan.code) : false;
+
+    if (fresh && canRetry && !paused && retried < MAX_RETRIES_PER_PASS) {
+      const claim = await claims.acquire(orphan.triageRecordId, 'retried');
+      if (claim === 'taken') { skipped += 1; continue; }
+      if (claim === 'unavailable') {
+        skipped += 1;
+        logger.error('[recommendationRecovery] triage produced no recommendations and could not be claimed', { ...orphan, ageMs });
+        continue;
+      }
+      logger.error('[recommendationRecovery] triage produced no recommendations, retrying', { ...orphan, ageMs });
+      try {
+        await retrigger(orphan);
+        retried += 1;
+      } catch (error) {
+        await claims.release(orphan.triageRecordId);
+        logger.error('[recommendationRecovery] retry could not be dispatched', { ...orphan, error: error.message });
+      }
+      continue;
+    }
+
+    const ticket = await ticketGate.acquire(orphan.triageRecordId, 'alerted');
+    if (ticket === 'taken') { skipped += 1; continue; }
+    if (ticket === 'unavailable') {
+      skipped += 1;
+      logger.error('[recommendationRecovery] triage produced no recommendations and could not be claimed', { ...orphan, ageMs });
+      continue;
+    }
+
+    logger.error('[recommendationRecovery] triage produced no recommendations', {
+      ...orphan, ageMs, retryable: fresh, retryLive: canRetry, botPaused: paused,
+    });
+    try {
+      if (await alert(orphan)) {
+        alerted += 1;
+      } else {
+        await ticketGate.release(orphan.triageRecordId);
+      }
+    } catch (error) {
+      await ticketGate.release(orphan.triageRecordId);
+      logger.error('[recommendationRecovery] could not file the ops ticket', { ...orphan, error: error.message });
+    }
+  }
+
+  return { scanned: orphans.length, retried, alerted, skipped };
+}
+
+module.exports = {
+  botIsPaused,
+  sweepUnrecoveredTriages,
+  orphanFormula,
+  _handledClaims: retryClaims,
+  _ticketClaims: ticketClaims,
+  CLAIM_TTL_MS,
+  MIN_AGE_MS,
+  RETRY_MAX_AGE_MS,
+  MAX_CANDIDATES,
+  MAX_RETRIES_PER_PASS,
+};

package/lib/clinical/services/writeClaimStore.js

@@ -55,6 +55,34 @@ class WriteClaimStore {
     }
   }
 
+  async acquire(key, value = true) {
+    if (this.memory.get(key) !== undefined) return 'taken';
+    if (!this._durable()) return 'unavailable';
+
+    try {
+      await WriteClaim.create({ key: this._key(key), value, expiresAt: new Date(Date.now() + this.ttlMs) });
+      this.memory.set(key, value);
+      return 'acquired';
+    } catch (error) {
+      if (error?.code === 11000) {
+        this.memory.set(key, value);
+        return 'taken';
+      }
+      logger.warn('[writeClaimStore] Claim could not be acquired', { namespace: this.namespace, error: error.message });
+      return 'unavailable';
+    }
+  }
+
+  async release(key) {
+    this.memory.delete(key);
+    if (!this._durable()) return;
+    try {
+      await WriteClaim.deleteOne({ key: this._key(key) });
+    } catch (error) {
+      logger.warn('[writeClaimStore] Claim could not be released', { namespace: this.namespace, error: error.message });
+    }
+  }
+
   clear() {
     this.memory.clear();
   }

package/lib/config/lifecycle.js

@@ -3,11 +3,7 @@ const { _resetMetaConfig } = require('../config/metaConfig');
 const { _clearClinicalContextCache } = require('../helpers/patientInformationHelper');
 const { setPreprocessingHandler } = require('../services/preprocessingService');
 const { clearTriageHistoryCache } = require('../services/triageHistoryService');
-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');
@@ -18,10 +14,6 @@ function resetAll() {
   _resetRegistry();
   _resetLLMState();
   setPreprocessingHandler(null);
-  clearInteractiveRoutes();
-  _resetSafetyNetConfig();
-  _resetSafetyNetState();
-  stopSafetyNetSweep();
   _resetOverrides();
   _resetMetaConfig();
   _clearClinicalContextCache();

package/lib/controllers/triageRecommendationController.js

@@ -1,100 +1,35 @@
-const { Symptoms_ID } = require('../config/airtableConfig');
 const { logger } = require('../utils/logger');
-const { getRecordByFilter } = require('../services/airtableService');
 const { handleTriageCompleted } = require('../clinical/services/triageRecommendationService');
-const { buildPayloadFromTriageRow } = require('../fhir/helpers/triagePayloadHelper');
+const { buildRetriggerPayload } = require('../clinical/helpers/triageRetriggerHelper');
 const { TRIAGE_RUN_PREFIX } = require('../fhir/helpers/recommendationIds');
 
-const RECORD_ID_RX = /^rec[A-Za-z0-9]+$/;
-const ITEM_TABLE = 'pro_ctcae_questions';
-const ITEM_FIELD = 'item_proctcae';
-
-const linkIdsOf = (value) => (Array.isArray(value) ? value : []).filter((id) => RECORD_ID_RX.test(String(id || '')));
-
-async function resolveLinkedItems(links, triageRecordId) {
-  const resolved = Object.fromEntries(Object.keys(links).map((field) => [field, []]));
-  const ids = [...new Set(Object.values(links).flatMap(linkIdsOf))];
-  const byId = new Map();
-  if (ids.length) {
-    const filter = `OR(${ids.map((id) => `RECORD_ID()='${id}'`).join(',')})`;
-    let rows;
-    try {
-      rows = await getRecordByFilter(Symptoms_ID, ITEM_TABLE, filter, null, [ITEM_FIELD], true);
-    } catch {
-      return null;
-    }
-    for (const row of (Array.isArray(rows) ? rows : [])) byId.set(row._recordId, row[ITEM_FIELD]);
-  }
-  for (const [field, value] of Object.entries(links)) {
-    const linked = (Array.isArray(value) ? value : []).length;
-    const wanted = linkIdsOf(value);
-    const items = wanted.map((id) => byId.get(id)).filter((item) => item != null && String(item).trim() !== '');
-    if (items.length !== linked) {
-      logger.warn('[TriageRecommendationController] unresolved triage item links', {
-        triageRecordId, field, linked, matchedIdShape: wanted.length, resolved: items.length,
-      });
-    }
-    resolved[field] = items;
-  }
-  return resolved;
-}
+const STATUS_BY_REASON = {
+  invalid_triage_id: 400,
+  missing_code: 400,
+  no_patient_link: 400,
+  code_mismatch: 400,
+  triage_not_found: 404,
+  patient_not_found: 404,
+  triage_read_failed: 503,
+  patient_read_failed: 503,
+  item_read_failed: 503,
+};
 
 const triageRecommendationController = async (req, res) => {
   const { triage_record_id: triageRecordId, code } = req.body || {};
-  if (typeof triageRecordId !== 'string' || !RECORD_ID_RX.test(triageRecordId.trim())) {
-    return res.status(400).json({ success: false, error: 'triage_record_id must be an Airtable record id' });
-  }
-  if (!code || typeof code !== 'string') {
-    return res.status(400).json({ success: false, error: 'code is required' });
-  }
 
   try {
-    const safeId = triageRecordId.trim();
-    const rows = await getRecordByFilter(Symptoms_ID, 'triaje_symptoms', `RECORD_ID()='${safeId}'`)
-      .catch(() => undefined);
-    if (!Array.isArray(rows)) {
-      logger.error('[TriageRecommendationController] triage record read failed', { triageRecordId: safeId, code });
-      return res.status(503).json({ success: false, error: 'triage record read failed' });
+    const built = await buildRetriggerPayload({ triageRecordId, code });
+    if (!built.ok) {
+      const status = STATUS_BY_REASON[built.reason] ?? 500;
+      if (status === 503) {
+        logger.error('[TriageRecommendationController] retrigger read failed', { triageRecordId, code, reason: built.reason });
+      }
+      return res.status(status).json({ success: false, error: built.message });
     }
-    const row = rows[0];
-    if (!row) return res.status(404).json({ success: false, error: 'triage record not found' });
 
-    const patientLink = Array.isArray(row.patient_id) ? row.patient_id[0] : row.patient_id;
-    if (!patientLink) {
-      return res.status(400).json({ success: false, error: 'triage row has no patient link' });
-    }
-    const patients = await getRecordByFilter(Symptoms_ID, 'estado_general', `RECORD_ID()='${patientLink}'`)
-      .catch(() => undefined);
-    if (!Array.isArray(patients)) {
-      logger.error('[TriageRecommendationController] patient record read failed', { triageRecordId: safeId, code });
-      return res.status(503).json({ success: false, error: 'patient record read failed' });
-    }
-    if (!patients[0]) {
-      return res.status(404).json({ success: false, error: 'patient record not found' });
-    }
-    if (patients[0].whatsapp_id !== code) {
-      return res.status(400).json({ success: false, error: 'code does not match the triage row patient' });
-    }
-
-    const cadence = row['type_quest (from questionnaire_id)'];
-    const linkedItems = await resolveLinkedItems({
-      additional_symptoms_select: row.additional_symptoms_select,
-      pain_multiselect: row.pain_multiselect,
-    }, safeId);
-    if (!linkedItems) {
-      logger.error('[TriageRecommendationController] triage item read failed', { triageRecordId: safeId, code });
-      return res.status(503).json({ success: false, error: 'triage item read failed' });
-    }
-    const {
-      additional_symptoms_select: additionalSymptoms,
-      pain_multiselect: painOptions,
-    } = linkedItems;
-    const payload = buildPayloadFromTriageRow(
-      { ...row, type_quest: Array.isArray(cadence) ? cadence[0] : cadence ?? row.type_quest },
-      { patientCode: code, triageRecordId: safeId, additionalSymptoms, painOptions },
-    );
-    handleTriageCompleted(payload, { trigger: 'retry' });
-    return res.status(202).json({ success: true, accepted: true, run_id: `${TRIAGE_RUN_PREFIX}${safeId}` });
+    handleTriageCompleted(built.payload, { trigger: 'retry' });
+    return res.status(202).json({ success: true, accepted: true, run_id: `${TRIAGE_RUN_PREFIX}${String(triageRecordId).trim()}` });
   } catch (error) {
     logger.error('[TriageRecommendationController] retrigger error', { error: error.message, triageRecordId, code });
     return res.status(500).json({ success: false, error: 'Failed to retrigger triage recommendation' });

package/lib/core/NexusMessaging.js

@@ -30,6 +30,7 @@ const { releaseHeldMessages, sweepHeldMessages } = require('../services/heldMess
 
 const { BatchingManager } = require('../core/BatchingManager');
 const { ProcessingPipeline } = require('../core/ProcessingPipeline');
+const { sweepUnrecoveredTriages } = require('../clinical/services/recommendationRecoveryService');
 const { preProcessMessages, configureOpenAIProvider, AssistantProcessor, TURN_KIND } = require('../clinical');
 const { buildOutreachCarrier } = require('../clinical/services/outreachCarrierService');
 const { routineOutreachCollisionReason } = require('../clinical/services/outreachSweepService');
@@ -45,7 +46,6 @@ const { isLlmMonitorEnabled } = require('../clinical/flags/llmMonitorConfig');
 const { createQueueAdapter } = require('../queue');
 const { ScheduledMessageJob } = require('../jobs/ScheduledMessageJob');
 const { TemplateApprovalJob } = require('../jobs/TemplateApprovalJob');
-const { invokeInteractiveRoute } = require('./interactiveRouteService');
 
 const { PhiProcessor } = require('./PhiProcessor');
 
@@ -170,6 +170,7 @@ class NexusMessaging {
       ...(config.queueReconciliation || {}),
       scheduleMessage: (options) => this.scheduledMessageJob.schedule(options),
       scheduleTemplateApproval: (options) => this.scheduleTemplateApproval(options),
+      sweepUnrecoveredTriages: () => sweepUnrecoveredTriages(),
       sweepHeldMessages: () => sweepHeldMessages()
     });
 
@@ -581,7 +582,6 @@ class NexusMessaging {
   }
 
   async handleInteractive(messageData) {
-    await invokeInteractiveRoute(messageData);
     if (this.handlers.onInteractive) return await this.handlers.onInteractive(messageData, this);
   }
 

package/lib/helpers/patientTaskRulesHelper.js

@@ -14,7 +14,6 @@ const ATTENTION_OPERATIONS_STATUS = 'pendiente';
 const ATTENTION_CASE_WINDOW_DAYS = 14;
 const ATTENTION_CASE_WINDOW_MS = ATTENTION_CASE_WINDOW_DAYS * 24 * 60 * 60 * 1000;
 const URGENT_REQUEST_URGENCY = 'urgent';
-const REQUEST_URGENCIES = ['routine', 'soon', 'urgent'];
 const URGENT_CASE_TYPES = ['Urgencia', 'Emergencia'];
 
 const isRequestOpen = (status) => !CLOSED_REQUEST_STATUSES.includes(status);
@@ -41,7 +40,6 @@ module.exports = {
   ATTENTION_CASE_WINDOW_DAYS,
   ATTENTION_OPERATIONS_STATUS,
   ATTENTION_REQUEST_STATUS,
-  REQUEST_URGENCIES,
   isCaseOpen,
   isCaseUrgent,
   isRequestOpen,

package/lib/index.d.ts

@@ -22,14 +22,8 @@ declare module '@peopl-health/nexus' {
     type?: 'message' | 'interactive' | 'media' | 'command' | 'keyword' | 'flow' | 'empty';
   }
 
-  export function registerInteractiveRoute(
-    prefix: string,
-    handler: (tap: { code: string; payload: string | null; title: string | null; messageData: unknown }) => unknown
-  ): void;
-  export function clearInteractiveRoutes(): void;
-
   export interface InteractiveData {
-    type: 'button' | 'list' | 'flow' | 'quick_reply';
+    type: 'button' | 'list' | 'flow';
     payload?: string;
     title?: string;
     description?: string;

package/lib/index.js

@@ -26,10 +26,6 @@ const { setModelDatabases, setModelDatabase, getModelDatabase, connect: mongoCon
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
 const { setPreprocessingHandler, hasPreprocessingHandler, invokePreprocessingHandler } = require('./services/preprocessingService');
-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');
@@ -188,16 +184,6 @@ class Nexus {
       logger.warn('Warning: failed to register clinical tools:', e?.message || e);
     }
 
-    try {
-      configureSafetyNet(options.safetyNet || {});
-      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);
-    }
-
     await this.messaging.initializeLlmMonitor();
 
     this.isInitialized = true;
@@ -252,7 +238,6 @@ 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 });
@@ -295,8 +280,6 @@ module.exports = {
   setPreprocessingHandler,
   hasPreprocessingHandler,
   invokePreprocessingHandler,
-  registerInteractiveRoute,
-  clearInteractiveRoutes,
   routes,
   syncClinicalContext,
   runProactiveOutreachSweep,

package/lib/services/patientTaskService.js

@@ -4,7 +4,6 @@ const { httpError } = require('../utils/httpErrorUtils');
 
 const { escapeFormulaValue, fieldEquals, recordIdIn } = require('../helpers/airtableFormulaHelper');
 const {
-  REQUEST_URGENCIES,
   isCaseOpen,
   isCaseUrgent,
   isRequestOpen,
@@ -110,7 +109,6 @@ const TASK_KINDS = {
     toTask: toRequest,
     writable: {
       status: { field: 'status', options: REQUEST_STATUSES },
-      urgency: { field: 'urgency', options: REQUEST_URGENCIES },
       note: { field: 'Observaciones' },
     },
   },
@@ -172,7 +170,7 @@ async function getPatientTasks(code) {
       requests: requests.attentionCount,
       isUrgent: requests.isUrgent || cases.isUrgent,
     },
-    options: { requestStatus: REQUEST_STATUSES, requestUrgency: REQUEST_URGENCIES, caseStatus: CASE_STATUSES, operationsStatus: OPERATIONS_STATUSES },
+    options: { requestStatus: REQUEST_STATUSES, caseStatus: CASE_STATUSES, operationsStatus: OPERATIONS_STATUSES },
   };
 }
 

package/lib/services/queueReconciliationService.js

@@ -7,20 +7,24 @@ const DEFAULT_INTERVAL_MS = 10 * 60 * 1000;
 const DEFAULT_LOOKBACK_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_STALE_AFTER_MS = 30 * 60 * 1000;
 const DEFAULT_BATCH_LIMIT = 200;
+const DEFAULT_PASS_TIMEOUT_MS = 5 * 60 * 1000;
 
 class QueueReconciliationService {
   constructor({
     scheduleMessage,
     scheduleTemplateApproval,
     sweepHeldMessages,
+    sweepUnrecoveredTriages,
     intervalMs = DEFAULT_INTERVAL_MS,
     lookbackMs = DEFAULT_LOOKBACK_MS,
     staleAfterMs = DEFAULT_STALE_AFTER_MS,
-    batchLimit = DEFAULT_BATCH_LIMIT
+    batchLimit = DEFAULT_BATCH_LIMIT,
+    passTimeoutMs = DEFAULT_PASS_TIMEOUT_MS
   } = {}) {
     this.scheduleMessage = scheduleMessage;
     this.scheduleTemplateApproval = scheduleTemplateApproval;
     this.sweepHeldMessages = sweepHeldMessages;
+    this.sweepUnrecoveredTriages = sweepUnrecoveredTriages;
     this.intervalMs = intervalMs;
     this.lookbackMs = lookbackMs;
     this.staleAfterMs = staleAfterMs;
@@ -28,6 +32,7 @@ class QueueReconciliationService {
     this.timer = null;
     this.stopped = false;
     this.inFlight = new Set();
+    this.passTimeoutMs = passTimeoutMs;
   }
 
   start() {
@@ -35,10 +40,15 @@ class QueueReconciliationService {
     this.stopped = false;
 
     const launch = (label) => {
-      const pass = this.runOnce()
+      const now = Date.now();
+      for (const entry of this.inFlight) {
+        if (now - entry.startedAt < this.passTimeoutMs) return;
+      }
+      const entry = { startedAt: now };
+      entry.promise = this.runOnce()
         .catch((error) => logger.warn(`[QueueReconciliation] ${label} failed`, { error: error.message }))
-        .finally(() => this.inFlight.delete(pass));
-      this.inFlight.add(pass);
+        .finally(() => this.inFlight.delete(entry));
+      this.inFlight.add(entry);
     };
 
     launch('Startup pass');
@@ -56,23 +66,35 @@ class QueueReconciliationService {
       clearInterval(this.timer);
       this.timer = null;
     }
-    return Promise.allSettled([...this.inFlight]).then(() => undefined);
+    return Promise.allSettled([...this.inFlight].map((entry) => entry.promise)).then(() => undefined);
   }
 
   async runOnce() {
-    if (this.stopped) return { scheduledMessages: 0, recoveries: 0, heldMessages: 0 };
+    if (this.stopped) return { scheduledMessages: 0, recoveries: 0, heldMessages: 0, unrecoveredTriages: 0 };
     const since = new Date(Date.now() - this.lookbackMs);
-    const [scheduledMessages, recoveries, heldMessages] = await Promise.all([
+    const [scheduledMessages, recoveries, heldMessages, unrecoveredTriages] = await Promise.all([
       this._reEnqueueScheduledMessages(since),
       this._reArmTemplateApprovals(since),
-      this._releaseHeldMessages()
+      this._releaseHeldMessages(),
+      this._recoverUnrecoveredTriages()
     ]);
 
     if (scheduledMessages || recoveries || heldMessages) {
       logger.warn('[QueueReconciliation] Re-armed dropped jobs', { scheduledMessages, recoveries, heldMessages });
     }
 
-    return { scheduledMessages, recoveries, heldMessages };
+    return { scheduledMessages, recoveries, heldMessages, unrecoveredTriages };
+  }
+
+  async _recoverUnrecoveredTriages() {
+    if (typeof this.sweepUnrecoveredTriages !== 'function') return 0;
+    try {
+      const result = await this.sweepUnrecoveredTriages();
+      return (result?.retried || 0) + (result?.alerted || 0);
+    } catch (error) {
+      logger.error('[QueueReconciliation] Recommendation recovery sweep failed', { error: error.message });
+      return 0;
+    }
   }
 
   async _releaseHeldMessages() {

package/package.json

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

package/lib/clinical/config/safetyNetConfig.js

@@ -1,64 +0,0 @@
-const runtimeConfig = require('../../config/runtimeConfig');
-
-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 };
-
-const SAFETY_NET_SOURCE = 'paused_safety_net';
-
-const humanReplyFilter = (code, since) => ({
-  numero: code,
-  from_me: true,
-  content_sid: null,
-  origin: { $ne: 'assistant' },
-  triggeredBy: { $ne: SAFETY_NET_SOURCE },
-  createdAt: { $gt: since }
-});
-
-const CHOICE_LABEL_KEYS = {
-  urgent: 'PAUSED_SAFETY_NET_URGENT_LABEL',
-  callback: 'PAUSED_SAFETY_NET_CALLBACK_LABEL',
-  later: 'PAUSED_SAFETY_NET_LATER_LABEL'
-};
-
-let injected = {};
-
-const configureSafetyNet = (config = {}) => {
-  injected = config && typeof config === 'object' ? config : {};
-};
-
-const _resetSafetyNetConfig = () => {
-  injected = {};
-};
-
-const text = (key, envKey) => {
-  const raw = injected[key] ?? runtimeConfig.get(envKey);
-  const value = String(raw ?? '').trim();
-  return value || null;
-};
-
-const duration = (key, envKey, fallback) => {
-  const raw = Number(injected[key] ?? runtimeConfig.get(envKey));
-  return Number.isFinite(raw) && raw > 0 ? raw : fallback;
-};
-
-module.exports = {
-  CONTACT_WINDOW,
-  SAFETY_NET_SOURCE,
-  humanReplyFilter,
-  CHOICE_LABEL_KEYS,
-  configureSafetyNet,
-  _resetSafetyNetConfig,
-  getSafetyNetContentSid: () => text('contentSid', 'PAUSED_SAFETY_NET_CONTENT_SID'),
-  getSafetyNetPhone: () => text('phone', 'PAUSED_SAFETY_NET_PHONE'),
-  getSafetyNetLabel: (choice) => text(`${choice}Label`, CHOICE_LABEL_KEYS[choice]),
-  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),
-  getSweepIntervalMs: () => duration('sweepIntervalMs', 'SAFETY_NET_SWEEP_INTERVAL_MS', DEFAULT_SWEEP_INTERVAL_MS)
-};

package/lib/clinical/services/pausedSafetyNetService.js

@@ -1,298 +0,0 @@
-const {
-  CONTACT_WINDOW,
-  SAFETY_NET_SOURCE,
-  getHumanQuietMs,
-  getOfferWindowMs,
-  getPledgeMs,
-  getSafetyNetContentSid,
-  getSafetyNetLabel,
-  getSafetyNetPhone,
-  getTapWindowMs
-} = require('../config/safetyNetConfig');
-const { logger } = require('../../utils/logger');
-
-const { acquireSendClaim, completeSendClaim, releaseSendClaim } = require('../../helpers/sendClaimHelper');
-
-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, stopSafetyNetSweep } = require('./safetyNetPledgeService');
-
-const getMessaging = () => require('../../core/NexusMessaging');
-
-const SOURCE = SAFETY_NET_SOURCE;
-const PAYLOAD_PREFIX = 'peopl_safetynet_';
-const CHOICES = ['urgent', 'callback', 'later'];
-const REQUEST_CATEGORY = 'contact_team_member';
-const CAN_WAIT_NOTE = 'El paciente indicó que su solicitud puede esperar.';
-const ATTENDED_STATUS = 'sin atender';
-
-const REQUEST_COPY = {
-  urgent: {
-    question: 'El paciente indicó que su situación es urgente',
-    details: (code) => `El paciente ${code} recibió el aviso de bot en pausa y eligió "urgencia". Se le dio el número para llamar. Revisar la conversación ahora.`
-  },
-  callback: {
-    question: 'El paciente pidió que el equipo lo contacte hoy',
-    details: (code) => `El paciente ${code} recibió el aviso de bot en pausa y pidió que lo contacten. Se le prometió contacto; revisar la conversación.`
-  }
-};
-
-let offerClaimStore = null;
-let tapClaimStore = null;
-let phoneCheckedFor = null;
-
-const offerClaims = () => {
-  if (!offerClaimStore) offerClaimStore = new WriteClaimStore({ namespace: 'paused-safety-net', ttlMs: getOfferWindowMs() });
-  return offerClaimStore;
-};
-
-const tapClaims = () => {
-  if (!tapClaimStore) tapClaimStore = new WriteClaimStore({ namespace: 'safety-net-choice', ttlMs: getTapWindowMs() });
-  return tapClaimStore;
-};
-
-const disarmSafetyNet = () => {
-  clearInteractiveRoutes();
-  stopSafetyNetSweep();
-};
-
-const _resetSafetyNetState = () => {
-  offerClaimStore = null;
-  tapClaimStore = null;
-  phoneCheckedFor = null;
-};
-
-function matchSafetyNetChoice(payload, title) {
-  const candidate = normalize(payload);
-  if (candidate.startsWith(PAYLOAD_PREFIX)) {
-    const suffix = candidate.slice(PAYLOAD_PREFIX.length);
-    return CHOICES.find((choice) => choice === suffix) || null;
-  }
-
-  const label = normalize(title) || candidate;
-  if (!label) return null;
-  return CHOICES.find((choice) => {
-    const configured = normalize(getSafetyNetLabel(choice));
-    return configured && configured === label;
-  }) || null;
-}
-
-async function warnIfPhoneDiffersFromTemplate(contentSid) {
-  const phone = getSafetyNetPhone();
-  if (!phone || phoneCheckedFor === contentSid) return;
-  phoneCheckedFor = contentSid;
-  try {
-    const body = await getMessaging().requireProvider().renderTemplate(contentSid);
-    const digits = (value) => String(value ?? '').replace(/\D/g, '');
-    if (body && !digits(body).includes(digits(phone))) {
-      logger.error('[PausedSafetyNet] The configured phone number is absent from the template body', { contentSid });
-    }
-  } catch (error) {
-    phoneCheckedFor = null;
-    logger.warn('[PausedSafetyNet] Could not read the template to check the phone number', { contentSid, error: error.message });
-  }
-}
-
-async function offerSafetyNet({ code }) {
-  try {
-    const contentSid = getSafetyNetContentSid();
-    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' };
-
-    await warnIfPhoneDiffersFromTemplate(contentSid);
-
-    const result = await getMessaging().sendMessage({ code, contentSid, triggeredBy: SOURCE });
-    const sent = result?.success === true || result?.completed === true;
-    if (!sent) return { sent: false, reason: result?.status || 'send_failed' };
-
-    await offerClaims().set(code, true);
-    return { sent: true, reason: null };
-  } catch (error) {
-    logger.error('[PausedSafetyNet] Could not offer the safety net', { code, error: error.message });
-    return { sent: false, reason: 'error' };
-  }
-}
-
-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({
-    code,
-    trace: null,
-    question: copy.question,
-    details: copy.details(code),
-    category: REQUEST_CATEGORY,
-    urgency: 'urgent'
-  });
-}
-
-async function markCanWait(code) {
-  const { requests = [] } = await getPatientTasks(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 false;
-
-  await updatePatientTask({
-    code,
-    kind: 'requests',
-    recordId: target.recordId,
-    changes: {
-      urgency: 'routine',
-      note: [target.note, CAN_WAIT_NOTE].filter(Boolean).join('\n')
-    },
-    updatedBy: SOURCE,
-    source: SOURCE
-  });
-  return true;
-}
-
-async function applyChoice(code, choice) {
-  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 };
-  if (!queued) return { queued, pledge: null };
-
-  try {
-    return { queued, pledge: await openPledge({ code }) };
-  } catch (error) {
-    logger.error('[PausedSafetyNet] The request was filed but no pledge was opened', { code, error: error.message });
-    return { queued, pledge: null };
-  }
-}
-
-const withPhone = (text, closing) => {
-  const phone = getSafetyNetPhone();
-  return phone ? `${text} ${closing.replace('{phone}', phone)}` : text;
-};
-
-function ackFor(choice, outcome) {
-  if (outcome.stale) {
-    return withPhone('Recibimos tu respuesta y el equipo va a revisar tu conversación.', 'Si necesitas ayuda ahora, llámanos al {phone}.');
-  }
-
-  if (!outcome.queued) {
-    return withPhone('No pudimos registrar tu solicitud.', 'Por favor llámanos al {phone} para que te atendamos.');
-  }
-
-  if (choice === 'urgent') {
-    return withPhone('Entendido, ya avisamos al equipo.', 'Si es una urgencia médica, llámanos ahora al {phone}.');
-  }
-
-  if (choice === 'later') {
-    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) {
-    return withPhone('Listo, ya avisamos al equipo y te van a contactar.', 'Si te sientes peor antes, llámanos al {phone}.');
-  }
-
-  if (outcome.pledge.deferredToWindow) {
-    return withPhone(
-      `Listo, ya avisamos al equipo. Te van a contactar en cuanto abran, a partir de las ${CONTACT_WINDOW.startHour}:00.`,
-      'Si es una urgencia médica, llámanos ahora al {phone}.'
-    );
-  }
-
-  const minutes = Math.round(getPledgeMs() / 60000);
-  return withPhone(
-    `Listo. Un miembro del equipo te va a contactar en los próximos ${minutes} minutos.`,
-    'Si te sientes peor antes, llámanos al {phone}.'
-  );
-}
-
-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;
-  }
-}
-
-async function handleSafetyNetTap({ code, payload, title }) {
-  const choice = matchSafetyNetChoice(payload, title);
-  if (!choice || !code) return { handled: false };
-
-  const claim = await acquireSendClaim({ idempotencyKey: `safetynet:${code}:${choice}` });
-  if (!claim.acquired) return { handled: true, choice, reason: 'concurrent_tap' };
-
-  let acknowledged = false;
-  try {
-    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 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(code, choice);
-      } catch (error) {
-        logger.error('[PausedSafetyNet] Could not record the tap', { code, choice, error: error.message });
-        outcome = { queued: false, pledge: null, repeated: false };
-      }
-    }
-
-    acknowledged = await sendAck(code, effective, outcome);
-    return { handled: true, choice: effective, ...outcome };
-  } finally {
-    if (acknowledged) await completeSendClaim(claim.claimId);
-    else await releaseSendClaim(claim.claimId);
-  }
-}
-
-function registerSafetyNetRoutes() {
-  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) {
-    const label = getSafetyNetLabel(choice);
-    if (label) registerInteractiveRoute(label, handleSafetyNetTap);
-  }
-  return true;
-}
-
-module.exports = {
-  disarmSafetyNet,
-  offerSafetyNet,
-  handleSafetyNetTap,
-  matchSafetyNetChoice,
-  registerSafetyNetRoutes,
-  _resetSafetyNetState,
-  PAYLOAD_PREFIX,
-  CHOICES
-};

package/lib/clinical/services/safetyNetPledgeService.js

@@ -1,120 +0,0 @@
-const { CONTACT_WINDOW, getPledgeMs, getSweepIntervalMs, humanReplyFilter } = require('../config/safetyNetConfig');
-const { logger } = require('../../utils/logger');
-const { clampToHourWindow } = require('../../utils/scheduleUtils');
-
-const { SafetyNetPledge } = require('../../models/safetyNetPledgeModel');
-
-const { getMessages } = require('../../services/messageService');
-
-const { recordUnresolvedRequest } = require('./clinicalAirtableService');
-
-const SWEEP_LIMIT = 200;
-const BREACH_CATEGORY = 'contact_team_member';
-const BREACH_QUESTION = 'El paciente sigue esperando el contacto que se le prometió';
-
-async function humanRepliedSince(code, since) {
-  const [reply] = await getMessages(humanReplyFilter(code, since), { sort: { createdAt: -1 }, limit: 1 });
-  return Boolean(reply);
-}
-
-function pledgeDueAt(pledgedAt) {
-  const target = new Date(pledgedAt.getTime() + getPledgeMs());
-  const opened = clampToHourWindow(target, CONTACT_WINDOW);
-  if (!opened) return { dueAt: target, deferredToWindow: false };
-  return { dueAt: opened, deferredToWindow: opened.getTime() > target.getTime() };
-}
-
-async function openPledge({ code }) {
-  const pledgedAt = new Date();
-  const { dueAt, deferredToWindow } = pledgeDueAt(pledgedAt);
-  const pledge = await SafetyNetPledge.create({ code, pledgedAt, dueAt, deferredToWindow });
-  logger.info('[SafetyNetPledge] Contact pledged', { code, dueAt, deferredToWindow });
-  return { pledgeId: pledge._id, dueAt, deferredToWindow };
-}
-
-async function reportBreach(pledge) {
-  const waitedMinutes = Math.round((Date.now() - new Date(pledge.pledgedAt).getTime()) / 60000);
-  return recordUnresolvedRequest({
-    code: pledge.code,
-    trace: null,
-    question: BREACH_QUESTION,
-    details: `El paciente ${pledge.code} pidió que lo contactaran y lleva ${waitedMinutes} minutos sin respuesta. Revisar la conversación ahora.`,
-    category: BREACH_CATEGORY,
-    urgency: 'urgent'
-  });
-}
-
-const REPORT_LEASE_MS = 5 * 60 * 1000;
-
-const settle = async (id, from, state) => Boolean(
-  await SafetyNetPledge.findOneAndUpdate({ _id: id, state: from }, { $set: { state, resolvedAt: new Date() } }).lean()
-);
-
-const takeReportingLease = async (id) => Boolean(
-  await SafetyNetPledge.findOneAndUpdate(
-    { _id: id, $or: [{ state: 'pending' }, { state: 'reporting', reportingSince: { $lt: new Date(Date.now() - REPORT_LEASE_MS) } }] },
-    { $set: { state: 'reporting', reportingSince: new Date() } },
-  ).lean()
-);
-
-async function sweepSafetyNetPledges() {
-  const due = await SafetyNetPledge.find({
-    state: { $in: ['pending', 'reporting'] },
-    dueAt: { $lte: new Date() },
-  })
-    .select({ _id: 1, code: 1, pledgedAt: 1 })
-    .limit(SWEEP_LIMIT)
-    .lean();
-
-  let breached = 0;
-
-  for (const pledge of due) {
-    try {
-      if (!await takeReportingLease(pledge._id)) continue;
-
-      if (await humanRepliedSince(pledge.code, pledge.pledgedAt)) {
-        await settle(pledge._id, 'reporting', 'met');
-        continue;
-      }
-
-      if (!await reportBreach(pledge)) {
-        await SafetyNetPledge.updateOne({ _id: pledge._id, state: 'reporting' }, { $set: { state: 'pending', reportingSince: null } });
-        logger.error('[SafetyNetPledge] Breach was not recorded, pledge returns to pending for the next sweep', { code: pledge.code });
-        continue;
-      }
-      if (await settle(pledge._id, 'reporting', 'breached')) breached += 1;
-    } catch (error) {
-      logger.error('[SafetyNetPledge] Could not resolve a pledge', { code: pledge.code, error: error.message });
-    }
-  }
-
-  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,
-  sweepSafetyNetPledges,
-  BREACH_QUESTION
-};

package/lib/core/interactiveRouteService.js

@@ -1,59 +0,0 @@
-const { logger } = require('../utils/logger');
-
-const routes = new Map();
-
-const normalizePayload = (value) => String(value ?? '').trim().toLowerCase();
-
-function registerInteractiveRoute(prefix, handler) {
-  const key = normalizePayload(prefix);
-  if (!key) throw new Error('registerInteractiveRoute requires a payload prefix');
-  if (typeof handler !== 'function') throw new Error('registerInteractiveRoute requires a handler function');
-  routes.set(key, handler);
-}
-
-function clearInteractiveRoutes() {
-  routes.clear();
-}
-
-function hasInteractiveRoutes() {
-  return routes.size > 0;
-}
-
-function resolveInteractiveRoute(payload) {
-  const candidate = normalizePayload(payload);
-  if (!candidate) return null;
-  for (const [prefix, handler] of routes) {
-    if (candidate.startsWith(prefix)) return handler;
-  }
-  return null;
-}
-
-async function invokeInteractiveRoute(messageData) {
-  if (!routes.size) return false;
-
-  const interactive = messageData?.interactive || {};
-  const handler = resolveInteractiveRoute(interactive.payload);
-  if (!handler) return false;
-
-  try {
-    await handler({
-      code: messageData.code,
-      payload: interactive.payload ?? null,
-      title: interactive.title ?? null,
-      messageData
-    });
-    return true;
-  } catch (error) {
-    logger.error('[InteractiveRoutes] Route handler failed', { error: error?.message || error });
-    return false;
-  }
-}
-
-module.exports = {
-  normalizePayload,
-  registerInteractiveRoute,
-  clearInteractiveRoutes,
-  hasInteractiveRoutes,
-  resolveInteractiveRoute,
-  invokeInteractiveRoute
-};

package/lib/models/safetyNetPledgeModel.js

@@ -1,20 +0,0 @@
-const mongoose = require('mongoose');
-
-const PLEDGE_STATES = ['pending', 'reporting', 'met', 'breached'];
-
-const safetyNetPledgeSchema = new mongoose.Schema({
-  code: { type: String, required: true },
-  pledgedAt: { type: Date, required: true },
-  dueAt: { type: Date, required: true },
-  deferredToWindow: { type: Boolean, default: false },
-  state: { type: String, enum: PLEDGE_STATES, default: 'pending' },
-  reportingSince: { type: Date, default: null },
-  resolvedAt: { type: Date, default: null },
-  createdAt: { type: Date, default: Date.now }
-});
-
-safetyNetPledgeSchema.index({ state: 1, dueAt: 1 }, { name: 'safety_net_pledge_due_idx' });
-
-const SafetyNetPledge = mongoose.model('SafetyNetPledge', safetyNetPledgeSchema);
-
-module.exports = { SafetyNetPledge, PLEDGE_STATES };