@peopl-health/nexus 5.71.8 → 5.71.10

package/lib/clinical/flags/escalationFlags.js

@@ -10,7 +10,12 @@ function escalationAssessmentLive() {
   return flagOn('ESCALATION_ASSESSMENT_LIVE');
 }
 
+function feverPatientTimerLive() {
+  return flagOn('FEVER_PATIENT_TIMER_LIVE');
+}
+
 module.exports = {
   escalationAssessmentLive,
   escalationUpdateModeLive,
+  feverPatientTimerLive,
 };

package/lib/clinical/services/clinicalExtractionService.js

@@ -78,11 +78,18 @@ async function extractClinicalMentions({ text, turnId, code, provider, detectedT
     const { datosClinicos, contextGaps } = await loadPatientContext(code);
     const vagueWords = await getVagueEntityWords();
 
-    const { result, durationMs } = await withTiming(() => provider.runStructured({
-      presetId,
-      input: [{ role: 'user', content: buildExtractorInput(text, detectedTags, curatedRows, template, { priorTurns, patientContext: datosClinicos }) }],
-      metadata: { extractor: 'clinical-mention', turnId },
-    }));
+    let timed;
+    try {
+      timed = await withTiming(() => provider.runStructured({
+        presetId,
+        input: [{ role: 'user', content: buildExtractorInput(text, detectedTags, curatedRows, template, { priorTurns, patientContext: datosClinicos }) }],
+        metadata: { extractor: 'clinical-mention', turnId },
+      }));
+    } catch (err) {
+      logger.error('[clinicalExtraction] extractor provider unavailable; returning deterministic safety flags only', { turnId, error: err?.message });
+      return { completed: false, unavailable: Boolean(patterns?.length), clinicalMentions: [], safetyFlags: [...flags], safetyFlagSources: sources() };
+    }
+    const { result, durationMs } = timed;
     trace?.addSubCall({ response: result, durationMs, presetId });
 
     if (result?.status && result.status !== 'completed') throw new Error(`clinical extraction incomplete: status=${result.status}`);

package/lib/clinical/tools/extractClinicalInfoTool.js

@@ -38,6 +38,8 @@ function nonClinicalRequestSchema() {
 }
 
 const MAX_CONTEXT_TURNS = 6;
+const EXTRACTOR_UNAVAILABLE = 'extractor_unavailable';
+const ESCALATION_WHILE_UNAVAILABLE = 'described in the patient\'s words and graded on the symptom itself; never mention the extractor or a technical failure, to the patient or the team.';
 
 const definition = {
   name: 'extractClinicalInfo',
@@ -239,13 +241,19 @@ async function handler(args, context = {}) {
     });
   }
 
+  if (!intakeCompleted && extraction.unavailable && !safetyFlags.length && !detectedTags.includes('symptom')) {
+    return degradedIntake(trace);
+  }
+
   if (!intakeCompleted) {
     return JSON.stringify({
       success: false,
       error: 'clinical_intake_incomplete',
       data: {
         safety_flags_received: safetyFlags,
-        recovery: 'Retry extractClinicalInfo with the complete patient message and all applicable supported tags.',
+        recovery: extraction.unavailable
+          ? `The clinical extractor is unavailable and a retry will not succeed. Send what the message reports to the team with reportMedicalEscalation (reportCrisis for a crisis), ${ESCALATION_WHILE_UNAVAILABLE}`
+          : 'Retry extractClinicalInfo with the complete patient message and all applicable supported tags.',
       },
     });
   }
@@ -312,6 +320,10 @@ async function declareNonClinical({ declaredRequest, rawMessage, intakeSource, p
     });
   }
 
+  if (check?.unavailable && !safetyFlags.length) {
+    return degradedIntake(trace, { non_clinical_request: declaredRequest });
+  }
+
   trace?.setSignals?.({ clinicalIntakeCompleted: false, clinicalMentions: [], safetyFlags });
   const supported = [...SUPPORTED_TAGS].sort();
   const reason = found
@@ -325,6 +337,20 @@ async function declareNonClinical({ declaredRequest, rawMessage, intakeSource, p
   });
 }
 
+function degradedIntake(trace, data = {}) {
+  trace?.setSignals?.({ clinicalIntakeCompleted: true, clinicalIntakeDegraded: EXTRACTOR_UNAVAILABLE, clinicalMentions: [], safetyFlags: [] });
+  return JSON.stringify({
+    success: true,
+    data: {
+      ...data,
+      degraded: true,
+      degraded_reasons: [EXTRACTOR_UNAVAILABLE],
+      clinical_facts: [],
+      agent_hint: `The clinical extractor is unavailable, so nothing from this message was recorded as clinical information. Do not call extractClinicalInfo again this turn. A new or worsening symptom goes to the team with reportMedicalEscalation, ${ESCALATION_WHILE_UNAVAILABLE} Anything else gets a reply only.`,
+    },
+  });
+}
+
 async function scanSafetyFlags(text) {
   try {
     const patterns = await getSafetyFlagPatterns();

package/lib/clinical/tools/reportMedicalEscalationTool.js

@@ -9,17 +9,19 @@ const { armEscalationNet } = require('../services/contingencyDispatchService');
 const { recordEmergency, writeUnresolvedRequest } = require('../services/clinicalAirtableService');
 const { activeTriageGateFloor } = require('../services/triageGateFloorService');
 const { clinicalPatternFloor } = require('../services/clinicalPatternFloorService');
-const { escalationAssessmentLive, escalationUpdateModeLive } = require('../flags/escalationFlags');
+const { escalationAssessmentLive, escalationUpdateModeLive, feverPatientTimerLive } = require('../flags/escalationFlags');
 const { triageGateFloorLive } = require('../flags/triageGateFloorFlags');
 const { clinicalPatternFloorLive } = require('../flags/clinicalPatternFloorFlags');
-const { attachEmergencyRow, escalationAnchorOf, recordEscalationAlarm } = require('../../services/escalationReviewService');
+const { attachEmergencyRow, escalationAnchorOf, recordEscalationAlarm, setAlarmAppliedLevel } = require('../../services/escalationReviewService');
 const { URGENCY_RANK } = require('../../models/escalationReviewModel');
 const { objectArg, safeParse, isPlainObject } = require('../../utils/jsonUtils');
 const { logger } = require('../../utils/logger');
 
+const FEVER_RULE = 'Fever that is `stat`: ≥38.0 °C within 8 weeks of cytotoxic chemotherapy (or a hematologic cancer, transplant, known neutropenia), any fever within 4 weeks of CAR-T or during bispecific step-up dosing, or sepsis signs with or without fever — say it calmly: "ve a urgencias ahora y di que estás en tratamiento oncológico" (CAR-T / bispecific: call the treating center first). If you don\'t know the treatment or the last dose date, ask in the same message; unknown date on chemo counts as within the window. Fever 37.5–37.9 °C in that window with the patient well is `asap`: remeasure in 30–60 min. ';
+
 const definition = {
   'name': 'reportMedicalEscalation',
-  'description': '**Does:** Escalates a MEDICAL situation to the oncology care team at a chosen urgency, with an explicit justification for the level. Covers the full medical-urgency spectrum — immediate emergencies through asynchronous team review. One-way commit; the payload is INTERNAL — the patient never sees it.\n\n**Required inputs:** `urgency_level` — the FHIR request-priority code (`stat` | `asap` | `urgent` | `routine`), `urgency_justification` (one or two sentences: why this level AND why not the tier above/below — the auditable decision record), `details` (object — `symptom` + `evidence_quote` required; pass `null` when unknown for `category`, `indicators`, `suspected_condition`, `recommended_action`).\n\n**Urgency levels:** FHIR request-priority, a RELATIVE order `routine` < `urgent` < `asap` < `stat` (priority/speed, not a fixed clock). The full per-tier rubric with clinical examples lives on the `urgency_level` input enum — read it there. Out-of-enum values are coerced to `urgent` and disclosed via `coerced_urgency` on the result.\n\n**Neurological constellation override:** TWO OR MORE of — visual change, dizziness/vertigo/loss of balance, inability to walk/stand, focal weakness/numbness, acute confusion, sudden severe headache — reported this turn or across the last 2–3 turns → escalate without a further clarifying question: `asap` by default, `stat` if there is an acute deficit (can\'t walk/stand, sphincter loss, bilateral leg weakness → possible cord compression) or any instability.\n\n**When NOT to call:**\n- Unconfirmed/unspecific symptom — ask ONE characterization question via `DeliverPatientMessage` first.\n- Active mental-health crisis — use `reportCrisis`.\n- Patient shared lab/imaging/values/files — use `reportResultsReceived`.\n- Administrative / operative matter (appointments, insurance, authorizations, letters, transport, scheduling, out-of-scope request) or a non-clinical referral (psico-oncología, paliativos, non-oncology medical) — use `reportUnresolvedRequestv2`.\n- Twice in the same turn for the same episode — already committed; a later datum belongs to the same open escalation.\n\n**After the commit:** the escalation does not end the conversation.\n- **Patient message** (`DeliverPatientMessage`, calm, ≤60 words): acknowledge what they told you → \'Ya avisé al equipo médico\' → ONE concrete next step → a safety net specific to THIS case (1–2 observable signs and what to do if they appear) → availability. Explain the purpose in everyday words. Reassure with the plan (\'ya le avisé al equipo médico para que lo revise\', \'vamos a darle seguimiento contigo\'), never with promises (\'no es nada\', \'no te preocupes\'). No diagnosis names, no lists of alarming symptoms, no \'grave/peligroso\', no timed fallback (\'si en 15 minutos…\'), and no promised contact time — not even \'te contactan hoy en las próximas horas\'; say what the team was asked to do (\'le pedí al equipo médico que lo revise\'), never that someone is already reviewing it, and not when they will reach out.\n- **By level:** `stat` is the ONLY level that sends the patient now — calm and unambiguous: ve a urgencias ahora, acompañado; 911 (or an ambulance) if they are alone with no one to take them, cannot move safely, or are unstable — being alone counts as unsafe transport, and they never drive themselves. Fever that is `stat`: ≥38.0 °C within 8 weeks of cytotoxic chemotherapy (or a hematologic cancer, transplant, known neutropenia), any fever within 4 weeks of CAR-T or during bispecific step-up dosing, or sepsis signs with or without fever — say it calmly: "ve a urgencias ahora y di que estás en tratamiento oncológico" (CAR-T / bispecific: call the treating center first). If you don\'t know the treatment or the last dose date, ask in the same message; unknown date on chemo counts as within the window. Fever 37.5–37.9 °C in that window with the patient well is `asap`: remeasure in 30–60 min. `asap`: do NOT lead with urgencias — it appears only in the conditional safety net (if [sign] appears or they feel much worse). `urgent`: they can stay home; urgencias only as a worsening-sign safety net. `routine`: acknowledgement, what to watch, when to write again.\n- **Keep characterizing (except `stat`):** in the same message ask the ONE question that most helps the team; in later turns keep going, one question per message, and give high-value guidance that does not prescribe (comfort measures already in their plan or indicated by the team, what to have at hand, how to monitor). Each new datum goes to the SAME open escalation, not a new one: raise the level if it makes something more serious plausible; never lower it. In `stat`, after the instruction only confirm they are on their way and accompanied.\n\n**Returns:** a RECEIPT, not a resolution — `{urgency_level, queued_for_team, safety_net_armed, safety_net_reason, team_has_reviewed, means, follow_up}`. `safety_net_armed` is `true`/`false`/`null`, where **`null` means this urgency tier gets no automatic check-in at all** (`routine`); read `follow_up` and make the fallback explicit to the patient whenever nothing is armed. `queued_for_team` says only that the ticket was written; `team_has_reviewed` is always `false` here because nothing on this path can know otherwise. Treat the escalation as OPEN and still your responsibility for the rest of the conversation: never tell the patient the team already reviewed it, and never close the topic because this call succeeded. If `queued_for_team` is `false` the team was NOT notified — say so instead of implying they were. When your `urgency_level` was out-of-enum it is coerced to `urgent` and disclosed via `{coerced_urgency, requested_urgency_level}`. A `details.category` outside the enum is dropped to `null` and disclosed via `{coerced_category, requested_category}`.\n\n**Side effects:** Emits `MEDICAL_ESCALATION_TRIGGERED`; the runtime routes it to the team by level (pages at `stat`/`asap`, ticket at `urgent`/`routine`).',
+  'description': '**Does:** Escalates a MEDICAL situation to the oncology care team at a chosen urgency, with an explicit justification for the level. Covers the full medical-urgency spectrum — immediate emergencies through asynchronous team review. One-way commit; the payload is INTERNAL — the patient never sees it.\n\n**Required inputs:** `urgency_level` — the FHIR request-priority code (`stat` | `asap` | `urgent` | `routine`), `urgency_justification` (one or two sentences: why this level AND why not the tier above/below — the auditable decision record), `details` (object — `symptom` + `evidence_quote` required; pass `null` when unknown for `category`, `indicators`, `suspected_condition`, `recommended_action`).\n\n**Urgency levels:** FHIR request-priority, a RELATIVE order `routine` < `urgent` < `asap` < `stat` (priority/speed, not a fixed clock). The full per-tier rubric with clinical examples lives on the `urgency_level` input enum — read it there. Out-of-enum values are coerced to `urgent` and disclosed via `coerced_urgency` on the result.\n\n**Neurological constellation override:** TWO OR MORE of — visual change, dizziness/vertigo/loss of balance, inability to walk/stand, focal weakness/numbness, acute confusion, sudden severe headache — reported this turn or across the last 2–3 turns → escalate without a further clarifying question: `asap` by default, `stat` if there is an acute deficit (can\'t walk/stand, sphincter loss, bilateral leg weakness → possible cord compression) or any instability.\n\n**When NOT to call:**\n- Unconfirmed/unspecific symptom — ask ONE characterization question via `DeliverPatientMessage` first.\n- Active mental-health crisis — use `reportCrisis`.\n- Patient shared lab/imaging/values/files — use `reportResultsReceived`.\n- Administrative / operative matter (appointments, insurance, authorizations, letters, transport, scheduling, out-of-scope request) or a non-clinical referral (psico-oncología, paliativos, non-oncology medical) — use `reportUnresolvedRequestv2`.\n- Twice in the same turn for the same episode — already committed; a later datum belongs to the same open escalation.\n\n**After the commit:** the escalation does not end the conversation.\n- **Patient message** (`DeliverPatientMessage`, calm, ≤60 words): acknowledge what they told you → \'Ya avisé al equipo médico\' → ONE concrete next step → a safety net specific to THIS case (1–2 observable signs and what to do if they appear) → availability. Explain the purpose in everyday words. Reassure with the plan (\'ya le avisé al equipo médico para que lo revise\', \'vamos a darle seguimiento contigo\'), never with promises (\'no es nada\', \'no te preocupes\'). No diagnosis names, no lists of alarming symptoms, no \'grave/peligroso\', no timed fallback (\'si en 15 minutos…\'), and no promised contact time — not even \'te contactan hoy en las próximas horas\'; say what the team was asked to do (\'le pedí al equipo médico que lo revise\'), never that someone is already reviewing it, and not when they will reach out.\n- **By level:** `stat` is the ONLY level that sends the patient now — calm and unambiguous: ve a urgencias ahora, acompañado; 911 (or an ambulance) if they are alone with no one to take them, cannot move safely, or are unstable — being alone counts as unsafe transport, and they never drive themselves. ' + FEVER_RULE + '`asap`: do NOT lead with urgencias — it appears only in the conditional safety net (if [sign] appears or they feel much worse). `urgent`: they can stay home; urgencias only as a worsening-sign safety net. `routine`: acknowledgement, what to watch, when to write again.\n- **Keep characterizing (except `stat`):** in the same message ask the ONE question that most helps the team; in later turns keep going, one question per message, and give high-value guidance that does not prescribe (comfort measures already in their plan or indicated by the team, what to have at hand, how to monitor). Each new datum goes to the SAME open escalation, not a new one: raise the level if it makes something more serious plausible; never lower it. In `stat`, after the instruction only confirm they are on their way and accompanied.\n\n**Returns:** a RECEIPT, not a resolution — `{urgency_level, queued_for_team, safety_net_armed, safety_net_reason, team_has_reviewed, means, follow_up}`. `safety_net_armed` is `true`/`false`/`null`, where **`null` means this urgency tier gets no automatic check-in at all** (`routine`); read `follow_up` and make the fallback explicit to the patient whenever nothing is armed. `queued_for_team` says only that the ticket was written; `team_has_reviewed` is always `false` here because nothing on this path can know otherwise. Treat the escalation as OPEN and still your responsibility for the rest of the conversation: never tell the patient the team already reviewed it, and never close the topic because this call succeeded. If `queued_for_team` is `false` the team was NOT notified — say so instead of implying they were. When your `urgency_level` was out-of-enum it is coerced to `urgent` and disclosed via `{coerced_urgency, requested_urgency_level}`. A `details.category` outside the enum is dropped to `null` and disclosed via `{coerced_category, requested_category}`.\n\n**Side effects:** Emits `MEDICAL_ESCALATION_TRIGGERED`; the runtime routes it to the team by level (pages at `stat`/`asap`, ticket at `urgent`/`routine`).',
   'strict': true,
   'parameters': {
     'type': 'object',
@@ -153,6 +155,19 @@ const MODE_PROPERTY = {
 
 const MODE_DESCRIPTION = '\n\n**mode:** `new` abre un aviso; `update` actualiza la escalación abierta y nunca baja su nivel. Lo que el paciente responde después de escalar va con `update`. El `urgency_level` del recibo es el nivel aplicado: puede ser mayor que el que pediste, nunca menor.';
 
+const FEVER_RULE_TIMER = 'Fever within 6 weeks (42 days) of cytotoxic chemotherapy (or with a hematologic cancer, transplant, known neutropenia) — ≥38.0 °C, ≤36.0 °C, feeling feverish or chills with no thermometer, or malaise while on an antipyretic or steroid — is `asap` with `category: febrile_neutropenia`. It is `stat` only with a clear, confirmed red flag (clear shortness of breath, clear confusion, strong rigors, mottled skin, bleeding), or any fever within 4 weeks of CAR-T or during bispecific step-up dosing — say it calmly: "ve a urgencias ahora y di que estás en tratamiento oncológico" (CAR-T / bispecific: call the treating center first). If you don\'t know the treatment or the last dose date, ask in the same message. 37.5–37.9 °C in that window is `urgent`: remeasure in 30–60 min. ';
+
+const CHEMO_WINDOW_PROPERTY = nullable({
+  'type': 'object',
+  'description': 'Quimioterapia citotóxica, del expediente o de lo que el paciente confirmó. Requerida y confirmada para `febrile_neutropenia`; pasa `null` si no está confirmada. No la supongas.',
+  'properties': {
+    'on_cytotoxic_chemo': { 'type': 'boolean' },
+    'days_since_last_cycle': nullable({ 'type': 'integer' }),
+  },
+  'required': ['on_cytotoxic_chemo', 'days_since_last_cycle'],
+  'additionalProperties': false,
+});
+
 const CLINICAL_ASSESSMENT_PROPERTY = nullable({
   'type': 'object',
   'description': 'Tu razonamiento clínico, estructurado para auditoría. Todos los campos aceptan `null`. No cambia el nivel: el nivel lo decides tú en `urgency_level`.',
@@ -195,7 +210,8 @@ const CLINICAL_ASSESSMENT_PROPERTY = nullable({
 function liveDefinition() {
   const updateMode = escalationUpdateModeLive();
   const assessment = escalationAssessmentLive();
-  if (!updateMode && !assessment) return definition;
+  const feverTimer = feverPatientTimerLive();
+  if (!updateMode && !assessment && !feverTimer) return definition;
   const live = structuredClone(definition);
   const { properties, required } = live.parameters;
   if (updateMode) {
@@ -207,9 +223,21 @@ function liveDefinition() {
     properties.details.properties.clinical_assessment = CLINICAL_ASSESSMENT_PROPERTY;
     properties.details.required.push('clinical_assessment');
   }
+  if (feverTimer) {
+    live.description = live.description.replace('`recommended_action`).', '`recommended_action`, `chemo_window`).');
+    live.description = live.description.replace(FEVER_RULE, FEVER_RULE_TIMER);
+    properties.details.properties.chemo_window = CHEMO_WINDOW_PROPERTY;
+    properties.details.required.push('chemo_window');
+  }
   return live;
 }
 
+function chemoWindowOf(raw) {
+  if (!isPlainObject(raw) || typeof raw.on_cytotoxic_chemo !== 'boolean') return null;
+  const days = raw.days_since_last_cycle;
+  return { onCytotoxicChemo: raw.on_cytotoxic_chemo, daysSinceLastCycle: Number.isInteger(days) && days >= 0 ? days : null };
+}
+
 const yesNo = (value) => (value === true ? 'sí' : value === false ? 'no' : null);
 
 function knownExplanationNote(known) {
@@ -306,6 +334,7 @@ async function handler(args, context = {}) {
           indicators: (Array.isArray(details.indicators) ? details.indicators : [])
             .filter((indicator) => typeof indicator === 'string' && indicator.trim()),
           turnId: runtime.turnId || null,
+          chemoWindow: chemoWindowOf(details.chemo_window),
           ...(clinicalAssessment ? { clinicalAssessment } : {}),
         },
       })
@@ -324,6 +353,9 @@ async function handler(args, context = {}) {
     const raisedByPattern = Boolean(patternFloor) && (URGENCY_RANK[patternFloor.level] || 0) > (URGENCY_RANK[flooredLevel] || 0);
     const urgencyLevel = raisedByPattern ? patternFloor.level : flooredLevel;
     const raisesOpen = !anchor || (URGENCY_RANK[urgencyLevel] || 0) > (URGENCY_RANK[anchor.urgencyLevel] || 0);
+    // Recorded on the alarm now, not only with the emergency row, so a floor-raised level is never
+    // treated by the review as the level the bot asked for.
+    if (review && (raisedByGate || raisedByPattern)) await setAlarmAppliedLevel({ reviewId: review._id, alarmId, appliedLevel: urgencyLevel });
 
     trace.setSafetyDecision({ ...(trace.safetyDecision || {}), escalationKind: 'medical_urgent' });
     trace.setSignals({

package/lib/core/NexusMessaging.js

@@ -33,7 +33,7 @@ const { beginInstruction, endInstruction } = require('../services/instructionInF
 const { QueueReconciliationService } = require('../services/queueReconciliationService');
 const { releaseHeldMessages, sweepHeldMessages } = require('../services/heldMessageService');
 
-const { BatchingManager } = require('../core/BatchingManager');
+const { BatchingManager, DrainingError } = require('../core/BatchingManager');
 const { ProcessingPipeline } = require('../core/ProcessingPipeline');
 const { preProcessMessages, configureOpenAIProvider, AssistantProcessor, TURN_KIND } = require('../clinical');
 const { deliveryOutcome } = require('../clinical/AssistantProcessor');
@@ -830,7 +830,13 @@ class NexusMessaging {
     }, shouldContinue, runId);
   }
 
-  async processInstruction(code, instruction, role = 'developer', { triggeredBy } = {}) {
+  /*
+   * `beforeRun`, when given, is asked under the chat lock right before the turn (and before every retry);
+   * a truthy reason vetoes the turn. Such a gated instruction never rides along in another instruction's
+   * batch, and is marked processed when vetoed or refused by a draining instance, so it can only ever
+   * run behind its own gate.
+   */
+  async processInstruction(code, instruction, role = 'developer', { triggeredBy, beforeRun = null } = {}) {
     const receivedAt = Date.now();
     const messageData = {
       pushName: 'Instruction',
@@ -840,33 +846,58 @@ class NexusMessaging {
       fromMe: true,
       processed: false,
       origin: 'instruction',
-      raw: { role },
+      raw: beforeRun ? { role, gated: true } : { role },
       triggeredBy: triggeredBy || null,
       silent: true,
     };
 
     beginInstruction(code);
     try {
-      await this.phiProcessor.inData(
+      return await this.phiProcessor.inData(
         messageData,
         this._saveMessageFn,
         async ({ body, _id }) => {
           if (this.batchingConfig.instructionSettleMs > 0 && !this.batchingManager.isDraining()) {
             await new Promise(resolve => setTimeout(resolve, this.batchingConfig.instructionSettleMs));
           }
+          const markOwnProcessed = async () => {
+            if (!_id) return;
+            try {
+              await updateMessage({ _id }, { $set: { processed: true } });
+            } catch (err) {
+              logger.error('[processInstruction] Could not mark a gated instruction processed', { error: err.message, code });
+            }
+          };
           let batchIds = [];
           let outcome = null;
           let runId = null;
+          let gate = null;
+          let alreadyAnswered = false;
           const answerPending = () => {
             batchIds = [];
             outcome = null;
             runId = null;
+            gate = null;
+            alreadyAnswered = false;
             return this._executeWithPipeline(code, 'instruction', 'queue',
               async (preProcessResult, shouldContinue, currentRunId) => {
                 runId = currentRunId;
+                if (beforeRun) {
+                  try {
+                    const reason = await beforeRun();
+                    if (reason) gate = { outcome: 'gated', reason };
+                  } catch (err) {
+                    gate = { outcome: 'gate_error', error: err.message };
+                  }
+                  if (gate) {
+                    await markOwnProcessed();
+                    return null;
+                  }
+                }
                 const batch = await this._pendingInstructionBatch(code, _id, body, receivedAt);
                 if (!batch.length) {
                   logger.info('[processInstruction] Instruction already answered by an earlier run', { code, runId });
+                  alreadyAnswered = true;
                   return null;
                 }
                 batchIds = batch.map(m => m._id).filter(Boolean);
@@ -899,15 +930,26 @@ class NexusMessaging {
           const needsAnotherTurn = () => batchIds.length > 0
             && ((outcome === null && this.batchingManager.isAbandoned(runId)) || outcome === 'known_not_sent');
 
-          let runResult = await answerPending();
+          const answer = async () => {
+            try {
+              return await answerPending();
+            } catch (err) {
+              if (beforeRun && err instanceof DrainingError) await markOwnProcessed();
+              throw err;
+            }
+          };
+          await answer();
           if (needsAnotherTurn()) {
             logger.warn('[processInstruction] Instruction reply was not sent; queueing one more turn', { code, outcome });
-            runResult = await answerPending();
+            await answer();
           }
           if (batchIds.length && outcome !== 'sent' && outcome !== 'unknown') {
             logger.error('[processInstruction] Instruction left unanswered', { code, outcome, instructionIds: batchIds.map(String) });
           }
-          return runResult;
+          // Only the send outcome goes back: the turn's output was already delivered, and handing it to
+          // the caller would invite a second send.
+          if (gate) return gate;
+          return { outcome: outcome === null && alreadyAnswered ? 'already_answered' : outcome };
         },
       );
     } finally {
@@ -923,7 +965,7 @@ class NexusMessaging {
           numero: code,
           origin: 'instruction',
           message_id: /^instruction_/,
-          $or: [{ _id: ownId }, { processed: false, createdAt: { $gte: new Date(receivedAt - PENDING_INSTRUCTION_WINDOW_MS) } }],
+          $or: [{ _id: ownId }, { processed: false, 'raw.gated': { $ne: true }, createdAt: { $gte: new Date(receivedAt - PENDING_INSTRUCTION_WINDOW_MS) } }],
         },
         { sort: { _id: 1 }, select: '_id body processed' },
       );

package/lib/index.d.ts

@@ -272,7 +272,7 @@ declare module '@peopl-health/nexus' {
     getLlmMonitor(): { start(options?: { scheduleDaily?: boolean }): Promise<{ enabled: boolean }> } | null;
     initializeLlmMonitor(): Promise<{ enabled: boolean; error?: string } | undefined>;
     getWorkflowRunner(): WorkflowRunner;
-    processInstruction(code: string, instruction: string, role?: string, options?: { triggeredBy?: string }): Promise<void>;
+    processInstruction(code: string, instruction: string, role?: string, options?: { triggeredBy?: string; beforeRun?: () => Promise<string | null | undefined> | string | null | undefined }): Promise<{ outcome: string | null; reason?: string; error?: string }>;
     processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<void>;
     processOutreach(code: string, options?: { brief?: OutreachBrief | null; triggeredBy?: string | null; reason?: string | null; firstName?: string | null; dryRun?: boolean }): Promise<OutreachDecision>;
     processScheduledFollowUp(code: string, options: { reminderId: string; firstName: string; now?: Date }): Promise<ScheduledFollowUpResult>;

package/lib/models/escalationReviewModel.js

@@ -16,6 +16,11 @@ const DOCTOR_DECISIONS = ['approved', 'edited_approved', 'needs_intervention', '
 const DECISION_SOURCES = ['platform', 'registered_by_navigator', 'chat'];
 const RETURN_REASONS = ['llamar', 'falta_dato', 'no_requiere'];
 
+const chemoWindowSchema = new mongoose.Schema({
+  onCytotoxicChemo: { type: Boolean, default: null },
+  daysSinceLastCycle: { type: Number, default: null },
+}, { _id: false });
+
 const alarmSchema = new mongoose.Schema({
   alarmId: { type: String, default: null },
   urgencyLevel: { type: String, enum: URGENCY_LEVELS, required: true },
@@ -30,6 +35,7 @@ const alarmSchema = new mongoose.Schema({
   clinicalAssessment: { type: mongoose.Schema.Types.Mixed, default: null },
   emergencyRecordId: { type: String, default: null },
   appliedLevel: { type: String, default: null },
+  chemoWindow: { type: chemoWindowSchema, default: null },
   raisedAt: { type: Date, required: true },
 }, { _id: false });
 
@@ -44,13 +50,14 @@ const impressionUpdateSchema = new mongoose.Schema({
 }, { _id: false });
 
 const doctorAlertSchema = new mongoose.Schema({
-  kind: { type: String, enum: ['initial', 'realert'], required: true },
+  kind: { type: String, enum: ['initial', 'realert', 'patient_prompt'], required: true },
   urgencyLevel: { type: String, enum: URGENCY_LEVELS, default: null },
   physicianEmail: { type: String, default: null },
   transport: { type: String, default: null },
   messageId: { type: String, default: null },
   error: { type: String, default: null },
   teamAlerted: { type: Boolean, default: false },
+  possiblyDelivered: { type: Boolean, default: false },
   sentAt: { type: Date, required: true },
 }, { _id: false });
 
@@ -198,8 +205,9 @@ const escalationReviewSchema = new mongoose.Schema({
   draftFailedAt: { type: Date, default: null },
   doctorAlerts: { type: [doctorAlertSchema], default: [] },
   doctorAlertDueAt: { type: Date, default: null },
-  doctorAlertKind: { type: String, enum: ['initial', 'realert', null], default: null },
+  doctorAlertKind: { type: String, enum: ['initial', 'realert', 'patient_prompt', null], default: null },
   doctorAlertAttempts: { type: Number, default: 0 },
+  feverPromptStartedAt: { type: Date, default: null },
   approverViewedAt: { type: Date, default: null },
   previousReviewId: { type: String, default: null },
   callLogs: { type: [callLogSchema], default: [] },

package/lib/services/escalationReviewService.js

@@ -23,19 +23,24 @@ const {
 const { getPatientAuditLog } = require('../models/patientAuditLogModel');
 const { isWithin24HourWindow } = require('../helpers/conversationWindowHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
+const { DrainingError } = require('../core/BatchingManager');
 const { generateEscalationDraft } = require('../clinical/services/escalationDraftService');
-const { conversationLink, recordEmergency, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
+const { conversationLink, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
 const { renderDoctorMessage, templateSummary, withIdentity } = require('../clinical/helpers/doctorReviewMessageHelper');
 const { generateKeyQuestions } = require('../clinical/services/escalationQuestionsService');
 const { drugsNamedIn } = require('../clinical/services/treatmentProposalService');
 const { characterizationSeedOf } = require('../clinical/helpers/reviewUpdateHelper');
 const { readNoteFacts, assertionOf } = require('../clinical/services/escalationNoteFactsService');
+const { humanReplyFilter } = require('../clinical/config/safetyNetConfig');
+const { feverPatientTimerLive: feverTimerLive } = require('../clinical/flags/escalationFlags');
+const { composePrompt } = require('../clinical/services/promptComposerService');
 const { storeContextFacts, readContextFacts } = require('../fhir/services/clinicalContextService');
 
 const { getPatientInformation, logPatientChange } = require('./patientService');
 const { MAX_NOTE_LENGTH, getPatientTasks, openCaseIds, updatePatientTask } = require('./patientTaskService');
+const { countMessages } = require('./messageService');
 const { getEscalationApprover, listEscalationApprovers } = require('./physicianService');
-const { switchThreadStoppedStatus } = require('./threadService');
+const { getThreadInfo, switchThreadStoppedStatus } = require('./threadService');
 const { effectiveUrgencyOf, responseDeadlineOf, responseDeadlinePolicy } = require('./reviewDeadlineService');
 
 const getMessaging = () => require('../core/NexusMessaging');
@@ -49,6 +54,7 @@ const DRAFT_OPERATOR = 'bot:escalationDraft';
 const DIRECT_CHAT_ATTEMPTS = 3;
 const RECHECK_DELAY_MS = 60 * 1000;
 const ALERT_RETRY_DELAY_MS = 2 * 60 * 1000;
+const MAX_ALERT_ATTEMPTS = 3;
 const BOOKKEEPING = { timestamps: false };
 const PREVIOUS_REVIEW_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
 const DUPLICATE_KEY_ERROR = 11000;
@@ -63,7 +69,12 @@ const DRAFTLESS_DECISIONS = ['monitor', 'returned'];
 const SETTLED_TRAJECTORIES = ['improving', 'stable'];
 const ALERTED_URGENCIES = ['stat', 'asap'];
 const ALERT_MARKS = { stat: '🔴', asap: '🟠' };
-const DEFAULT_STAT_REALERT_MINUTES = 15;
+const DEFAULT_FEVER_TIMER_MINUTES = 15;
+const DEFAULT_FEVER_CHEMO_WINDOW_DAYS = 42;
+const FEVER_TIMER_PROMPT_ID = 'fever_patient_timer';
+const FEVER_TIMER_OPERATOR = 'fever_patient_timer';
+const FEVER_CATEGORY = 'febrile_neutropenia';
+const STAFF_ORIGINS = ['whatsapp_platform', 'instruction', 'system'];
 const PRE_DECISION_STATUSES = ['open', 'documenting', 'draft_ready', 'handing_off', 'awaiting_doctor'];
 const ALERT_OPERATOR = 'bot:escalationAlert';
 const RECLASSIFIABLE_STATUSES = [...DOCUMENTING_STATUSES, 'awaiting_doctor'];
@@ -541,6 +552,7 @@ async function recordEscalationAlarm({ code, alarm, now = new Date() } = {}) {
     const joined = await join();
     if (joined) {
       await scheduleDoctorAlert(joined, entry, now);
+      await armFeverTimerOnJoin(joined, entry, now);
       if (FOLLOWUP_STATUSES.includes(joined.status)) return await reopenFromFollowUp(joined, 'new_alarm');
       if (!DOCUMENTING_STATUSES.includes(joined.status)) {
         logger.error('[EscalationReview] An alarm arrived after the doctor already had the case', {
@@ -597,6 +609,20 @@ async function attachEmergencyRow({ reviewId, alarmId, emergencyRecordId, applie
   }
 }
 
+async function setAlarmAppliedLevel({ reviewId, alarmId, appliedLevel }) {
+  try {
+    await getEscalationReview().updateOne(
+      { _id: reviewId, 'alarms.alarmId': alarmId },
+      { $set: { 'alarms.$.appliedLevel': appliedLevel } },
+      { timestamps: false },
+    );
+  } catch (error) {
+    logger.error('[EscalationReview] The applied level was not recorded on its alarm', {
+      error: error.message, stack: redactedStack(error),
+    });
+  }
+}
+
 async function openEscalationReview({
   code,
   patientCaseRecordId = null,
@@ -892,19 +918,105 @@ async function scheduleDoctorAlert(review, alarm, now) {
   }
 }
 
-const statRealertMs = () => {
-  const minutes = Number(runtimeConfig.get('ESCALATION_REVIEW_STAT_REALERT_MINUTES', DEFAULT_STAT_REALERT_MINUTES));
-  return (Number.isFinite(minutes) && minutes > 0 ? minutes : DEFAULT_STAT_REALERT_MINUTES) * 60 * 1000;
+const feverTimerMs = () => {
+  const minutes = Number(runtimeConfig.get('FEVER_PATIENT_TIMER_MINUTES', DEFAULT_FEVER_TIMER_MINUTES));
+  return (Number.isFinite(minutes) && minutes > 0 ? minutes : DEFAULT_FEVER_TIMER_MINUTES) * 60 * 1000;
 };
 
-function answeredSince(review, since) {
-  const sinceMs = new Date(since).getTime();
-  if (!PRE_DECISION_STATUSES.includes(review.status)) return true;
-  if (review.approverViewedAt && new Date(review.approverViewedAt).getTime() >= sinceMs) return true;
-  return (review.decisions ?? []).some((decision) => decision.createdAt && new Date(decision.createdAt).getTime() >= sinceMs);
+const feverChemoWindowDays = () => {
+  const days = Number(runtimeConfig.get('FEVER_CHEMO_WINDOW_DAYS', DEFAULT_FEVER_CHEMO_WINDOW_DAYS));
+  return Number.isFinite(days) && days > 0 ? days : DEFAULT_FEVER_CHEMO_WINDOW_DAYS;
+};
+
+const appliedLevelOf = (alarm) => alarm.appliedLevel || alarm.urgencyLevel;
+
+const feverAlarmsOf = (review) => currentAlarms(review)
+  .filter((alarm) => appliedLevelOf(alarm) === 'asap' && alarm.category === FEVER_CATEGORY);
+
+// The timer is only for a patient confirmed on cytotoxic chemotherapy with a known last cycle inside the
+// window; anything short of that (unknown, off chemo, no date, too long ago) leaves it unarmed.
+function chemoWindowGap(alarm) {
+  const chemo = alarm?.chemoWindow;
+  if (!chemo) return 'chemo_window_missing';
+  if (chemo.onCytotoxicChemo !== true) return 'not_on_cytotoxic_chemo';
+  const days = chemo.daysSinceLastCycle;
+  if (!Number.isInteger(days)) return 'days_since_last_cycle_missing';
+  return days >= 0 && days <= feverChemoWindowDays() ? null : 'outside_chemo_window';
 }
 
-async function prepareDoctorAlert(review, kind, urgencyLevel) {
+function feverTimerGap(review) {
+  const fevers = feverAlarmsOf(review);
+  if (fevers.some((alarm) => !chemoWindowGap(alarm))) return null;
+  return chemoWindowGap(fevers.at(-1));
+}
+
+// The timer runs from the first asap alert of this episode, so a retried alert never restarts it and a
+// decision taken after it (which counts as taking the case) never moves it.
+function feverTimerSince(review) {
+  const asapAlerts = (review.doctorAlerts ?? []).filter((sent) => sent.kind === 'initial' && sent.urgencyLevel === 'asap');
+  if (!asapAlerts.length) return null;
+  const lastMs = new Date(asapAlerts.at(-1).sentAt).getTime();
+  const decidedMs = Math.max(-Infinity, ...(review.decisions ?? [])
+    .map((decision) => new Date(decision.createdAt).getTime())
+    .filter((ms) => ms < lastMs));
+  return new Date(asapAlerts.find((sent) => new Date(sent.sentAt).getTime() > decidedMs).sentAt);
+}
+
+// One prompt per episode: a prompt delivered (or possibly delivered) since the episode began, or one whose
+// turn is still running, blocks another; an errored or dropped attempt does not. `ownStart` is the
+// marker of the run asking, so its own in-flight marker never blocks it.
+function promptedSince(review, since, ownStart = null) {
+  const sinceMs = since.getTime();
+  const delivered = (review.doctorAlerts ?? [])
+    .some((sent) => sent.kind === 'patient_prompt' && (!sent.error || sent.possiblyDelivered) && new Date(sent.sentAt).getTime() >= sinceMs);
+  const startedMs = review.feverPromptStartedAt ? new Date(review.feverPromptStartedAt).getTime() : null;
+  return delivered || (startedMs != null && startedMs >= sinceMs && startedMs !== ownStart?.getTime());
+}
+
+// An approver merely opening the review does not count: only an answer, a stat escalation, a paused
+// thread or a staff member writing to the patient means someone took the case.
+async function feverTakenReason(review, since, ownStart = null) {
+  // Staff acting before the fever reached the review (on an earlier asap of the same episode) did not
+  // take the fever case: those signals count only from the first asap fever alarm onwards.
+  const firstFever = feverAlarmsOf(review)[0];
+  const from = new Date(Math.max(since.getTime(), firstFever ? new Date(firstFever.raisedAt).getTime() : -Infinity));
+  const atOrAfter = (at) => at != null && new Date(at).getTime() >= from.getTime();
+  if (review.closedAt || !PRE_DECISION_STATUSES.includes(review.status)) return 'review_moved_on';
+  if (promptedSince(review, since, ownStart)) return 'already_prompted';
+  if ((review.decisions ?? []).some((decision) => atOrAfter(decision.createdAt))) return 'decision';
+  const stat = (alarm) => alarm.urgencyLevel === 'stat' || alarm.appliedLevel === 'stat';
+  if (currentAlarms(review).some(stat)) return 'stat_alarm';
+  if ((review.urgencyReclassifications ?? []).some((change) => atOrAfter(change.at))) return 'reclassified';
+  if ((review.callLogs ?? []).some((call) => call.outcome === 'contacted' && atOrAfter(call.calledAt))) return 'call_contacted';
+  // A read error goes back to the sweep to retry; only a thread that does not exist (no turn to run
+  // anyway) skips the prompt.
+  const thread = await getThreadInfo(review.patientCode, { rethrow: true });
+  if (!thread) return 'thread_missing';
+  if (thread.stopped === true) return 'thread_paused';
+  // Staff write from the platform or act through add-instruction / add-msg, always under their email;
+  // automations (the timer itself included) sign with a name and never count.
+  const staffMessages = await countMessages({ ...humanReplyFilter(review.patientCode, from), origin: { $in: STAFF_ORIGINS }, $and: [{ triggeredBy: /@/ }] });
+  return staffMessages ? 'staff_message' : null;
+}
+
+async function armFeverTimerOnJoin(review, alarm, now) {
+  try {
+    if (!feverTimerLive() || appliedLevelOf(alarm) !== 'asap' || alarm.category !== FEVER_CATEGORY || chemoWindowGap(alarm)) return;
+    if (alertedRankOf(review) !== URGENCY_RANK.asap) return;
+    const since = feverTimerSince(review);
+    if (!since || promptedSince(review, since)) return;
+    // The patient gets the full timer from when the case became eligible, not from the earlier alert.
+    await getEscalationReview().updateOne(
+      { _id: review._id, doctorAlertDueAt: null },
+      { $set: { doctorAlertDueAt: new Date(now.getTime() + feverTimerMs()), doctorAlertKind: 'patient_prompt', doctorAlertAttempts: 0 } },
+      BOOKKEEPING,
+    );
+  } catch (error) {
+    logger.error('[EscalationReview] The fever patient timer was not set for a joining alarm', { escalationReviewId: String(review?._id), error: redactedError(error) });
+  }
+}
+
+async function prepareDoctorAlert(review, urgencyLevel) {
   const identity = await readDoctorIdentity(review);
   if (identity.missing.length) throw new Error(`missing ${identity.missing.join(' and ')}`);
   const approver = await soleApprover();
@@ -912,7 +1024,7 @@ async function prepareDoctorAlert(review, kind, urgencyLevel) {
   if (!link) throw new Error('missing the interface URL for the chat link');
   const alarm = (review.alarms ?? []).findLast((raised) => raised.urgencyLevel === urgencyLevel) ?? review.alarms?.at(-1);
   const symptom = inlineOf(alarm?.symptom);
-  const urgency = [kind === 'realert' && 'Sigue pendiente', urgencyLevel.toUpperCase()].filter(Boolean).join(' · ');
+  const urgency = urgencyLevel.toUpperCase();
   const patient = `${identity.patientName} (${identity.treatingDoctor})`;
   const message = {
     body: `${ALERT_MARKS[urgencyLevel]} ${[urgency, patient, symptom].filter(Boolean).join(' · ')}\n${link}`,
@@ -933,7 +1045,98 @@ const topUrgencyOf = (review) => {
     .reduce((top, alarm) => (URGENCY_RANK[alarm.urgencyLevel] > (URGENCY_RANK[top] || 0) ? alarm.urgencyLevel : top), null);
 };
 
-const realertStillDue = (review, initial) => !review.closedAt && Boolean(initial) && !answeredSince(review, initial.sentAt);
+const SENT_OUTCOMES = ['sent', 'unknown', 'already_answered'];
+
+async function sendPatientPrompt({ id, release, lease, now }) {
+  const review = await loadReview(reviewIdOf(id));
+  const skip = async (current, reason) => {
+    await release();
+    await audit(current, ALERT_OPERATOR, null, { action: 'patient_prompt_skipped', reason });
+    return null;
+  };
+  if (!feverTimerLive()) return skip(review, 'flag_off');
+  const since = feverTimerSince(review);
+  if (!since) return skip(review, 'no_asap_alert');
+  const taken = await feverTakenReason(review, since);
+  if (taken) return skip(review, taken);
+
+  let directive;
+  try {
+    directive = String((await composePrompt({ promptId: FEVER_TIMER_PROMPT_ID }))?.resolvedPrompt ?? '').trim();
+  } catch (composeError) {
+    // A failed read may be transient: the same slot comes back shortly, and the sweep's attempt cap
+    // drops it (with a ledger entry) if Airtable stays unreachable.
+    logger.error('[EscalationReview] The fever patient prompt could not be read; trying again shortly', { escalationReviewId: String(review._id), error: redactedError(composeError) });
+    await release({ doctorAlertDueAt: new Date(Date.now() + ALERT_RETRY_DELAY_MS), doctorAlertKind: 'patient_prompt' });
+    return null;
+  }
+  let error = directive ? null : `the ${FEVER_TIMER_PROMPT_ID} prompt is empty or missing`;
+  let outcome = null;
+  let startedAt = null;
+  const settle = () => getEscalationReview()
+    .updateOne({ _id: review._id, feverPromptStartedAt: startedAt }, { $set: { feverPromptStartedAt: null } }, BOOKKEEPING);
+  if (error) {
+    logger.error('[EscalationReview] The fever patient prompt has no directive; nothing was sent', { escalationReviewId: String(review._id), error });
+    await release();
+  } else {
+    const fresh = await loadReview(review._id);
+    const takenNow = await feverTakenReason(fresh, since);
+    if (takenNow) return skip(fresh, takenNow);
+    // The instruction runs a whole agent turn, which can outlast the sweep's lease; letting go of the
+    // slot first keeps a second sweep from prompting the patient twice.
+    const released = await release();
+    if (lease && !released?.modifiedCount) {
+      await audit(fresh, ALERT_OPERATOR, null, { action: 'lease_lost' });
+      return null;
+    }
+    // While the turn runs, this marker stops both arming paths from setting a second prompt; it is
+    // cleared once the turn settles, after the ledger entry that takes over is written.
+    startedAt = new Date();
+    await getEscalationReview().updateOne({ _id: review._id }, { $set: { feverPromptStartedAt: startedAt } }, BOOKKEEPING);
+    // No turn ran: the same prompt comes back shortly, under the sweep's attempt cap. A draining
+    // instance refused it before doing anything, so that refusal does not use up an attempt.
+    const rearm = async (why) => {
+      logger.warn('[EscalationReview] The fever patient prompt ran no turn; trying again shortly', { escalationReviewId: String(review._id), why });
+      const attempts = review.doctorAlertAttempts ?? 0;
+      await settle();
+      await getEscalationReview().updateOne(
+        { _id: review._id, doctorAlertDueAt: null },
+        { $set: { doctorAlertDueAt: new Date(Date.now() + ALERT_RETRY_DELAY_MS), doctorAlertKind: 'patient_prompt', doctorAlertAttempts: why === 'draining' ? Math.max(0, attempts - 1) : attempts } },
+        BOOKKEEPING,
+      );
+      return null;
+    };
+    // The gate runs again under the chat lock, right before the turn: a patient turn queued ahead of
+    // this one can raise the case to stat, pause the bot or bring staff in while the prompt waits.
+    const beforeRun = async () => feverTakenReason(await loadReview(review._id), since, startedAt);
+    try {
+      const result = await getMessaging().processInstruction(review.patientCode, directive, 'developer', { triggeredBy: FEVER_TIMER_OPERATOR, beforeRun });
+      outcome = result?.outcome ?? null;
+      if (outcome === 'gated') {
+        await settle();
+        await audit(fresh, ALERT_OPERATOR, null, { action: 'patient_prompt_skipped', reason: result.reason });
+        return null;
+      }
+      if (outcome === 'gate_error') return rearm(result.error ?? 'gate_error');
+      if (outcome === null) return rearm('no_turn');
+      // A send that threw ('threw') may still have reached the patient: recorded as possibly delivered,
+      // so it is never sent again this episode.
+      if (!SENT_OUTCOMES.includes(outcome)) error = `the instruction turn was not sent (outcome: ${outcome})`;
+    } catch (sendError) {
+      // processInstruction swallows send errors (they come back as 'threw'), so a throw here means no
+      // send happened: the same prompt comes back under the sweep's attempt cap.
+      return rearm(sendError instanceof DrainingError ? 'draining' : redactedError(sendError));
+    }
+    if (error) logger.error('[EscalationReview] The fever patient prompt was not sent', { escalationReviewId: String(review._id), error });
+  }
+
+  const sent = { kind: 'patient_prompt', urgencyLevel: 'asap', error, ...(outcome === 'threw' ? { possiblyDelivered: true } : {}), sentAt: now };
+  const updated = await getEscalationReview()
+    .findOneAndUpdate({ _id: review._id }, { $push: { doctorAlerts: sent } }, { ...BOOKKEEPING, new: true }).lean();
+  if (startedAt) await settle();
+  await audit(updated ?? review, ALERT_OPERATOR, null, { action: 'patient_prompted', delivered: !error, outcome });
+  return updated;
+}
 
 async function sendScheduledDoctorAlert({ id, kind, lease = null, now = new Date() } = {}) {
   const EscalationReview = getEscalationReview();
@@ -941,34 +1144,33 @@ async function sendScheduledDoctorAlert({ id, kind, lease = null, now = new Date
   const release = (set = { doctorAlertDueAt: null, doctorAlertKind: null, doctorAlertAttempts: 0 }) => EscalationReview
     .updateOne({ _id: id, ...ours }, { $set: set }, BOOKKEEPING);
 
-  const review = await loadReview(reviewIdOf(id));
-  if (review.closedAt || !PRE_DECISION_STATUSES.includes(review.status)) {
+  // Stat re-alerts were retired; a review that still holds one lets the slot go without sending.
+  if (kind === 'realert') {
     await release();
     return null;
   }
-  const initial = (review.doctorAlerts ?? []).filter((sent) => sent.kind === 'initial').at(-1);
-  if (kind === 'realert' && !realertStillDue(review, initial)) {
+  if (kind === 'patient_prompt') return sendPatientPrompt({ id, release, lease, now });
+
+  const review = await loadReview(reviewIdOf(id));
+  if (review.closedAt || !PRE_DECISION_STATUSES.includes(review.status)) {
     await release();
     return null;
   }
-  const urgencyLevel = kind === 'realert' ? initial.urgencyLevel : topUrgencyOf(review);
+  const urgencyLevel = topUrgencyOf(review);
   if (!ALERTED_URGENCIES.includes(urgencyLevel)) {
     await release();
     return null;
   }
-  if (kind === 'initial' && (URGENCY_RANK[urgencyLevel] || 0) <= alertedRankOf(review)) {
+  if ((URGENCY_RANK[urgencyLevel] || 0) <= alertedRankOf(review)) {
     await release();
     return null;
   }
 
   let delivery;
   try {
-    const { approver, message } = await prepareDoctorAlert(review, kind, urgencyLevel);
+    const { approver, message } = await prepareDoctorAlert(review, urgencyLevel);
     const fresh = await loadReview(review._id);
-    const stillDue = kind === 'realert'
-      ? realertStillDue(fresh, initial)
-      : !fresh.closedAt && PRE_DECISION_STATUSES.includes(fresh.status);
-    if (!stillDue) {
+    if (fresh.closedAt || !PRE_DECISION_STATUSES.includes(fresh.status)) {
       await release();
       return null;
     }
@@ -978,32 +1180,26 @@ async function sendScheduledDoctorAlert({ id, kind, lease = null, now = new Date
     logger.error('[EscalationReview] The doctor alert was not sent', { escalationReviewId: String(review._id), kind, error: delivery.error });
   }
 
-  let teamAlerted = false;
-  if (kind === 'realert') {
-    const lead = review.alarms?.findLast((alarm) => alarm.urgencyLevel === 'stat') ?? review.alarms?.at(-1);
-    teamAlerted = Boolean(await recordEmergency({
-      code: review.patientCode,
-      trace: null,
-      symptom: lead?.symptom || 'Revisión clínica STAT',
-      urgencyFhir: 'stat',
-      documentation: `Re-aviso: revisión clínica STAT sin respuesta del médico ${Math.round(statRealertMs() / 60000)} min después del aviso.`,
-      mergeWithRecent: false,
-    }).catch((error) => {
-      logger.error('[EscalationReview] The team alert for an unanswered stat review was not filed', { escalationReviewId: String(review._id), error: redactedError(error) });
-      return false;
-    }));
-  }
-
-  const sent = { kind, urgencyLevel, transport: null, messageId: null, physicianEmail: null, error: null, ...delivery, teamAlerted, sentAt: now };
+  const sent = { kind, urgencyLevel, transport: null, messageId: null, physicianEmail: null, error: null, ...delivery, sentAt: now };
   const updated = await EscalationReview.findOneAndUpdate({ _id: review._id }, { $push: { doctorAlerts: sent } }, { ...BOOKKEEPING, new: true }).lean();
-  if (kind === 'initial' && urgencyLevel === 'stat') {
-    await release({ doctorAlertDueAt: new Date(now.getTime() + statRealertMs()), doctorAlertKind: 'realert', doctorAlertAttempts: 0 });
-  } else if (kind === 'initial' && sent.error) {
+  // A fever asap case gets the patient timer even when the doctor alert failed: the doctor is retried
+  // while there is time before the prompt and attempts left, then the patient prompt is the safety net.
+  // Stat already sends the patient to the ED.
+  const latestReview = updated ?? review;
+  const feverCase = urgencyLevel === 'asap' && feverTimerLive() && feverAlarmsOf(latestReview).length > 0;
+  const feverGap = feverCase ? feverTimerGap(latestReview) : null;
+  const since = feverTimerSince(latestReview) ?? now;
+  const promptAt = feverCase && !feverGap && !promptedSince(latestReview, since) ? since.getTime() + feverTimerMs() : null;
+  const retriesDoctor = sent.error
+    && (promptAt == null || (now.getTime() + ALERT_RETRY_DELAY_MS < promptAt && (review.doctorAlertAttempts ?? 0) < MAX_ALERT_ATTEMPTS));
+  if (promptAt != null && !retriesDoctor) {
+    await release({ doctorAlertDueAt: new Date(promptAt), doctorAlertKind: 'patient_prompt', doctorAlertAttempts: 0 });
+  } else if (sent.error) {
     await release({ doctorAlertDueAt: new Date(Date.now() + ALERT_RETRY_DELAY_MS), doctorAlertKind: 'initial' });
   } else {
     await release();
   }
-  if (kind === 'initial' && urgencyLevel !== 'stat' && !sent.error) {
+  if (urgencyLevel !== 'stat' && !sent.error) {
     try {
       const latest = await loadReview(review._id);
       const topNow = topUrgencyOf(latest);
@@ -1018,8 +1214,9 @@ async function sendScheduledDoctorAlert({ id, kind, lease = null, now = new Date
     }
   }
   await audit(updated ?? review, ALERT_OPERATOR, null, {
-    action: kind === 'realert' ? 'doctor_realerted' : 'doctor_alerted', urgencyLevel, delivered: !sent.error, teamAlerted,
+    action: 'doctor_alerted', urgencyLevel, delivered: !sent.error,
   });
+  if (feverGap) await audit(updated ?? review, ALERT_OPERATOR, null, { action: 'patient_prompt_not_armed', reason: feverGap });
   return updated;
 }
 
@@ -1840,6 +2037,7 @@ async function syncEscalationReviewCase({ id, syncedBy, requestId = null } = {})
 module.exports = {
   BOOKKEEPING,
   DOCUMENTING_STATUSES,
+  MAX_ALERT_ATTEMPTS,
   PRE_DECISION_STATUSES,
   _resetEscalationReviewIndexes,
   addCallLog,
@@ -1862,6 +2060,7 @@ module.exports = {
   recordReviewUpdate,
   requestBotDraft,
   sendApprovedIndications,
+  setAlarmAppliedLevel,
   setReviewCases,
   suggestDraft,
   suggestKeyQuestions,

package/lib/services/reviewAlertSweepService.js

@@ -3,13 +3,12 @@ const { createIntervalSweeper } = require('../utils/intervalSweeper');
 const { withTimeout } = require('../utils/timeoutUtils');
 const { getEscalationReview } = require('../models/escalationReviewModel');
 
-const { BOOKKEEPING, PRE_DECISION_STATUSES, sendScheduledDoctorAlert } = require('./escalationReviewService');
+const { BOOKKEEPING, MAX_ALERT_ATTEMPTS, PRE_DECISION_STATUSES, sendScheduledDoctorAlert } = require('./escalationReviewService');
 
 const SWEEP_LIMIT = 10;
 const DEFAULT_SWEEP_INTERVAL_MS = 30 * 1000;
 const LEASE_MS = 5 * 60 * 1000;
 const SEND_TIMEOUT_MS = 2 * 60 * 1000;
-const MAX_ALERT_ATTEMPTS = 3;
 const SELF_HEAL_WINDOW_MS = 60 * 60 * 1000;
 const ALERTED_URGENCIES = ['stat', 'asap'];
 
@@ -63,6 +62,12 @@ async function sweepDoctorAlerts({ now = new Date(), clock = () => new Date() }
         .lean();
       if (!claimed) continue;
       const alert = sendScheduledDoctorAlert({ id: String(reviewId), kind, lease, now: claimedAt });
+      if (kind === 'patient_prompt') {
+        // A patient prompt runs a whole agent turn; the pass moves on so doctor alerts for other reviews
+        // are not held behind it. Its ledger entry and audit are written when the turn settles.
+        alert.catch((error) => logger.error('[ReviewAlertSweep] The fever patient prompt failed', { escalationReviewId: String(reviewId), error: error.message }));
+        continue;
+      }
       if (await withTimeout(alert, SEND_TIMEOUT_MS, 'doctor alert')) sent += 1;
     } catch (error) {
       logger.error('[ReviewAlertSweep] Could not alert the doctor for a review', { escalationReviewId: String(reviewId), error: error.message });

package/lib/services/threadService.js

@@ -25,11 +25,12 @@ const getThread = async (code, message = null) => {
   }
 };
 
-const getThreadInfo = async (code) => {
+const getThreadInfo = async (code, { rethrow = false } = {}) => {
   try {
     return await Thread.findOne({ code });
   } catch (error) {
     logger.error('[getThreadInfo] Error', { code, error: error.message });
+    if (rethrow) throw error;
     return null;
   }
 };

package/lib/utils/retryUtils.js

@@ -53,6 +53,7 @@ function isAbortError(error) {
 function isRetryableError(error) {
   if (!error) return false;
   if (isAbortError(error)) return false;
+  if (error.code === 'insufficient_quota') return false;
 
   const status = error?.status;
   const code = error?.code;

package/package.json

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