@peopl-health/nexus 5.69.0-dev.12624 → 5.69.0

package/lib/clinical/helpers/doctorReviewMessageHelper.js

@@ -21,10 +21,12 @@ function latestAlarm(review) {
 function flagsByStatus(sections) {
   const flags = (Array.isArray(sections?.redFlags) ? sections.redFlags : []).filter((flag) => inlineOf(flag?.flag));
   const named = (present) => flags.filter((flag) => flag.present === present).map((flag) => inlineOf(flag.flag));
+  const pending = flags.filter((flag) => typeof flag.present !== 'boolean');
   return {
     present: named(true),
     absent: named(false),
-    unassessed: flags.filter((flag) => typeof flag.present !== 'boolean').map((flag) => inlineOf(flag.flag)),
+    unassessed: pending.map((flag) => inlineOf(flag.flag)),
+    drugSafety: pending.filter((flag) => flag.blocksDrug !== false).map((flag) => inlineOf(flag.flag)),
   };
 }
 
@@ -49,13 +51,24 @@ function drugOf(symptom, item) {
 
 const proposedDrugs = ({ proposal }) => (proposal?.items ?? []).map((item) => drugOf(proposal.symptom, item)).filter(Boolean);
 
-function proposalLine({ proposal, withheldReason }) {
+function proposalLine({ proposal, withheldReason, conduct, sections }) {
   const drugs = proposedDrugs({ proposal });
-  if (!drugs.length) return `→ Sin propuesta de tratamiento: ${sentence(inlineOf(withheldReason) || 'requiere valoración médica')}`;
+  if (!drugs.length) {
+    const why = [withheldReason, conduct].map(inlineOf).filter(Boolean).map(sentence).join(' ');
+    return `→ Sin propuesta de tratamiento: ${why || 'requiere valoración médica.'}`;
+  }
   const declared = [...(proposal.conditions ?? []), ...(proposal.ruledOut ?? []).map((key) => `descartado ${key}`)]
     .map((key) => inlineOf(key)?.replace(/_/g, ' ')).filter(Boolean);
   const table = formularyFor(proposal.symptom)?.label;
-  return [`→ Propuesta para su aprobación (tabla ${table}): ${sentence(drugs.join('; '))}`, declared.length && `Verificar: ${sentence(declared.join(', '))}`].filter(Boolean).join(' ');
+  const { unassessed, drugSafety } = flagsByStatus(sections);
+  const lead = drugSafety.length
+    ? `→ Propuesta para su aprobación si se confirma sin ${drugSafety.join(', ')} (tabla ${table})`
+    : `→ Propuesta para su aprobación (tabla ${table})`;
+  return [
+    `${lead}: ${sentence(drugs.join('; '))}`,
+    unassessed.length && 'Si algo de lo pendiente es positivo: valoración presencial.',
+    declared.length && `Verificar: ${sentence(declared.join(', '))}`,
+  ].filter(Boolean).join(' ');
 }
 
 function symptomParagraph(entry, fallbackSymptom) {

package/lib/clinical/services/escalationDraftService.js

@@ -13,7 +13,7 @@ const { logger } = require('../../utils/logger');
 const { arrayArg, safeParse } = require('../../utils/jsonUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
 
-const { crossSymptomIssues, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
+const { crossSymptomIssues, drugsNamedIn, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
 
 const CONVERSATION_TURNS = 40;
 const TRIAGE_LIMIT = 3;
@@ -22,11 +22,10 @@ const CALL_LOG_LIMIT = 10;
 const trimmed = (value) => String(value ?? '').trim();
 
 function withholdReason(sections) {
-  const { present, unassessed } = flagsByStatus(sections);
+  const { present } = flagsByStatus(sections);
   const modifiers = (Array.isArray(sections?.treatmentModifiers) ? sections.treatmentModifiers : []).map(trimmed).filter(Boolean);
   const reasons = [];
   if (present.length) reasons.push(present.length === 1 ? 'hay una bandera roja presente' : 'hay banderas rojas presentes');
-  if (unassessed.length) reasons.push(unassessed.length === 1 ? 'hay una bandera roja sin evaluar' : 'hay banderas rojas sin evaluar');
   if (modifiers.length) reasons.push(`condición que cambia el algoritmo (${modifiers.join(', ')})`);
   return reasons.join('; ') || null;
 }
@@ -35,8 +34,10 @@ function settleProposal(parsed) {
   const withheld = withholdReason(parsed);
   const raw = parsed?.treatmentProposal;
   const items = Array.isArray(raw?.items) ? raw.items : [];
-  if (withheld) return { proposal: null, withheldReason: withheld, strippedItems: items.length };
-  if (!items.length) return { proposal: null, withheldReason: trimmed(parsed?.proposalWithheldReason) || null, strippedItems: 0 };
+  const stated = trimmed(parsed?.proposalWithheldReason);
+  const conduct = stated && !drugsNamedIn(stated).length ? stated : null;
+  if (withheld) return { proposal: null, withheldReason: withheld, conduct, strippedItems: items.length };
+  if (!items.length) return { proposal: null, withheldReason: null, conduct, strippedItems: 0 };
 
   const conditions = Array.isArray(raw.conditions) ? raw.conditions : [];
   const ruledOut = Array.isArray(raw.ruledOut) ? raw.ruledOut : [];
@@ -154,7 +155,8 @@ async function generateEscalationDraft({
 
   const issues = settled.flatMap((entry) => entry.invalid ?? []);
   if (!issues.length) issues.push(...crossSymptomIssues(proposals));
-  const patientDrugs = unproposedDrugsIn(patientMessage, proposals);
+  const confirmed = settled.filter((entry) => entry.proposal && !flagsByStatus(entry.block).drugSafety.length).map((entry) => entry.proposal);
+  const patientDrugs = unproposedDrugsIn(patientMessage, confirmed);
   if (!issues.length && patientDrugs.length) {
     issues.push(`el mensaje al paciente menciona ${patientDrugs.join(', ')}, que no está en la propuesta de tratamiento`);
   }
@@ -167,7 +169,7 @@ async function generateEscalationDraft({
   const doctorText = composeDoctorBody({
     alarm: alarms[alarms.length - 1] ?? null,
     shared: parsed,
-    symptoms: settled.map(({ block, proposal, withheldReason }) => ({ sections: block, proposal, withheldReason })),
+    symptoms: settled.map(({ block, proposal, withheldReason, conduct }) => ({ sections: block, proposal, withheldReason, conduct })),
   });
 
   if (!doctorText || !patientMessage) {

package/lib/clinical/services/outreachSweepService.js

@@ -6,10 +6,8 @@ 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');
 
 const TABLE = 'weekly_questionnaires';
 const VIEW = 'seguimiento_72hrs_principal';
@@ -51,11 +49,6 @@ const AUDIT = {
   turnId: 'seguimiento_turn_id',
 };
 
-const WEEKLY_SOURCE = 'weekly';
-const SCOPE_SOURCE = 'patient_scope';
-
-const sweepClaims = new WriteClaimStore({ namespace: 'outreach_sweep', ttlMs: 8 * 24 * 60 * 60 * 1000 });
-
 const UNDELIVERED_STATUSES = ['failed', 'undelivered'];
 const CONTACT_SENT = {
   from_me: true,
@@ -210,56 +203,6 @@ function buildCandidates(rows, { now, cadence = 'daily', mode = 'continuity' })
   return { candidates, targetDays, weekday, cadence, mode };
 }
 
-function firstWord(value) {
-  return String(value || '').trim().split(/\s+/)[0];
-}
-
-function buildScopeCandidates({ threads, excludedCodes }) {
-  const threadsByCode = new Map();
-  for (const thread of threads) threadsByCode.set(thread.code, [...(threadsByCode.get(thread.code) || []), thread]);
-
-  const candidates = [];
-  for (const [code, docs] of threadsByCode) {
-    const [thread] = docs.sort((a, b) => String(a._id).localeCompare(String(b._id)));
-    const name = firstWord(thread.nombre);
-    const names = new Set(docs.map((doc) => firstWord(doc.nombre).toLowerCase()));
-    if (excludedCodes.has(code) || !name || names.size !== 1 || !thread.patient_id) continue;
-    candidates.push({
-      source: SCOPE_SOURCE,
-      patientId: thread.patient_id,
-      recordId: String(thread._id),
-      code,
-      name,
-      reason: 'no_triage_history',
-      rows: [],
-      brief: {
-        reason: 'no hay un triaje contestado que sirva como ancla clínica',
-        lastTriageAt: null,
-        maxGrade: null,
-        positiveSymptoms: [],
-      },
-    });
-  }
-  return candidates;
-}
-
-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(
-      Symptoms_ID, TABLE, `NOT(IS_BEFORE({${F.createdAt}}, DATETIME_PARSE("${weekStart}")))`, null, [F.whatsapp],
-    ),
-  ]);
-  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 opsOptedOut(candidate, { now }) {
   const weekStart = startOfLocalWeek(now);
   for (const row of candidate.rows) {
@@ -295,12 +238,9 @@ async function rejectionReason(candidate, {
 } = {}) {
   const opsReason = opsOptedOut(candidate, { now });
   if (opsReason) return opsReason;
-  if (await Thread.exists({ code: candidate.code, outreachOptOut: true })) return 'outreach_opt_out';
   if (await botIsPaused(candidate.code, { label: '[outreachSweep]' })) return 'bot_paused';
   if (!includePreviouslySwept) {
-    const sweptReason = candidate.source === SCOPE_SOURCE
-      ? (await sweepClaims.has(sweepClaimKey(candidate, now)) ? 'already_swept_this_week' : null)
-      : priorSweepReason(candidate);
+    const sweptReason = priorSweepReason(candidate);
     if (sweptReason) return sweptReason;
 
     const since = mode === 'monday_triage_recovery'
@@ -419,10 +359,8 @@ 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, now }) {
+async function claimCandidate({ candidate, weekdayLabel, dryRun }) {
   if (dryRun) return true;
-  if ((await sweepClaims.acquire(sweepClaimKey(candidate, now))) !== 'acquired') return false;
-  if (candidate.source === SCOPE_SOURCE) return true;
   try {
     const claimed = await airtableService.updateRecordByFilter(
       Symptoms_ID,
@@ -445,7 +383,7 @@ async function claimCandidate({ candidate, weekdayLabel, dryRun, now }) {
 }
 
 async function recordOutcome({ candidate, outcome, weekdayLabel, dryRun }) {
-  if (dryRun || candidate.source === SCOPE_SOURCE) return;
+  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;
@@ -484,7 +422,6 @@ async function runOutreachSweep({
   includePreviouslySwept = false,
   cadence = 'daily',
   mode = 'continuity',
-  source = WEEKLY_SOURCE,
   runOutreachTurn,
 } = {}) {
   if (typeof runOutreachTurn !== 'function') {
@@ -506,12 +443,6 @@ async function runOutreachSweep({
   if (!['continuity', 'monday_triage_recovery'].includes(mode)) {
     throw new Error('mode must be continuity or monday_triage_recovery');
   }
-  if (![WEEKLY_SOURCE, SCOPE_SOURCE].includes(source)) {
-    throw new Error('source must be weekly or patient_scope');
-  }
-  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) {
@@ -529,9 +460,7 @@ async function runOutreachSweep({
   const rows = await airtableService.getRecordByFilter(
     Symptoms_ID, TABLE, 'TRUE()', mode === 'monday_triage_recovery' ? null : VIEW, Object.values(F), true,
   );
-  const { candidates, targetDays, weekday } = source === SCOPE_SOURCE
-    ? { candidates: await loadScopeCandidates({ now, viewRows: rows || [], patientScope }), targetDays: [], weekday: localWeekday }
-    : buildCandidates(rows || [], { now, cadence, mode });
+  const { candidates, targetDays, weekday } = 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: {} };
@@ -569,7 +498,7 @@ 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, now })) {
+    if (!dryRun && !await claimCandidate({ candidate, weekdayLabel, dryRun })) {
       counts.rejected++;
       rejectedBy.claim_lost = (rejectedBy.claim_lost || 0) + 1;
       return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: 'claim_lost' };
@@ -620,13 +549,12 @@ async function runOutreachSweep({
   });
 
   logger.info('[outreachSweep] complete', { dryRun, counts, rejectedBy });
-  return { ran: true, weekday, cadence, mode, source, targetDays, dryRun, counts, rejectedBy, decisions };
+  return { ran: true, weekday, cadence, mode, targetDays, dryRun, counts, rejectedBy, decisions };
 }
 
 module.exports = {
   runOutreachSweep,
   buildCandidates,
-  buildScopeCandidates,
   rejectionReason,
   priorSweepReason,
   TARGET_DAYS_BY_WEEKDAY,
@@ -638,5 +566,4 @@ module.exports = {
   VIEW,
   F,
   AUDIT,
-  sweepClaims,
 };

package/lib/index.d.ts

@@ -501,7 +501,6 @@ declare module '@peopl-health/nexus' {
     ran: boolean;
     weekday: number;
     mode?: 'continuity' | 'monday_triage_recovery';
-    source?: 'weekly' | 'patient_scope';
     targetDays?: string[];
     dryRun?: boolean;
     counts: Record<string, number>;
@@ -521,8 +520,6 @@ 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. 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,7 +10,6 @@ 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.12624",
+  "version": "5.69.0",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",