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

package/lib/clinical/monitoring/LlmMonitorService.js

@@ -230,7 +230,7 @@ class LlmMonitorService {
     if (!evaluation) return Evaluations.findOne(key);
 
     try {
-      const evidence = await spec.buildEvidence(trace);
+      const evidence = spec.buildEvidence(trace);
       let judge = null;
       let result = null;
       let judgePrompt = null;
@@ -248,19 +248,12 @@ class LlmMonitorService {
           text: { format: { type: 'json_schema', name: `${spec.id}_verdict`, schema: spec.schema, strict: true } },
           metadata: { source: 'llm_monitor', turn_id: trace.turnId, monitor_id: spec.id, monitor_version: String(spec.version) },
         });
-        // A refusal repeats on retry, so a spec that can record it does not pay for it again.
-        const isFinalRefusal = result?.status === 'refused' && spec.refusalIsFinal === true;
-        if (result?.status && result.status !== 'completed' && !isFinalRefusal) {
-          throw new Error(`monitor judge did not complete: ${result.stop_reason || result.status}`);
-        }
-        if (!isFinalRefusal) {
-          judge = parseJudge(result);
-          spec.validateJudge?.(judge);
-        }
+        judge = parseJudge(result);
+        spec.validateJudge?.(judge);
       }
       let findings = spec.interpret({ trace, evidence, judge });
       const evalKey = `${spec.id}:${spec.version}:${trace.turnId}`;
-      const passSampled = findings.length === 0 && judge !== null && stableFraction(evalKey) < this.passSampleRate;
+      const passSampled = findings.length === 0 && stableFraction(evalKey) < this.passSampleRate;
       if (passSampled) findings = [passFinding(judge)];
       findings = findings.map((finding, index) => ({
         ...finding,
@@ -559,7 +552,6 @@ class LlmMonitorService {
 
 module.exports = {
   LlmMonitorService,
-  stableFraction,
   EVALUATE_QUEUE,
   RECONCILE_QUEUE,
   _test: { stableFraction, findingId, needsSync, syncBacklogFilter, RECONCILE_BATCH_SIZE, MAX_EVALUATION_ATTEMPTS },

package/lib/clinical/providers/AnthropicProvider.js

@@ -348,27 +348,15 @@ class AnthropicProvider extends BaseLLMProvider {
     };
     if (system) apiConfig.system = system;
 
-    // Always-thinking models (Opus/Sonnet 5.5) reject a forced tool_choice; presets opt into output_config.format instead.
-    const nativeFormat = modelConfig.structured_mode === 'output_format';
-    if (nativeFormat) {
-      const effort = modelConfig.reasoning?.effort;
-      if (effort) apiConfig.output_config = { effort: effort === 'minimal' ? 'low' : effort };
-      if (modelConfig.thinking) apiConfig.thinking = modelConfig.thinking;
-    }
-
     const spec = text || modelConfig.text;
     let tool = null;
     if (spec) {
       const format = spec.format ? spec.format : spec;
       if (!format.schema) throw new Error('runStructured: format spec has no schema');
-      if (nativeFormat) {
-        apiConfig.output_config = { ...apiConfig.output_config, format: { type: 'json_schema', schema: format.schema } };
-      } else {
-        tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
-        if (format.strict !== undefined) tool.strict = format.strict;
-        apiConfig.tools = [tool];
-        apiConfig.tool_choice = { type: 'tool', name: tool.name };
-      }
+      tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
+      if (format.strict !== undefined) tool.strict = format.strict;
+      apiConfig.tools = [tool];
+      apiConfig.tool_choice = { type: 'tool', name: tool.name };
     }
 
     const { result: { result }, durationMs } = await withTiming(() =>

package/lib/clinical/services/outreachSweepService.js

@@ -1,13 +1,14 @@
 const moment = require('moment-timezone');
 
 const airtableService = require('../../services/airtableService');
-const { Symptoms_ID } = require('../../config/airtableConfig');
+const { Monitoreo_ID, 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 { PATIENT_CONTACT_WINDOW } = require('./contingencyDispatchService');
 const { hasPendingReminderForPatient } = require('./clinicalAirtableService');
+const { WriteClaimStore } = require('./writeClaimStore');
 
 const TABLE = 'weekly_questionnaires';
 const VIEW = 'seguimiento_72hrs_principal';
@@ -49,6 +50,29 @@ const AUDIT = {
   turnId: 'seguimiento_turn_id',
 };
 
+const WEEKLY_SOURCE = 'weekly';
+const MONITOR_SOURCE = 'message_monitor';
+const SOURCES = [WEEKLY_SOURCE, MONITOR_SOURCE];
+
+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 UNDELIVERED_STATUSES = ['failed', 'undelivered'];
 const CONTACT_SENT = {
   from_me: true,
@@ -62,6 +86,7 @@ const CONTACT_SENT = {
 const RECENT_OUTBOUND_HOURS = 24;
 const COLLIDING_REMINDER_MINUTES = 24 * 60;
 const INACTIVITY_DAYS = 7;
+const MAX_SILENCE_DAYS = 30;
 const TRIAGE_PROTECTION_START_MINUTE = (7 * 60) + 30;
 const TRIAGE_PROTECTION_END_MINUTE = 11 * 60;
 
@@ -202,7 +227,106 @@ 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;
+  }
+
+  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;
+    }
+    candidates.push({
+      source: MONITOR_SOURCE,
+      patientId: null,
+      recordId: row._recordId,
+      code,
+      name: [...patient.names.values()][0],
+      reason: 'no_triage_history',
+      followUpDisabled: patient.followUpDisabled,
+      rows: [],
+      brief: {
+        reason: 'no hay un triaje contestado que sirva como ancla clínica',
+        lastTriageAt: null,
+        maxGrade: null,
+        positiveSymptoms: [],
+      },
+    });
+  }
+  return candidates;
+}
+
+async function loadMonitorCandidates({ now, viewRows }) {
+  const weekStart = startOfLocalWeek(now).toDate();
+  const [monitorRows, deniedRows, patientRows, weekRows] = await Promise.all([
+    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],
+    ),
+  ]);
+  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 });
+}
+
+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';
@@ -216,9 +340,12 @@ 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) {
-  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;
+  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] : []);
 }
 
 async function mondayTriageStillPending(candidate) {
@@ -239,7 +366,9 @@ async function rejectionReason(candidate, {
   if (opsReason) return opsReason;
   if (await botIsPaused(candidate.code, { label: '[outreachSweep]' })) return 'bot_paused';
   if (!includePreviouslySwept) {
-    const sweptReason = priorSweepReason(candidate);
+    const sweptReason = candidate.source === MONITOR_SOURCE
+      ? await priorMonitorSweepReason(candidate, { now })
+      : priorSweepReason(candidate);
     if (sweptReason) return sweptReason;
 
     const since = mode === 'monday_triage_recovery'
@@ -269,11 +398,13 @@ async function rejectionReason(candidate, {
       if (!await mondayTriageStillPending(candidate)) return 'triage_no_longer_pending';
     } else if (cadence === 'daily') {
       const inactiveSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(INACTIVITY_DAYS, 'days').toDate();
-      const recentInbound = await getMessages(
-        { numero: candidate.code, from_me: false, createdAt: { $gte: inactiveSince } },
-        { sort: { createdAt: -1 }, limit: 1 },
+      const silentSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(MAX_SILENCE_DAYS, 'days').toDate();
+      const [lastInbound] = await getMessages(
+        { numero: candidate.code, from_me: false, createdAt: { $gte: silentSince } },
+        { select: { createdAt: 1 }, sort: { createdAt: -1 }, limit: 1 },
       );
-      if (recentInbound?.length) return 'patient_active_within_inactivity_window';
+      if (!lastInbound) return 'patient_silent_beyond_max_window';
+      if (new Date(lastInbound.createdAt) >= inactiveSince) return 'patient_active_within_inactivity_window';
 
       const lastTriageAt = candidate?.brief?.lastTriageAt;
       if (lastTriageAt && moment.tz(lastTriageAt, DEFAULT_TIMEZONE).isSameOrAfter(inactiveSince)) {
@@ -356,8 +487,16 @@ async function enrichBrief(candidate) {
 // so a second overlapping sweep sees this one and stands down. A turn that then dies leaves the
 // 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 }) {
-  if (dryRun) return true;
+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';
+  }
   try {
     const claimed = await airtableService.updateRecordByFilter(
       Symptoms_ID,
@@ -368,27 +507,39 @@ async function claimCandidate({ candidate, weekdayLabel, dryRun }) {
     );
     if (!claimed?.length) {
       logger.info('[outreachSweep] candidate already claimed by another run', { recordId: candidate.recordId });
-      return false;
+      return 'claim_lost';
     }
-    return true;
+    return null;
   } catch (error) {
     logger.warn('[outreachSweep] claim failed; skipping rather than risking a double send', {
       recordId: candidate.recordId, error: error.message,
     });
-    return false;
+    return 'claim_lost';
   }
 }
 
-async function recordOutcome({ candidate, outcome, weekdayLabel, dryRun }) {
+// 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;
-  // 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 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;
+  }
   const where = `RECORD_ID() = "${candidate.recordId}"`;
   await airtableService.updateRecordByFilter(Symptoms_ID, TABLE, where, {
     [F.review]: stamp,
@@ -419,6 +570,7 @@ async function runOutreachSweep({
   includePreviouslySwept = false,
   cadence = 'daily',
   mode = 'continuity',
+  source = WEEKLY_SOURCE,
   runOutreachTurn,
 } = {}) {
   if (typeof runOutreachTurn !== 'function') {
@@ -440,10 +592,19 @@ 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');
+  }
+  // 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');
+  }
 
   const localWeekday = moment.tz(now, DEFAULT_TIMEZONE).isoWeekday();
   if (mode === 'monday_triage_recovery' && localWeekday !== 1) {
-    return { ran: false, weekday: localWeekday, reason: 'not_monday', counts: {} };
+    return { ran: false, weekday: localWeekday, source, reason: 'not_monday', counts: {} };
   }
 
   // Triage owns the morning. This is deliberately enforced below the cron so a manual invocation
@@ -451,23 +612,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, reason: 'triage_protection_window', counts: {} };
+    return { ran: false, weekday, source, 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 } = buildCandidates(rows || [], { now, cadence, mode });
+  const { candidates, targetDays, weekday } = source === MONITOR_SOURCE
+    ? { candidates: await loadMonitorCandidates({ now, viewRows: rows || [] }), 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, reason: 'not_a_sweep_day', counts: {} };
+    return { ran: false, weekday, source, 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, reason: 'quiet_hours', counts: {} };
+    return { ran: false, weekday, source, reason: 'quiet_hours', counts: {} };
   }
 
   // An explicit empty scope means "nobody", not "scope omitted". This matters for a canary
@@ -495,10 +658,11 @@ 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);
-    if (!dryRun && !await claimCandidate({ candidate, weekdayLabel, dryRun })) {
+    const claimLost = await claimCandidate({ candidate, weekdayLabel, dryRun, now });
+    if (claimLost) {
       counts.rejected++;
-      rejectedBy.claim_lost = (rejectedBy.claim_lost || 0) + 1;
-      return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: 'claim_lost' };
+      rejectedBy[claimLost] = (rejectedBy[claimLost] || 0) + 1;
+      return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: claimLost };
     }
     try {
       const outcome = await runOutreachTurn(candidate.code, {
@@ -508,7 +672,9 @@ async function runOutreachSweep({
         dryRun,
         reminderType: 'seguimiento',
         reminderPrefix: mode === 'monday_triage_recovery' ? 'recovery' : null,
-        triggeredBy: `seguimiento:${candidate.recordId}`,
+        triggeredBy: candidate.source === MONITOR_SOURCE
+          ? `seguimiento:mm:${candidate.recordId}`
+          : `seguimiento:${candidate.recordId}`,
       });
       counts.run++;
       if (outcome.decision === 'skipped') {
@@ -518,19 +684,20 @@ 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 });
+      await recordOutcome({ candidate, outcome, weekdayLabel, dryRun, now });
       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 });
+        await recordOutcome({ candidate, outcome: { error: error.message }, weekdayLabel, dryRun, now });
       } 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
@@ -546,12 +713,13 @@ async function runOutreachSweep({
   });
 
   logger.info('[outreachSweep] complete', { dryRun, counts, rejectedBy });
-  return { ran: true, weekday, cadence, mode, targetDays, dryRun, counts, rejectedBy, decisions };
+  return { ran: true, weekday, cadence, mode, source, targetDays, dryRun, counts, rejectedBy, decisions };
 }
 
 module.exports = {
   runOutreachSweep,
   buildCandidates,
+  buildMonitorCandidates,
   rejectionReason,
   priorSweepReason,
   TARGET_DAYS_BY_WEEKDAY,
@@ -562,5 +730,8 @@ module.exports = {
   mondayTriageStillPending,
   VIEW,
   F,
+  MONITOR_F,
+  PATIENT_F,
   AUDIT,
+  sweepClaims,
 };

package/lib/core/NexusMessaging.js

@@ -77,11 +77,7 @@ const unbatchedRoutes = {
 function loadDefaultLlmMonitor() {
   const { LlmMonitorService } = require('../clinical/monitoring/LlmMonitorService');
   const { contingencyMonitorSpec } = require('../clinical/monitoring/contingencyMonitorSpec');
-  const { emergencyConsultMonitorSpec } = require('../clinical/monitoring/emergencyConsultMonitorSpec');
-  const { emergencyConsultMode } = require('../clinical/flags/emergencyConsultFlags');
-  const specs = [contingencyMonitorSpec];
-  if (emergencyConsultMode() !== 'off') specs.push(emergencyConsultMonitorSpec);
-  return { LlmMonitorService, specs };
+  return { LlmMonitorService, contingencyMonitorSpec };
 }
 
 function normalizeLlmMonitorConfig(value) {
@@ -92,8 +88,8 @@ function normalizeLlmMonitorConfig(value) {
 function createDefaultLlmMonitor(options, loader = loadDefaultLlmMonitor) {
   if (!options.enabled) return null;
   try {
-    const { LlmMonitorService, specs } = loader();
-    return new LlmMonitorService({ ...options, specs });
+    const { LlmMonitorService, contingencyMonitorSpec } = loader();
+    return new LlmMonitorService({ ...options, specs: [contingencyMonitorSpec] });
   } catch (error) {
     logger.warn('[llmMonitor] construction failed; patient messaging remains available', {
       error: error?.message || String(error),

package/lib/index.d.ts

@@ -501,6 +501,7 @@ declare module '@peopl-health/nexus' {
     ran: boolean;
     weekday: number;
     mode?: 'continuity' | 'monday_triage_recovery';
+    source?: 'weekly' | 'message_monitor';
     targetDays?: string[];
     dryRun?: boolean;
     counts: Record<string, number>;
@@ -520,6 +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';
   }): Promise<OutreachSweepResult>;
 
   export const routes: any;

package/package.json

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

package/lib/clinical/flags/emergencyConsultFlags.js

@@ -1,16 +0,0 @@
-const runtimeConfig = require('../../config/runtimeConfig');
-
-const MODES = ['off', 'shadow'];
-const DEFAULT_SAMPLE_RATE = 0.1;
-
-function emergencyConsultMode() {
-  const value = String(runtimeConfig.get('EMERGENCY_CONSULT_MODE', 'off')).trim().toLowerCase();
-  return MODES.includes(value) ? value : 'off';
-}
-
-function emergencyConsultSampleRate() {
-  const value = Number(runtimeConfig.get('EMERGENCY_CONSULT_SAMPLE_RATE', DEFAULT_SAMPLE_RATE));
-  return Number.isFinite(value) && value >= 0 && value <= 1 ? value : DEFAULT_SAMPLE_RATE;
-}
-
-module.exports = { emergencyConsultMode, emergencyConsultSampleRate };

package/lib/clinical/monitoring/emergencyConsultMonitorSpec.js

@@ -1,215 +0,0 @@
-const { patientMessageFromTrace } = require('../helpers/evidenceAnchorHelper');
-const { buildConsultContext } = require('../services/emergencyConsultService');
-const { emergencyConsultSampleRate } = require('../flags/emergencyConsultFlags');
-const { URGENCY_RANK } = require('../../models/escalationReviewModel');
-const { isPlainObject } = require('../../utils/jsonUtils');
-
-const { stableFraction } = require('./LlmMonitorService');
-
-const MONITOR_ID = 'emergency_consult';
-const MONITOR_VERSION = '1';
-const PRESET_ID = 'sa_emergency_consult';
-const LEVELS = ['stat', 'asap', 'urgent', 'routine'];
-const IMMEDIATE_LEVELS = ['stat', 'asap'];
-const DISPOSITIONS = ['escalate_now', 'ask_first', 'no_escalation'];
-const STALE_AFTER_MS = 15 * 60 * 1000;
-const UNREADABLE_PATIENT = [400, 404];
-
-const strings = { type: 'array', items: { type: 'string' } };
-const nullableLevel = { anyOf: [{ type: 'string', enum: LEVELS }, { type: 'null' }] };
-
-const CONSULT_SCHEMA = {
-  type: 'object',
-  additionalProperties: false,
-  required: ['disposition', 'urgency_level', 'confidence', 'clinical_reasoning', 'serious_differential', 'red_flags_present',
-    'red_flags_ruled_out', 'missing_information', 'level_if_unanswered', 'context_gaps', 'recommended_action', 'what_to_tell_patient'],
-  properties: {
-    disposition: { type: 'string', enum: DISPOSITIONS },
-    urgency_level: nullableLevel,
-    confidence: { type: 'string', enum: ['low', 'moderate', 'high'] },
-    clinical_reasoning: { type: 'string' },
-    serious_differential: {
-      type: 'array',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['condition', 'status', 'features'],
-        properties: {
-          condition: { type: 'string' },
-          status: { type: 'string', enum: ['supported', 'not_excluded', 'unlikely'] },
-          features: strings,
-        },
-      },
-    },
-    red_flags_present: strings,
-    red_flags_ruled_out: strings,
-    missing_information: {
-      type: 'array',
-      items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['question_for_patient', 'why', 'level_if_positive'],
-        properties: {
-          question_for_patient: { type: 'string' },
-          why: { type: 'string' },
-          level_if_positive: { type: 'string', enum: LEVELS },
-        },
-      },
-    },
-    level_if_unanswered: nullableLevel,
-    context_gaps: strings,
-    recommended_action: {
-      type: 'object',
-      additionalProperties: false,
-      required: ['now', 'notify'],
-      properties: {
-        now: { type: 'string' },
-        notify: { type: 'string', enum: ['none', 'team_review', 'treating_team_today', 'oncologist_now', 'emergency_services'] },
-      },
-    },
-    what_to_tell_patient: { type: 'string' },
-  },
-};
-
-const asArray = (value) => (Array.isArray(value) ? value : []);
-
-function triggers(trace) {
-  const signals = trace?.signals || {};
-  const found = [];
-  if (signals.medicalEscalation) found.push('medical_escalation');
-  if (asArray(signals.safetyFlags).length) found.push('safety_flags');
-  if (asArray(signals.activatedSkills).includes('emergency')) found.push('emergency_skill');
-  if (!found.length && asArray(signals.clinicalMentions).length
-    && stableFraction(`${MONITOR_ID}:${trace.turnId}`) < emergencyConsultSampleRate()) found.push('mention_sample');
-  return found;
-}
-
-function isEligible(trace) {
-  return trace?.status === 'completed'
-    && trace?.shadow !== true
-    && triggers(trace).length > 0;
-}
-
-function agentDecision(trace) {
-  const escalation = trace.signals?.medicalEscalation;
-  if (!escalation) return { escalated: false, level: null, requestedLevel: null, patternFloor: null };
-  return {
-    escalated: true,
-    level: escalation.urgencyLevel || null,
-    requestedLevel: escalation.requestedUrgencyLevel || null,
-    patternFloor: escalation.clinicalPatternFloor || null,
-  };
-}
-
-const mentionFacts = (trace) => asArray(trace.signals?.clinicalMentions)
-  .map(({ fact }) => {
-    if (!isPlainObject(fact)) return null;
-    const { patientId: _patientId, mentionId: _mentionId, ...rest } = fact;
-    return rest;
-  })
-  .filter(Boolean);
-
-async function buildEvidence(trace, now = Date.now()) {
-  // The trace is saved once the turn ends, so the turn started predictionTimeMs before createdAt.
-  const turnStart = new Date(trace.createdAt).getTime() - (trace.timings?.predictionTimeMs || 0);
-  const base = { triggers: triggers(trace), agent: agentDecision(trace), lag_ms: now - turnStart };
-  if (base.lag_ms > STALE_AFTER_MS) return { ...base, extraction_succeeded: false, degraded: 'stale' };
-  try {
-    const { input, degradedSections, hasCoreContext } = await buildConsultContext({
-      code: trace.patientCode,
-      turnStart,
-      patientMessage: patientMessageFromTrace(trace),
-      mentions: mentionFacts(trace),
-    });
-    if (!hasCoreContext) return { ...base, extraction_succeeded: false, degraded: 'core_context_missing', degraded_sections: degradedSections };
-    return { ...base, extraction_succeeded: true, input, degraded_sections: degradedSections };
-  } catch (error) {
-    if (!UNREADABLE_PATIENT.includes(error?.statusCode)) throw error;
-    return { ...base, extraction_succeeded: false, degraded: 'patient_unreadable', error: error.message };
-  }
-}
-
-function buildJudgeInput(evidence) {
-  return [{ role: 'user', content: evidence.input }];
-}
-
-function validateJudge(judge) {
-  if (!isPlainObject(judge) || !DISPOSITIONS.includes(judge.disposition)) {
-    throw new Error('emergency consult returned no valid disposition');
-  }
-}
-
-function invariantViolations(judge) {
-  const violations = [];
-  const askFirst = judge.disposition === 'ask_first';
-  if (judge.disposition === 'escalate_now' && !judge.urgency_level) violations.push('escalate_now_without_level');
-  if (askFirst && !asArray(judge.missing_information).length) violations.push('ask_first_without_questions');
-  if (askFirst && !judge.level_if_unanswered) violations.push('ask_first_without_level_if_unanswered');
-  if (askFirst && [judge.urgency_level, judge.level_if_unanswered].some((level) => IMMEDIATE_LEVELS.includes(level))) {
-    violations.push('ask_first_on_immediate_level');
-  }
-  if (judge.disposition !== 'escalate_now' && asArray(judge.red_flags_present).length) violations.push('red_flags_without_escalation');
-  return violations;
-}
-
-const rank = (level) => URGENCY_RANK[level] || 0;
-
-function consultFinding(fields) {
-  return {
-    type: 'emergency_consult',
-    severity: 'normal',
-    confidence: 'high',
-    opsReviewRequired: false,
-    targetId: null,
-    observedCallIndex: null,
-    ...fields,
-  };
-}
-
-function interpret({ evidence, judge }) {
-  if (!evidence.extraction_succeeded || !judge) {
-    return [consultFinding({
-      expectedAction: null,
-      observedAction: evidence.agent?.level || null,
-      criteria: { degraded: evidence.extraction_succeeded ? 'judge_refused' : evidence.degraded },
-      summary: 'El especialista no evaluó el turno.',
-      evidence: evidence.error || 'Sin detalle.',
-    })];
-  }
-  const specialistLevel = judge.disposition === 'ask_first' ? judge.level_if_unanswered : judge.urgency_level;
-  const agentLevel = evidence.agent?.level || null;
-  return [consultFinding({
-    expectedAction: specialistLevel || null,
-    observedAction: agentLevel,
-    criteria: {
-      disposition: judge.disposition,
-      agent_below_specialist: rank(agentLevel) < rank(specialistLevel),
-      invariant_violations: invariantViolations(judge),
-    },
-    summary: `Especialista: ${judge.disposition} ${specialistLevel || 'sin nivel'}; agente: ${agentLevel || 'sin escalamiento'}.`,
-    evidence: judge.clinical_reasoning || 'Sin razonamiento.',
-  })];
-}
-
-const emergencyConsultMonitorSpec = {
-  id: MONITOR_ID,
-  version: MONITOR_VERSION,
-  presetId: PRESET_ID,
-  schema: CONSULT_SCHEMA,
-  refusalIsFinal: true,
-  reconcileQuery: {
-    $or: [
-      { 'signals.medicalEscalation': { $exists: true } },
-      { 'signals.safetyFlags.0': { $exists: true } },
-      { 'signals.activatedSkills': 'emergency' },
-      { 'signals.clinicalMentions.0': { $exists: true } },
-    ],
-  },
-  isEligible,
-  buildEvidence,
-  buildJudgeInput,
-  validateJudge,
-  interpret,
-};
-
-module.exports = { emergencyConsultMonitorSpec };

package/lib/clinical/services/emergencyConsultService.js

@@ -1,76 +0,0 @@
-const { readClinicalProfile } = require('../helpers/clinicalProfileHelper');
-const { buildExposureBlock } = require('../helpers/triageCaseBaseHelper');
-const { readDispatchedEscalations } = require('../../fhir');
-const { getEscalationContext } = require('../../services/escalationContextService');
-const { redactDirectIdentifiers } = require('../../utils/sanitizerUtils');
-const { assembleRiskProfile } = require('./riskAssessmentService');
-const { escalationLookbackSince } = require('./turnRiskBriefService');
-
-const CONTEXT_SECTIONS = ['agentContext', 'conversation', 'history'];
-const MAX_INPUT_CHARS = 120000;
-
-const optional = (promise) => promise.catch(() => undefined);
-
-// The conversation ends with this turn's own reply; the consult must not read the decision it is judging.
-function conversationBeforeReply(conversation) {
-  const messages = Array.isArray(conversation) ? [...conversation] : [];
-  while (messages.length && messages[messages.length - 1].role === 'assistant') messages.pop();
-  return messages;
-}
-
-function clinicalProfile(profile) {
-  if (!profile) return undefined;
-  const { edad = null, sexo = null } = profile.demografia || {};
-  return { demografia: { edad, sexo }, datos_clinicos: profile.datos_clinicos ?? null };
-}
-
-const section = (title, value) => [`## ${title}`, value === undefined ? 'no disponible' : JSON.stringify(value), ''];
-
-function fitConversation(head, conversation) {
-  const messages = [...conversation];
-  let text = section('Conversación', messages).join('\n');
-  while (messages.length && head.length + text.length > MAX_INPUT_CHARS) {
-    messages.shift();
-    text = section('Conversación', messages).join('\n');
-  }
-  return { text, truncated: messages.length < conversation.length };
-}
-
-async function buildConsultContext({ code, turnStart, patientMessage = null, mentions = [] }) {
-  const asOf = new Date(turnStart);
-  const [context, profile, risk, escalations] = await Promise.all([
-    getEscalationContext({ code, sections: CONTEXT_SECTIONS }),
-    readClinicalProfile(code),
-    optional(assembleRiskProfile(code)),
-    optional(readDispatchedEscalations({ patientId: code, since: escalationLookbackSince(asOf.getTime()) })),
-  ]);
-  const exposure = buildExposureBlock(profile);
-  const degradedSections = [...context.degradedSections];
-  if (!profile) degradedSections.push('clinicalProfile');
-  if (risk === undefined) degradedSections.push('risk');
-  if (escalations === undefined) degradedSections.push('escalations');
-
-  const head = [
-    `Fecha de hoy: ${asOf.toISOString().slice(0, 10)}`,
-    '',
-    '## Mensaje del paciente en este turno',
-    patientMessage || 'no capturado',
-    '',
-    ...section('Menciones clínicas extraídas en este turno', mentions),
-    ...section('Contexto clínico que ve la enfermera', context.agentContext ?? undefined),
-    '## Exposición antineoplásica y medicación documentadas',
-    exposure || 'no documentada',
-    '',
-    ...section('Perfil clínico', clinicalProfile(profile)),
-    ...section('Perfil de riesgo', risk?.profile ?? undefined),
-    ...section('Escalamientos de los últimos 14 días', escalations?.filter((event) => Date.parse(event.escalatedAt) < asOf.getTime())),
-    ...section('Historia clínica reciente', context.history ?? undefined),
-  ].join('\n');
-  const conversation = fitConversation(head, conversationBeforeReply(context.conversation));
-  if (conversation.truncated) degradedSections.push('conversation_truncated');
-  const input = `${head}\n${conversation.text}`;
-
-  return { input: redactDirectIdentifiers(input), degradedSections, hasCoreContext: Boolean(context.agentContext || profile) };
-}
-
-module.exports = { buildConsultContext };