@peopl-health/nexus 5.69.0-dev.12621 → 5.69.0-dev.12623

package/lib/clinical/services/outreachSweepService.js

@@ -1,11 +1,12 @@
 const moment = require('moment-timezone');
 
 const airtableService = require('../../services/airtableService');
-const { Monitoreo_ID, Symptoms_ID } = require('../../config/airtableConfig');
+const { Symptoms_ID } = require('../../config/airtableConfig');
 const { getMessages } = require('../../services/messageService');
 const { DEFAULT_TIMEZONE, isWithinHourWindow } = require('../../utils/scheduleUtils');
 const { logger } = require('../../utils/logger');
 const { botIsPaused } = require('../../helpers/pausedThreadHelper');
+const { Thread } = require('../../models/threadModel');
 const { PATIENT_CONTACT_WINDOW } = require('./contingencyDispatchService');
 const { hasPendingReminderForPatient } = require('./clinicalAirtableService');
 const { WriteClaimStore } = require('./writeClaimStore');
@@ -51,27 +52,9 @@ const AUDIT = {
 };
 
 const WEEKLY_SOURCE = 'weekly';
-const MONITOR_SOURCE = 'message_monitor';
-const SOURCES = [WEEKLY_SOURCE, MONITOR_SOURCE];
+const SCOPE_SOURCE = 'patient_scope';
 
-const MONITOR_TABLE = 'message_monitor';
-const MONITOR_F = {
-  whatsapp: 'whatsapp_id',
-  lastInbound: 'last_message_patient_time',
-};
-
-const PATIENT_TABLE = 'estado_general';
-const PATIENT_F = {
-  whatsapp: 'whatsapp_id',
-  firstName: 'first_name',
-  disableFollowUp: 'desactivar_seguimiento_48hrs',
-};
-
-const CANONICAL_CODE = /^whatsapp:\+\d{6,}$/;
-
-// The monitor lane has no questionnaire row to stamp, so its weekly claim lives in Mongo, where a
-// unique key makes it atomic and an unavailable store fails closed.
-const sweepClaims = new WriteClaimStore({ namespace: 'outreach_sweep', ttlMs: 14 * 24 * 60 * 60 * 1000 });
+const sweepClaims = new WriteClaimStore({ namespace: 'outreach_sweep', ttlMs: 8 * 24 * 60 * 60 * 1000 });
 
 const UNDELIVERED_STATUSES = ['failed', 'undelivered'];
 const CONTACT_SENT = {
@@ -227,64 +210,18 @@ function buildCandidates(rows, { now, cadence = 'daily', mode = 'continuity' })
   return { candidates, targetDays, weekday, cadence, mode };
 }
 
-function airtableInstant(date) {
-  return `DATETIME_PARSE("${date.toISOString()}")`;
-}
-
-function monitorPrefilter(now) {
-  const oldest = moment.tz(now, DEFAULT_TIMEZONE).subtract(MAX_SILENCE_DAYS + 1, 'days').toDate();
-  const newest = moment.tz(now, DEFAULT_TIMEZONE).subtract(INACTIVITY_DAYS - 1, 'days').toDate();
-  return `AND(IS_AFTER({${MONITOR_F.lastInbound}}, ${airtableInstant(oldest)}), `
-    + `IS_BEFORE({${MONITOR_F.lastInbound}}, ${airtableInstant(newest)}))`;
-}
-
-// A number can carry several monitor rows; any one of them outside prod, outside the programme or
-// paused rules the number out, so a stale duplicate cannot admit it.
-const MONITOR_DENY = 'OR({tipo} != "prod", NOT({is_program}), {stopped})';
-
-/* Patients the weekly lane does not own: anyone in the questionnaire view, or with a questionnaire
- * row this week, belongs to that lane and its stamps. Names come from estado_general because the
- * monitor's own name is a formula that falls back to "Desconocido". A number carrying two names is
- * a shared handset, and a message addressed to one of them is skipped rather than guessed. */
-function buildMonitorCandidates({ monitorRows, patientRows, excludedCodes }) {
-  const newestByCode = new Map();
-  for (const row of monitorRows) {
-    const code = String(first(row[MONITOR_F.whatsapp]) || '').trim();
-    if (!CANONICAL_CODE.test(code) || excludedCodes.has(code)) continue;
-    const seen = newestByCode.get(code);
-    if (!seen || new Date(row[MONITOR_F.lastInbound] || 0) > new Date(seen[MONITOR_F.lastInbound] || 0)) {
-      newestByCode.set(code, row);
-    }
-  }
-
-  const patientsByCode = new Map();
-  for (const row of patientRows) {
-    const code = String(first(row[PATIENT_F.whatsapp]) || '').trim();
-    if (!newestByCode.has(code)) continue;
-    if (!patientsByCode.has(code)) patientsByCode.set(code, { names: new Map(), followUpDisabled: false });
-    const patient = patientsByCode.get(code);
-    const name = String(first(row[PATIENT_F.firstName]) || '').trim();
-    if (name) patient.names.set(name.toLowerCase().replace(/\s+/g, ' '), name);
-    if (row[PATIENT_F.disableFollowUp] === true) patient.followUpDisabled = true;
-  }
-
+function buildScopeCandidates({ threads, excludedCodes }) {
   const candidates = [];
-  for (const [code, row] of newestByCode) {
-    const patient = patientsByCode.get(code);
-    if (!patient || patient.names.size !== 1) {
-      logger.info('[outreachSweep] monitor candidate skipped — no single patient name', {
-        recordId: row._recordId, names: patient?.names.size || 0,
-      });
-      continue;
-    }
+  for (const thread of new Map(threads.map((t) => [t.code, t])).values()) {
+    const name = String(thread.nombre || '').trim().split(/\s+/)[0];
+    if (excludedCodes.has(thread.code) || !name) continue;
     candidates.push({
-      source: MONITOR_SOURCE,
-      patientId: null,
-      recordId: row._recordId,
-      code,
-      name: [...patient.names.values()][0],
+      source: SCOPE_SOURCE,
+      patientId: thread.patient_id || null,
+      recordId: String(thread._id),
+      code: thread.code,
+      name,
       reason: 'no_triage_history',
-      followUpDisabled: patient.followUpDisabled,
       rows: [],
       brief: {
         reason: 'no hay un triaje contestado que sirva como ancla clínica',
@@ -297,36 +234,24 @@ function buildMonitorCandidates({ monitorRows, patientRows, excludedCodes }) {
   return candidates;
 }
 
-async function loadMonitorCandidates({ now, viewRows }) {
-  const weekStart = startOfLocalWeek(now).toDate();
-  const [monitorRows, deniedRows, patientRows, weekRows] = await Promise.all([
+async function loadScopeCandidates({ now, viewRows, patientScope }) {
+  const weekStart = startOfLocalWeek(now).toISOString();
+  const [threads, weekRows] = await Promise.all([
+    Thread.find({ code: { $in: patientScope } }, { code: 1, nombre: 1, patient_id: 1 }).lean(),
     airtableService.getRecordByFilter(
-      Monitoreo_ID, MONITOR_TABLE, monitorPrefilter(now), null, Object.values(MONITOR_F), true,
-    ),
-    airtableService.getRecordByFilter(Monitoreo_ID, MONITOR_TABLE, MONITOR_DENY, null, [MONITOR_F.whatsapp]),
-    airtableService.getRecordByFilter(Symptoms_ID, PATIENT_TABLE, 'TRUE()', null, Object.values(PATIENT_F)),
-    airtableService.getRecordByFilter(
-      Symptoms_ID, TABLE, `NOT(IS_BEFORE({${F.createdAt}}, ${airtableInstant(weekStart)}))`, null, [F.whatsapp],
+      Symptoms_ID, TABLE, `NOT(IS_BEFORE({${F.createdAt}}, DATETIME_PARSE("${weekStart}")))`, null, [F.whatsapp],
     ),
   ]);
-  const excludedCodes = new Set([
-    ...[...viewRows, ...(weekRows || [])].map((row) => first(row[F.whatsapp])),
-    ...(deniedRows || []).map((row) => first(row[MONITOR_F.whatsapp])),
-  ].map((code) => String(code || '').trim()).filter(Boolean));
-  return buildMonitorCandidates({ monitorRows: monitorRows || [], patientRows: patientRows || [], excludedCodes });
+  const excludedCodes = new Set([...viewRows, ...(weekRows || [])]
+    .map((row) => String(first(row[F.whatsapp]) || '').trim()));
+  return buildScopeCandidates({ threads: threads || [], excludedCodes });
 }
 
 function sweepClaimKey(candidate, now) {
   return `${candidate.code}:${startOfLocalWeek(now).format('YYYY-MM-DD')}`;
 }
 
-function sweepReasonFromStamps(stamps) {
-  if (stamps.some((stamp) => stamp.endsWith('_en curso'))) return 'stuck_in_progress';
-  return stamps.length ? 'already_swept_this_week' : null;
-}
-
 function opsOptedOut(candidate, { now }) {
-  if (candidate.followUpDisabled) return 'patient_follow_up_disabled';
   const weekStart = startOfLocalWeek(now);
   for (const row of candidate.rows) {
     if (first(row[F.disableFollowUp]) === true) return 'patient_follow_up_disabled';
@@ -340,12 +265,9 @@ function opsOptedOut(candidate, { now }) {
 // Patient-scoped, not row-scoped: a patient with two questionnaires this week is one person, and
 // the old automation's per-row stamp is what let her be contacted twice.
 function priorSweepReason(candidate) {
-  return sweepReasonFromStamps(candidate.rows.map((row) => String(row[F.review] || '').trim()).filter(Boolean));
-}
-
-async function priorMonitorSweepReason(candidate, { now }) {
-  const claim = await sweepClaims.get(sweepClaimKey(candidate, now));
-  return sweepReasonFromStamps(claim?.stamp ? [claim.stamp] : []);
+  const stamps = candidate.rows.map((row) => String(row[F.review] || '').trim()).filter(Boolean);
+  if (stamps.some((stamp) => stamp.endsWith('_en curso'))) return 'stuck_in_progress';
+  return stamps.length ? 'already_swept_this_week' : null;
 }
 
 async function mondayTriageStillPending(candidate) {
@@ -364,10 +286,11 @@ async function rejectionReason(candidate, {
 } = {}) {
   const opsReason = opsOptedOut(candidate, { now });
   if (opsReason) return opsReason;
+  if (await Thread.exists({ code: candidate.code, outreachOptOut: true })) return 'patient_follow_up_disabled';
   if (await botIsPaused(candidate.code, { label: '[outreachSweep]' })) return 'bot_paused';
   if (!includePreviouslySwept) {
-    const sweptReason = candidate.source === MONITOR_SOURCE
-      ? await priorMonitorSweepReason(candidate, { now })
+    const sweptReason = candidate.source === SCOPE_SOURCE
+      ? (await sweepClaims.has(sweepClaimKey(candidate, now)) ? 'already_swept_this_week' : null)
       : priorSweepReason(candidate);
     if (sweptReason) return sweptReason;
 
@@ -488,14 +411,9 @@ async function enrichBrief(candidate) {
 // patient uncontacted for the week, which is the safe direction: a free-text send carries no
 // contentSid and no idempotency key, so nothing downstream would catch a duplicate.
 async function claimCandidate({ candidate, weekdayLabel, dryRun, now }) {
-  if (dryRun) return null;
-  if (candidate.source === MONITOR_SOURCE) {
-    const claim = await sweepClaims.acquire(sweepClaimKey(candidate, now), {
-      stamp: `${weekdayLabel}_en curso`, recordId: candidate.recordId,
-    });
-    if (claim === 'acquired') return null;
-    logger.info('[outreachSweep] monitor claim not acquired', { recordId: candidate.recordId, claim });
-    return claim === 'taken' ? 'claim_lost' : 'claim_unavailable';
+  if (dryRun) return true;
+  if (candidate.source === SCOPE_SOURCE) {
+    return (await sweepClaims.acquire(sweepClaimKey(candidate, now))) === 'acquired';
   }
   try {
     const claimed = await airtableService.updateRecordByFilter(
@@ -507,39 +425,27 @@ async function claimCandidate({ candidate, weekdayLabel, dryRun, now }) {
     );
     if (!claimed?.length) {
       logger.info('[outreachSweep] candidate already claimed by another run', { recordId: candidate.recordId });
-      return 'claim_lost';
+      return false;
     }
-    return null;
+    return true;
   } catch (error) {
     logger.warn('[outreachSweep] claim failed; skipping rather than risking a double send', {
       recordId: candidate.recordId, error: error.message,
     });
-    return 'claim_lost';
+    return false;
   }
 }
 
-// Three outcomes, not two: a `write` whose delivery never happened is neither "escrito" nor a
-// deliberate hold, and collapsing it into either would hide the failure from the ops queue.
-function outcomeStamp(outcome, weekdayLabel) {
-  if (outcome.error) return `${weekdayLabel}_error`;
-  if (outcome.delivered) return `${weekdayLabel}_entregado`;
-  if (outcome.accepted) return `${weekdayLabel}_enviado`;
-  if (outcome.decision === 'write') return `${weekdayLabel}_no entregado`;
-  return `${weekdayLabel}_omitido`;
-}
-
-async function recordOutcome({ candidate, outcome, weekdayLabel, dryRun, now }) {
-  if (dryRun) return;
-  const stamp = outcomeStamp(outcome, weekdayLabel);
-  if (candidate.source === MONITOR_SOURCE) {
-    await sweepClaims.set(sweepClaimKey(candidate, now), {
-      stamp,
-      recordId: candidate.recordId,
-      rationale: outcome.rationale || outcome.error || '',
-      turnId: outcome.turnId || '',
-    });
-    return;
-  }
+async function recordOutcome({ candidate, outcome, weekdayLabel, dryRun }) {
+  if (dryRun || candidate.source === SCOPE_SOURCE) return;
+  // Three outcomes, not two: a `write` whose delivery never happened is neither "escrito" nor a
+  // deliberate hold, and collapsing it into either would hide the failure from the ops queue.
+  let stamp;
+  if (outcome.error) stamp = `${weekdayLabel}_error`;
+  else if (outcome.delivered) stamp = `${weekdayLabel}_entregado`;
+  else if (outcome.accepted) stamp = `${weekdayLabel}_enviado`;
+  else if (outcome.decision === 'write') stamp = `${weekdayLabel}_no entregado`;
+  else stamp = `${weekdayLabel}_omitido`;
   const where = `RECORD_ID() = "${candidate.recordId}"`;
   await airtableService.updateRecordByFilter(Symptoms_ID, TABLE, where, {
     [F.review]: stamp,
@@ -592,19 +498,16 @@ async function runOutreachSweep({
   if (!['continuity', 'monday_triage_recovery'].includes(mode)) {
     throw new Error('mode must be continuity or monday_triage_recovery');
   }
-  if (!SOURCES.includes(source)) {
-    throw new Error('source must be weekly or message_monitor');
+  if (![WEEKLY_SOURCE, SCOPE_SOURCE].includes(source)) {
+    throw new Error('source must be weekly or patient_scope');
   }
-  // message_monitor also holds AMI and inactive patients; only the consumer's scope says who is in
-  // its programme and active, so this lane never runs unscoped.
-  if (source === MONITOR_SOURCE
-    && (mode !== 'continuity' || cadence !== 'daily' || !Array.isArray(patientScope))) {
-    throw new Error('the message_monitor source requires continuity mode, daily cadence and a patientScope');
+  if (source === SCOPE_SOURCE && (mode !== 'continuity' || cadence !== 'daily' || !Array.isArray(patientScope))) {
+    throw new Error('the patient_scope source requires continuity mode, daily cadence and a patientScope');
   }
 
   const localWeekday = moment.tz(now, DEFAULT_TIMEZONE).isoWeekday();
   if (mode === 'monday_triage_recovery' && localWeekday !== 1) {
-    return { ran: false, weekday: localWeekday, source, reason: 'not_monday', counts: {} };
+    return { ran: false, weekday: localWeekday, reason: 'not_monday', counts: {} };
   }
 
   // Triage owns the morning. This is deliberately enforced below the cron so a manual invocation
@@ -612,25 +515,25 @@ async function runOutreachSweep({
   if (isWithinTriageProtectionWindow(now)) {
     const weekday = moment.tz(now, DEFAULT_TIMEZONE).isoWeekday();
     logger.info('[outreachSweep] triage protection window — nothing sent', { weekday });
-    return { ran: false, weekday, source, reason: 'triage_protection_window', counts: {} };
+    return { ran: false, weekday, reason: 'triage_protection_window', counts: {} };
   }
 
   const rows = await airtableService.getRecordByFilter(
     Symptoms_ID, TABLE, 'TRUE()', mode === 'monday_triage_recovery' ? null : VIEW, Object.values(F), true,
   );
-  const { candidates, targetDays, weekday } = source === MONITOR_SOURCE
-    ? { candidates: await loadMonitorCandidates({ now, viewRows: rows || [] }), targetDays: [], weekday: localWeekday }
+  const { candidates, targetDays, weekday } = source === SCOPE_SOURCE
+    ? { candidates: await loadScopeCandidates({ now, viewRows: rows || [], patientScope }), targetDays: [], weekday: localWeekday }
     : buildCandidates(rows || [], { now, cadence, mode });
   if (cadence === 'legacy' && !targetDays.length) {
     logger.info('[outreachSweep] not a sweep day — nothing to do', { weekday });
-    return { ran: false, weekday, source, reason: 'not_a_sweep_day', counts: {} };
+    return { ran: false, weekday, reason: 'not_a_sweep_day', counts: {} };
   }
 
   // The scheduler is not the guard. An operator running the sweep by hand at 03:00 must not wake
   // every candidate, so the window is checked here as well as by whatever invoked us.
   if (!isWithinHourWindow(now, PATIENT_CONTACT_WINDOW)) {
     logger.info('[outreachSweep] outside patient contact hours — nothing sent', { weekday });
-    return { ran: false, weekday, source, reason: 'quiet_hours', counts: {} };
+    return { ran: false, weekday, reason: 'quiet_hours', counts: {} };
   }
 
   // An explicit empty scope means "nobody", not "scope omitted". This matters for a canary
@@ -658,11 +561,10 @@ async function runOutreachSweep({
   const weekdayLabel = moment.tz(now, DEFAULT_TIMEZONE).locale('es').format('dddd');
   const decisions = await mapWithConcurrency(admitted, concurrency, async (candidate) => {
     const brief = await enrichBrief(candidate);
-    const claimLost = await claimCandidate({ candidate, weekdayLabel, dryRun, now });
-    if (claimLost) {
+    if (!dryRun && !await claimCandidate({ candidate, weekdayLabel, dryRun, now })) {
       counts.rejected++;
-      rejectedBy[claimLost] = (rejectedBy[claimLost] || 0) + 1;
-      return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: claimLost };
+      rejectedBy.claim_lost = (rejectedBy.claim_lost || 0) + 1;
+      return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: 'claim_lost' };
     }
     try {
       const outcome = await runOutreachTurn(candidate.code, {
@@ -672,9 +574,7 @@ async function runOutreachSweep({
         dryRun,
         reminderType: 'seguimiento',
         reminderPrefix: mode === 'monday_triage_recovery' ? 'recovery' : null,
-        triggeredBy: candidate.source === MONITOR_SOURCE
-          ? `seguimiento:mm:${candidate.recordId}`
-          : `seguimiento:${candidate.recordId}`,
+        triggeredBy: `seguimiento:${candidate.recordId}`,
       });
       counts.run++;
       if (outcome.decision === 'skipped') {
@@ -684,20 +584,19 @@ async function runOutreachSweep({
           outcome: { ...outcome, decision: 'hold', rationale: outcome.rationale || outcome.holdReason || 'turn skipped' },
           weekdayLabel,
           dryRun,
-          now,
         });
         return { code: candidate.code, recordId: candidate.recordId, ...outcome };
       }
       counts[outcome.decision === 'write' ? 'write' : 'hold']++;
       if (outcome.accepted) counts.accepted++;
       if (outcome.delivered) counts.delivered++;
-      await recordOutcome({ candidate, outcome, weekdayLabel, dryRun, now });
+      await recordOutcome({ candidate, outcome, weekdayLabel, dryRun });
       return { code: candidate.code, recordId: candidate.recordId, dryRun, brief, ...outcome };
     } catch (error) {
       counts.error++;
       logger.error('[outreachSweep] outreach turn failed', { code: candidate.code, error: error.message });
       try {
-        await recordOutcome({ candidate, outcome: { error: error.message }, weekdayLabel, dryRun, now });
+        await recordOutcome({ candidate, outcome: { error: error.message }, weekdayLabel, dryRun });
       } catch (auditError) {
         // An audit-schema outage must be loud, but it must not abort the other patients in this
         // bounded batch. The pre-send claim remains `_en curso`, which the next sweep surfaces as
@@ -719,7 +618,7 @@ async function runOutreachSweep({
 module.exports = {
   runOutreachSweep,
   buildCandidates,
-  buildMonitorCandidates,
+  buildScopeCandidates,
   rejectionReason,
   priorSweepReason,
   TARGET_DAYS_BY_WEEKDAY,
@@ -730,8 +629,6 @@ module.exports = {
   mondayTriageStillPending,
   VIEW,
   F,
-  MONITOR_F,
-  PATIENT_F,
   AUDIT,
   sweepClaims,
 };

package/lib/index.d.ts

@@ -501,7 +501,7 @@ declare module '@peopl-health/nexus' {
     ran: boolean;
     weekday: number;
     mode?: 'continuity' | 'monday_triage_recovery';
-    source?: 'weekly' | 'message_monitor';
+    source?: 'weekly' | 'patient_scope';
     targetDays?: string[];
     dryRun?: boolean;
     counts: Record<string, number>;
@@ -521,8 +521,8 @@ declare module '@peopl-health/nexus' {
     mode?: 'continuity' | 'monday_triage_recovery';
     /** daily: patients inactive for 7+ days. legacy: the Thursday/Saturday post-triage cohort (Mon/Tue and Wed/Thu triages). */
     cadence?: 'daily' | 'legacy';
-    /** weekly: the triage questionnaire view. message_monitor: active-program patients outside that view, read from message_monitor; requires continuity, daily and a patientScope. */
-    source?: 'weekly' | 'message_monitor';
+    /** weekly: the triage questionnaire view. patient_scope: the scoped patients outside that view; requires continuity, daily and a patientScope. */
+    source?: 'weekly' | 'patient_scope';
   }): Promise<OutreachSweepResult>;
 
   export const routes: any;

package/lib/models/threadModel.js

@@ -10,6 +10,7 @@ const threadSchema = new mongoose.Schema({
   run_id: { type: String, default: null },
   nombre: { type: String, default: null },
   stopped: { type: Boolean, default: false },
+  outreachOptOut: { type: Boolean, default: false },
   pausedAt: { type: Date, default: null },
   doNotAlertThrough: { type: Date, default: null },
   review: { type: Boolean, default: false },

package/package.json

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