@peopl-health/nexus 6.4.0-dev.18775 → 6.4.0-dev.18777

package/lib/clinical/helpers/doctorPlanHelper.js

@@ -181,6 +181,43 @@ function proposedPlanOf(draft) {
   return { items, studies: [], homeCare: [], note: rests.join('. ') || null, followUp: { kind: 'check_in', hours: DEFAULT_FOLLOW_UP_HOURS.check_in } };
 }
 
+const plain = (text) => String(text ?? '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+const URGENCY_WORDS = /\b(urgencias?|urgente|de inmediato|inmediatamente|emergencias?|911|lo antes posible|cuanto antes|no esperes)\b/g;
+const numbersIn = (text, pattern) => new Set([...plain(text).matchAll(pattern)].map((match) => match[1].replace(',', '.')));
+const HOURS = /cada\s+(\d+)\s*h(?:rs?|oras?)?\b/g;
+const DAYS = /por\s+(\d+)\s+dias?/g;
+const MG = /(\d+(?:[.,]\d+)?)\s*mg\b/g;
+
+// The plan's own words, so what the doctor wrote anywhere in it is never flagged.
+const plannedTextOf = (plan) => [
+  ...plan.items.flatMap((item) => [item.drug, item.strength, item.dose, item.frequency, `por ${item.days} dias`]),
+  ...plan.studies.flatMap((study) => [study.name, study.instructions]),
+  ...plan.homeCare,
+  plan.note,
+].filter(Boolean).join('\n');
+
+// What in the assistant's reply strays from the plan, for the team to check; `unplannedDrugs` are the formulary drugs it names beyond the plan.
+function replyIssues(plan, reply, unplannedDrugs = []) {
+  const text = plain(reply);
+  if (!text) return ['no se pudo leer el mensaje enviado'];
+  const planned = plannedTextOf(plan);
+  const issues = [];
+  for (const item of plan.items) {
+    const name = plain(item.drug).split(/[\s/]/)[0];
+    if (name && !text.includes(name)) issues.push(`no menciona ${item.drug}`);
+  }
+  const strays = (pattern) => [...numbersIn(reply, pattern)].filter((value) => !numbersIn(planned, pattern).has(value));
+  for (const value of strays(HOURS)) issues.push(`dice «cada ${value} horas», que no está en el plan`);
+  for (const value of strays(DAYS)) issues.push(`dice «por ${value} días», que no está en el plan`);
+  for (const value of strays(MG)) issues.push(`dice «${value} mg», que no está en el plan`);
+  for (const name of unplannedDrugs) issues.push(`menciona ${name}, que el médico no indicó`);
+  const plannedWords = new Set([...plain(planned).matchAll(URGENCY_WORDS)].map((match) => match[1]));
+  for (const word of new Set([...text.matchAll(URGENCY_WORDS)].map((match) => match[1]))) {
+    if (!plannedWords.has(word)) issues.push(`usa «${word}», que el médico no indicó`);
+  }
+  return issues;
+}
+
 module.exports = {
   approvedInstructions,
   assistantInstructionsOf,
@@ -190,4 +227,6 @@ module.exports = {
   planSummary,
   prescriptionText,
   proposedPlanOf,
+  plannedTextOf,
+  replyIssues,
 };

package/lib/clinical/services/treatmentProposalService.js

@@ -90,10 +90,8 @@ function validateProposal(proposal, context = {}) {
 
 const namesOf = (drug) => [drug.drug, ...drug.drug.split('/'), ...String(drug.brand ?? '').split('/')].map(key).filter((name) => name.length >= 4);
 
-const DRUG_NAMES = [...new Set(TREATMENT_FORMULARY
-  .flatMap((entry) => entry.drugs)
-  .filter((drug) => drug.isPharmacological !== false)
-  .flatMap(namesOf))];
+const FORMULARY_DRUGS = TREATMENT_FORMULARY.flatMap((entry) => entry.drugs).filter((drug) => drug.isPharmacological !== false);
+const DRUG_NAMES = [...new Set(FORMULARY_DRUGS.flatMap(namesOf))];
 
 function resolvedDrugs(proposals) {
   return proposals.filter(Boolean).flatMap((proposal) => {
@@ -107,6 +105,14 @@ function drugsNamedIn(text) {
   return DRUG_NAMES.filter((name) => padded.includes(` ${name} `));
 }
 
+// Drugs the text names that the planned text does not; a brand of a planned drug counts as planned, a combination only when named whole.
+function unplannedDrugsIn(text, plannedText) {
+  const planned = new Set(drugsNamedIn(plannedText));
+  const ownNames = (drug) => [drug.drug, ...String(drug.brand ?? '').split('/')].map(key).filter(Boolean);
+  const allowed = new Set([...planned, ...FORMULARY_DRUGS.filter((drug) => ownNames(drug).some((name) => planned.has(name))).flatMap(namesOf)]);
+  return [...new Set(drugsNamedIn(text).filter((name) => !allowed.has(name)))];
+}
+
 function unproposedDrugsIn(text, proposals) {
   const proposed = new Set(resolvedDrugs(proposals).flatMap(({ drug }) => namesOf(drug)));
   return drugsNamedIn(text).filter((name) => !proposed.has(name));
@@ -132,6 +138,7 @@ module.exports = {
   JUSTIFICATION_KINDS,
   validateProposal,
   unproposedDrugsIn,
+  unplannedDrugsIn,
   drugsNamedIn,
   crossSymptomIssues,
 };

package/lib/clinical/tools/getRouterContextBundleTool.js

@@ -10,7 +10,7 @@ const REQUIRED_SECTION = 'risk';
 
 const definition = {
   name: 'getRouterContextBundle',
-  description: '**Does:** Batched router-context fetch — always evaluates and returns the mandatory `risk` section, plus the requested `landscape` and/or `history` sections. Read-only.\n\n**Required inputs:** none. Optional `include` selects additional sections (`landscape`, `history`; a supplied `risk` value is accepted but redundant), plus optional `landscape_min_priority`, `history_scope`, `history_filter`. Omitting `include` returns all three sections.\n\n**When to call:** after intake at the start of every routing turn, as the single load of the patient\'s clinical context. Do not call it in parallel with `Skill(clinical_routing)`: first read the skill body, then call this bundle. The patient\'s risk disposition cannot be excluded by `include`. Prefer this over calling `getActiveSymptomLandscape`, `getPatientHistory` or `getPatientRiskAssessment` for the same context.\n\n**`turn_focus.recent_escalations` — what you already sent the team.** Every escalation dispatched for this patient in the last 14 days, newest first, with `escalated_at`, `days_since`, `urgency`, `reason` and the `channels` used. Read it before `reportMedicalEscalation`. It records only what was SENT; where the team is with it is in `team_cases`. A complaint unchanged since an escalation a day ago rarely needs a second dispatch; one still uncontrolled days after its escalation needs one at a HIGHER urgency, and `urgency_justification` should say which of the two this is. Empty means nothing was escalated in the window.\n\n**`turn_focus.team_cases` — where the care team is with each case.** Every case the team still holds, and those it closed in the last 14 days, newest first: `status`, `is_open`, `level`, `opened_at`, `days_since`, `doctor_decision` and `case_ids` (the symptom cases it covers).\n- `Por revisar`, `En evaluación`, `Con el médico`, `Indicación por enviar`, `Requiere valoración`: the team has it and has not answered yet. Tell the patient it is with the team, without promising a time. A new escalation is for a new symptom, a higher grade, a new red flag, or a symptom that persists or worsens while it waits (send it as an update).\n- `Esperando paciente`, `Indicaciones dadas`, `En vigilancia`: the team already answered (an indication on its way to the patient, given, or under watch). This comes first: ask how the indication is going before escalating again.\n- `Cerrado`, `No requiere`: the team closed it. A new complaint is a new decision.\n`doctor_decision` is internal (`approved`, `edited_approved`, `monitor`, `needs_intervention` = the doctor asked for an in-person evaluation, `returned`, `direct_chat`): use it to understand the case, never quote it. `team_cases` never says whether the problem resolved; ask the patient. An escalation in `recent_escalations` with no case here has an unknown team status, not an absent one.\n\n**Use `turn_focus.symptom_history` before grading or escalating.** It carries what no other section does: how this patient compares to their own past. `worst_grade` and `worst_reported_at` are the worst they have ever been recorded, `at_personal_worst` says whether they are back at it, and `days_since_last_report` says how stale `last_grade` is. (The current grade and trajectory are already in `landscape.active_cases` — do not expect them repeated here.) Escalate on the comparison, not on severity alone: a patient at their personal worst is a different decision from one below it, and a grade unchanged for weeks is different from the same grade reported yesterday. When you ask about it, anchor the question in the value and the date so the patient can compare. Empty means no graded case on record. \n\n**A case flagged `stale_no_recent_evidence` has had no new evidence for two weeks or more.** `days_since_evidence` says how long. Ask whether the symptom is still there, and close the case with `recordClinicalImpression` `close` when it is not: an open case keeps consuming the landscape and keeps the symptom reading as active on the record.\n\n**How to use risk:** read `risk.turn_focus` first — it is always present. It deterministically keeps every current symptom and maps it to relevant full-profile risks, `checks_now`, and `escalation_threshold`; use the full `risk.profile` only for supporting detail. A highest-severity fallback is labelled explicitly when no direct symptom match exists. When `turn_focus.selection` is `no_current_concerns` the patient reported no current symptom this turn.\n\n**`risk.profile` is a forecast, not history:** `predicted_aes[].minimum_symptom_set`, `disease_risks[].warning_symptoms` and every other profile list name symptoms to watch for, none of which the patient has reported. Never tell the patient a profile symptom appears in their report, and never attach a CTCAE grade to one. Reported symptoms come only from `landscape`, `history` and `turn_focus.current_concerns`.\n\n**Recovery:** verify `sections_returned` contains `risk`. If it does not, inspect `_diagnostics.risk_error` and call `getPatientRiskAssessment` before `submitRoutingDecision`.\n\n**Returns:** `patient_id`, `sections_requested[]`, `sections_returned[]` (only sections that succeeded), mandatory `risk` (always including `turn_focus`), and requested `landscape` / `history`. A section that errors is omitted and its error reported under `_diagnostics`. The attempted risk read and deterministic turn processing are recorded on the turn trace even when no profile exists.',
+  description: '**Does:** Batched router-context fetch — always evaluates and returns the mandatory `risk` section, plus the requested `landscape` and/or `history` sections. Read-only.\n\n**Required inputs:** none. Optional `include` selects additional sections (`landscape`, `history`; a supplied `risk` value is accepted but redundant), plus optional `landscape_min_priority`, `history_scope`, `history_filter`. Omitting `include` returns all three sections.\n\n**When to call:** after intake at the start of every routing turn, as the single load of the patient\'s clinical context. Do not call it in parallel with `Skill(clinical_routing)`: first read the skill body, then call this bundle. The patient\'s risk disposition cannot be excluded by `include`. Prefer this over calling `getActiveSymptomLandscape`, `getPatientHistory` or `getPatientRiskAssessment` for the same context.\n\n**`turn_focus.recent_escalations` — what you already sent the team.** Every escalation dispatched for this patient in the last 14 days, newest first, with `escalated_at`, `days_since`, `urgency`, `reason` and the `channels` used. Read it before `reportMedicalEscalation`. It records only what was SENT; where the team is with it is in `team_cases`. A complaint unchanged since an escalation a day ago rarely needs a second dispatch; one still uncontrolled days after its escalation needs one at a HIGHER urgency, and `urgency_justification` should say which of the two this is. Empty means nothing was escalated in the window.\n\n**`turn_focus.team_cases` — where the care team is with each case.** Every case the team still holds, and those it closed in the last 14 days, newest first: `status`, `is_open`, `level`, `opened_at`, `days_since`, `doctor_decision` and `case_ids` (the symptom cases it covers).\n- `Por revisar`, `En evaluación`, `Con el médico`, `Indicación por enviar`, `Requiere valoración`: the team has it and has not answered yet. Tell the patient it is with the team, without promising a time. A new escalation is for a new symptom, a higher grade, a new red flag, or a symptom that persists or worsens while it waits (send it as an update).\n- `Esperando paciente`, `Indicaciones dadas`, `En vigilancia`: the team already answered (an indication on its way to the patient, given, or under watch). This comes first: ask how the indication is going before escalating again.\n- `Cerrado`, `No requiere`: the team closed it. A new complaint is a new decision.\n`doctor_decision` is internal (`approved`, `edited_approved`, `plan_approved` = the doctor gave a structured plan, `monitor`, `needs_intervention` = the doctor asked for an in-person evaluation, `returned`, `direct_chat`): use it to understand the case, never quote it. `team_cases` never says whether the problem resolved; ask the patient. An escalation in `recent_escalations` with no case here has an unknown team status, not an absent one.\n\n**Use `turn_focus.symptom_history` before grading or escalating.** It carries what no other section does: how this patient compares to their own past. `worst_grade` and `worst_reported_at` are the worst they have ever been recorded, `at_personal_worst` says whether they are back at it, and `days_since_last_report` says how stale `last_grade` is. (The current grade and trajectory are already in `landscape.active_cases` — do not expect them repeated here.) Escalate on the comparison, not on severity alone: a patient at their personal worst is a different decision from one below it, and a grade unchanged for weeks is different from the same grade reported yesterday. When you ask about it, anchor the question in the value and the date so the patient can compare. Empty means no graded case on record. \n\n**A case flagged `stale_no_recent_evidence` has had no new evidence for two weeks or more.** `days_since_evidence` says how long. Ask whether the symptom is still there, and close the case with `recordClinicalImpression` `close` when it is not: an open case keeps consuming the landscape and keeps the symptom reading as active on the record.\n\n**How to use risk:** read `risk.turn_focus` first — it is always present. It deterministically keeps every current symptom and maps it to relevant full-profile risks, `checks_now`, and `escalation_threshold`; use the full `risk.profile` only for supporting detail. A highest-severity fallback is labelled explicitly when no direct symptom match exists. When `turn_focus.selection` is `no_current_concerns` the patient reported no current symptom this turn.\n\n**`risk.profile` is a forecast, not history:** `predicted_aes[].minimum_symptom_set`, `disease_risks[].warning_symptoms` and every other profile list name symptoms to watch for, none of which the patient has reported. Never tell the patient a profile symptom appears in their report, and never attach a CTCAE grade to one. Reported symptoms come only from `landscape`, `history` and `turn_focus.current_concerns`.\n\n**Recovery:** verify `sections_returned` contains `risk`. If it does not, inspect `_diagnostics.risk_error` and call `getPatientRiskAssessment` before `submitRoutingDecision`.\n\n**Returns:** `patient_id`, `sections_requested[]`, `sections_returned[]` (only sections that succeeded), mandatory `risk` (always including `turn_focus`), and requested `landscape` / `history`. A section that errors is omitted and its error reported under `_diagnostics`. The attempted risk read and deterministic turn processing are recorded on the turn trace even when no profile exists.',
   strict: false,
   replayScope: 'turn',
   parameters: {

package/lib/index.d.ts

@@ -274,7 +274,7 @@ declare module '@peopl-health/nexus' {
     initializeLlmMonitor(): Promise<{ enabled: boolean; error?: string } | undefined>;
     getWorkflowRunner(): WorkflowRunner;
     processInstruction(code: string, instruction: string, role?: string, options?: { triggeredBy?: string; beforeRun?: () => Promise<string | null | undefined> | string | null | undefined; dedupeWithinMs?: number }): Promise<{ outcome: string | null; reason?: string; error?: string }>;
-    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<{ delivery: Record<string, unknown> | null; sendThrew: boolean } | undefined>;
+    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<{ delivery: Record<string, unknown> | null; sendThrew: boolean; reply: string | null } | undefined>;
     processOutreach(code: string, options?: { brief?: OutreachBrief | null; triggeredBy?: string | null; reason?: string | null; firstName?: string | null; dryRun?: boolean; replyToContact?: boolean; allowFollowUp?: boolean }): Promise<OutreachDecision>;
     processCheckInDue(code: string, options: { reminderId: string; type: 'contingencia' | 'seguimiento'; question?: string; firstName?: string | null }): Promise<CheckInDueResult>;
     processScheduledFollowUp(code: string, options: { reminderId: string; firstName: string; now?: Date }): Promise<ScheduledFollowUpResult>;

package/lib/models/escalationReviewModel.js

@@ -245,6 +245,7 @@ const patientDeliverySchema = new mongoose.Schema({
   status: { type: String, default: null },
   transport: { type: String, enum: ['text', 'template_recovery', 'predefined_template', 'assistant'], required: true },
   prescriptionRecordId: { type: String, default: null },
+  checks: { type: [String], default: undefined },
   deferred: { type: Boolean, default: false },
   confirmedBy: { type: String, default: null },
   confirmedAt: { type: Date, default: null },

package/lib/services/assistantMessageService.js

@@ -141,7 +141,7 @@ async function processAssistantSystemMessage(code, messages, role = 'system', op
     throw new AssistantMessageError('MESSAGE_REPLY_FAILED', acceptedCount, error);
   }
   // What the reply's send returned, or null when the turn produced or sent nothing; a send that threw may still have reached the patient.
-  return { delivery: turn?.delivery ?? null, sendThrew: settled === 'threw' };
+  return { delivery: turn?.delivery ?? null, sendThrew: settled === 'threw', reply: turn?.output ?? null };
 }
 
 module.exports = { AssistantMessageError, injectAssistantMessages, processAssistantSystemMessage };

package/lib/services/escalationReviewService.js

@@ -28,13 +28,13 @@ const { isWithin24HourWindow } = require('../helpers/conversationWindowHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
 const { DrainingError } = require('../core/BatchingManager');
 const { generateEscalationDraft } = require('../clinical/services/escalationDraftService');
-const { conversationLink, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
+const { conversationLink, readGroupMessageId, writeUnresolvedRequest } = require('../clinical/services/clinicalAirtableService');
 const { doctorAlertHeadline, doctorAlertOpener, renderDoctorMessage, templateSummary, withIdentity } = require('../clinical/helpers/doctorReviewMessageHelper');
 const { generateKeyQuestions } = require('../clinical/services/escalationQuestionsService');
-const { drugsNamedIn } = require('../clinical/services/treatmentProposalService');
+const { drugsNamedIn, unplannedDrugsIn } = require('../clinical/services/treatmentProposalService');
 const { characterizationSeedOf } = require('../clinical/helpers/reviewUpdateHelper');
 const {
-  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, proposedPlanOf,
+  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, plannedTextOf, proposedPlanOf, replyIssues,
 } = require('../clinical/helpers/doctorPlanHelper');
 const { readNoteFacts, assertionOf } = require('../clinical/services/escalationNoteFactsService');
 const { humanReplyFilter } = require('../clinical/config/safetyNetConfig');
@@ -59,7 +59,7 @@ const { createPrescription } = require('./prescriptionService');
 const { getThreadInfo, switchThreadStoppedStatus } = require('./threadService');
 const { effectiveUrgencyOf, levelsOf, patientTimerMinutes, responseDeadlineOf, responseDeadlinePolicy } = require('./reviewDeadlineService');
 const { caseTaskLive, scheduleCaseSync } = require('./escalationCaseTaskService');
-const { groupConfigured, sendTeamAlert, teamChannelConfigured } = require('./teamAlertService');
+const { groupConfigured, sendGroupNotice, sendTeamAlert, teamChannelConfigured } = require('./teamAlertService');
 
 const getMessaging = () => require('../core/NexusMessaging');
 
@@ -2156,7 +2156,24 @@ function replyOutcome(delivery, sendThrew) {
   return 'unknown';
 }
 
-// The assistant writes the patient message from the doctor's instructions; the review closes unless a follow-up was chosen.
+// A reply in the case's alarm thread; a notice that fails is logged and never undoes the send.
+async function notifyPlanIssues(review, issues) {
+  try {
+    const { patient, doctor, link } = await teamAlertIdentity(review);
+    const header = '⚠️ Revisar el envío del plan';
+    const lines = issues.map((issue) => `- ${issue}`);
+    const action = 'Qué hacer: revisar el chat; corregir con la paciente o volver a mandar la receta si hace falta';
+    // Every alarm, not only those since the decision: the plan is always sent after it, so the case's alarm came before.
+    const recordId = [...(review.alarms ?? [])].reverse().find((alarm) => alarm.emergencyRecordId)?.emergencyRecordId;
+    const quoted = await readGroupMessageId(recordId, review.patientCode);
+    const sent = await sendGroupNotice([header, `${patient} (${doctor})`, ...lines, action, link].join('\n'), quoted, [header, ...lines, action].join('\n'));
+    if (!sent.delivered) logger.error('[EscalationReview] The plan check notice did not reach the group', { escalationReviewId: String(review._id), error: sent.error });
+  } catch (error) {
+    logger.error('[EscalationReview] The plan check notice failed', { escalationReviewId: String(review._id), error: redactedError(error) });
+  }
+}
+
+// The assistant writes the patient message from the doctor's instructions; the review closes unless a follow-up was chosen or the reply needs a look.
 async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan, operator, requestId }) {
   const reviewId = claimed._id;
   const release = () => releaseReview(reviewId, 'sending', 'approved', claim).catch((releaseError) => {
@@ -2168,9 +2185,10 @@ async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan,
   const prescriberEmail = needsPrescriber(plan) ? plan.prescriber?.email ?? null : null;
   let delivery;
   let sendThrew;
+  let reply;
   try {
     if (needsPrescriber(plan) && !prescriberEmail) throw httpError(409, 'This plan names no doctor to sign the receta; record the plan again');
-    ({ delivery = null, sendThrew = false } = await getMessaging().processSystemMessage(
+    ({ delivery = null, sendThrew = false, reply = null } = await getMessaging().processSystemMessage(
       claimed.patientCode, [assistantInstructionsOf(plan)], 'system', { reply: true, triggeredBy: operator },
     ) ?? {});
   } catch (error) {
@@ -2193,25 +2211,30 @@ async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan,
   }
   if (outcome === 'unknown') {
     logger.error('[EscalationReview] The assistant reply could not be confirmed; leaving the review in sending', { escalationReviewId: String(reviewId) });
+    await notifyPlanIssues(claimed, ['no se pudo confirmar que el mensaje salió; el caso sigue en «enviando»']);
     throw httpError(502, 'The assistant reply could not be confirmed; check the chat before sending again');
   }
 
   // A queued reply goes out once the patient answers the recovery template; the receta, a template itself, goes now.
   const queued = outcome === 'queued';
   const prescriptionRecordId = prescriberEmail ? await issuePrescription(claimed, plan, prescriberEmail) : null;
+  const prescriptionFailed = Boolean(prescriberEmail) && !prescriptionRecordId;
+  const unplanned = reply ? unplannedDrugsIn(reply, plannedTextOf(plan)) : [];
+  const issues = [...replyIssues(plan, reply, unplanned), ...(prescriptionFailed ? ['no se pudo crear la receta'] : [])];
   const record = {
     decisionNumber, messageId: delivery.messageId || null, status: delivery.status || null, transport: 'assistant', deferred: queued, sentBy: operator,
     ...(prescriptionRecordId && { prescriptionRecordId }),
+    ...(issues.length && { checks: issues }),
   };
   const recordUpdate = withCaseMirror(claimed, { $set: { patientDelivery: record } }, { recommendation: planSummary(plan) });
   const status = queued ? 'indications_queued' : 'indications_sent';
   const review = await completeOperation(reviewId, claim, 'sending', recordUpdate, status);
-  const prescriptionFailed = Boolean(prescriberEmail) && !prescriptionRecordId;
   await audit(review, operator, requestId, {
-    action: status, decisionNumber, transport: 'assistant', ...(prescriberEmail && { prescription: prescriptionFailed ? 'failed' : 'created' }),
+    action: status, decisionNumber, transport: 'assistant', checks: issues.length, ...(prescriberEmail && { prescription: prescriptionFailed ? 'failed' : 'created' }),
   });
-  // Closing waits for a sent reply and the receta it promised; otherwise the team still has something to do.
-  if (plan.followUp.kind === 'none' && !queued && !prescriptionFailed) {
+  if (issues.length) await notifyPlanIssues(review, issues);
+  // Closing waits for a sent reply that kept to the plan and the receta it promised; otherwise the team still has something to do.
+  if (plan.followUp.kind === 'none' && !queued && !issues.length) {
     try {
       return await closeEscalationReview({ id: reviewId, closedBy: operator, requestId });
     } catch (error) {

package/package.json

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