@peopl-health/nexus 6.4.0-dev.18675 → 6.4.0-dev.18676

package/lib/clinical/helpers/doctorPlanHelper.js

@@ -93,6 +93,9 @@ function planOf(input) {
 const needsPrescriber = (plan) => plan.items.length > 0 || plan.studies.length > 0;
 
 const daysText = (days) => (days === 1 ? '1 día' : `${days} días`);
+const itemLine = (item) => `${[item.drug, item.strength].filter(Boolean).join(' ')}: ${item.dose} ${item.frequency} por ${daysText(item.days)}.`;
+const studyLine = (study) => `${study.name}${study.instructions ? `: ${study.instructions}` : ''}.`;
+const PRESCRIPTION_LINE = 'Justo después de tu mensaje le llega aparte la receta del médico en PDF; dile que la va a recibir.';
 
 const FOLLOW_UP_LINES = {
   check_in: (hours) => `Seguimiento: le escribiremos en unas ${hours} horas para ver cómo va.`,
@@ -103,14 +106,36 @@ const FOLLOW_UP_LINES = {
 function planInstructions(plan) {
   const lines = ['Transmítele al paciente lo que indicó el médico, con tus palabras: no cambies dosis, frecuencia ni días, y no agregues otros medicamentos ni estudios.'];
   if (plan.items.length) {
-    lines.push('Medicamentos:', ...plan.items.map((item) => `- ${[item.drug, item.strength].filter(Boolean).join(' ')}: ${item.dose} ${item.frequency} por ${daysText(item.days)}.`));
+    lines.push('Medicamentos:', ...plan.items.map((item) => `- ${itemLine(item)}`));
   }
   if (plan.studies.length) {
-    lines.push('Estudios:', ...plan.studies.map((study) => `- ${study.name}${study.instructions ? `: ${study.instructions}` : ''}.`));
+    lines.push('Estudios:', ...plan.studies.map((study) => `- ${studyLine(study)}`));
   }
   if (plan.homeCare.length) lines.push('Cuidados en casa:', ...plan.homeCare.map((entry) => `- ${entry}`));
   if (plan.note) lines.push(`Nota del médico: «${plan.note}».`);
   if (plan.followUp.kind !== 'none') lines.push(FOLLOW_UP_LINES[plan.followUp.kind](plan.followUp.hours));
+  if (needsPrescriber(plan)) lines.push(PRESCRIPTION_LINE);
+  return lines.join('\n');
+}
+
+// An edit can drop the receta line; the PDF goes out anyway, so the assistant is still told.
+function assistantInstructionsOf(plan) {
+  if (!needsPrescriber(plan) || plan.instructions.includes(PRESCRIPTION_LINE)) return plan.instructions;
+  return `${plan.instructions}\n${PRESCRIPTION_LINE}`;
+}
+
+// What the team's case shows as the indication, in the doctor's terms rather than the assistant's.
+function planSummary(plan) {
+  const lines = [...plan.items.map(itemLine), ...plan.studies.map((study) => `Estudio: ${studyLine(study)}`)];
+  if (plan.homeCare.length) lines.push(`Cuidados en casa: ${plan.homeCare.join('; ')}.`);
+  if (plan.note) lines.push(`Nota: ${plan.note}`);
+  return lines.join('\n');
+}
+
+// The receta the Airtable automations turn into the doctor's PDF.
+function prescriptionText(plan) {
+  const lines = plan.items.map(itemLine);
+  if (plan.studies.length) lines.push('Estudios:', ...plan.studies.map(studyLine));
   return lines.join('\n');
 }
 
@@ -158,8 +183,11 @@ function proposedPlanOf(draft) {
 
 module.exports = {
   approvedInstructions,
+  assistantInstructionsOf,
   needsPrescriber,
   planInstructions,
   planOf,
+  planSummary,
+  prescriptionText,
   proposedPlanOf,
 };

package/lib/clinical/tools/getPatientRiskAssessmentTool.js

@@ -5,7 +5,7 @@ const { logger } = require('../../utils/logger');
 
 const definition = {
   name: 'getPatientRiskAssessment',
-  description: '**Does:** Returns the patient\'s latest full risk assessment and a deterministic `turn_focus` for the symptoms extracted in this turn. Read-only; no model call.\n\n**Required inputs:** none.\n\n**When to call:** immediately before `submitRoutingDecision` only when `getRouterContextBundle.sections_returned` does not contain `risk`, including a bundle result with `_diagnostics.risk_error`. The routine load is the bundle\'s mandatory `risk` section, which resolves the same assessment through the same code path.\n\n**When NOT to call:** when `getRouterContextBundle` already returned `risk` this turn — it is the same assessment, and a second read cannot change it. Nor again in the same turn after a `not_generated` result — generation runs between turns and the result cannot change mid-turn.\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**How to use:** read `turn_focus.current_concerns`, then each `relevant_risks[].checks_now` and `escalation_threshold`. It preserves concurrent symptoms. Any `selection` containing `fallback` marks a precaution to check, not a confirmed explanation. When `selection` is `no_current_concerns` the patient reported no current symptom this turn. Use `profile` only for supporting detail.\n\n**`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 `turn_focus.current_concerns`.\n\n**Returns:** `status` — `final` when an assessment exists and carries findings, `no_signal` when one exists but the synthesis found nothing usable, or `not_generated`; `turn_focus`, always present; and the full `profile` (`predicted_aes[]`, `disease_risks[]`, `comorbidity_amplifiers[]`, lifecycle and missing-information fields). `profile` is null when not yet generated.',
+  description: '**Does:** Returns the patient\'s latest full risk assessment and a deterministic `turn_focus` for the symptoms extracted in this turn. Read-only; no model call.\n\n**Required inputs:** none.\n\n**When to call:** immediately before `submitRoutingDecision` only when `getRouterContextBundle.sections_returned` does not contain `risk`, including a bundle result with `_diagnostics.risk_error`. The routine load is the bundle\'s mandatory `risk` section, which resolves the same assessment through the same code path.\n\n**When NOT to call:** when `getRouterContextBundle` already returned `risk` this turn — it is the same assessment, and a second read cannot change it. Nor again in the same turn after a `not_generated` result — generation runs between turns and the result cannot change mid-turn.\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**How to use:** read `turn_focus.current_concerns`, then each `relevant_risks[].checks_now` and `escalation_threshold`. It preserves concurrent symptoms. Any `selection` containing `fallback` marks a precaution to check, not a confirmed explanation. When `selection` is `no_current_concerns` the patient reported no current symptom this turn. Use `profile` only for supporting detail.\n\n**`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 `turn_focus.current_concerns`.\n\n**Returns:** `status` — `final` when an assessment exists and carries findings, `no_signal` when one exists but the synthesis found nothing usable, or `not_generated`; `turn_focus`, always present; and the full `profile` (`predicted_aes[]`, `disease_risks[]`, `comorbidity_amplifiers[]`, lifecycle and missing-information fields). `profile` is null when not yet generated.',
   strict: false,
   replayScope: 'turn',
   parameters: {

package/lib/controllers/prescriptionController.js

@@ -1,17 +1,11 @@
-const { Monitoreo_ID } = require('../config/airtableConfig');
-
 const { logger } = require('../utils/logger');
 
-const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
-
-const { addLinkedRecord } = require('../services/airtableService');
+const { createPrescription } = require('../services/prescriptionService');
 
 const RECORD_ID_RX = /^rec[A-Za-z0-9]{14}$/;
 
-// physicianId links the receta to a physicians row; the Airtable automation picks the PDF template from that physician's specialty.
 const createPrescriptionController = async (req, res) => {
-  const { prescription, triggeredBy, creationSource = 'other', physicianId } = req.body;
-  let code = req.body.code;
+  const { code, prescription, triggeredBy, creationSource = 'other', physicianId } = req.body;
 
   if (!code) return res.status(400).json({ success: false, error: 'Code is required' });
   if (!prescription) return res.status(400).json({ success: false, error: 'Prescription is required' });
@@ -21,28 +15,10 @@ const createPrescriptionController = async (req, res) => {
   }
 
   try {
-    code = ensureWhatsAppFormat(code);
-
-    const record = await addLinkedRecord(
-      Monitoreo_ID,
-      'patient_prescriptions',
-      {
-        prescription,
-        author_email: triggeredBy,
-        creation_source: creationSource,
-        created: new Date().toISOString(),
-        ...(physicianId && { physician: [physicianId] })
-      },
-      {
-        referenceTable: 'estado_general',
-        referenceFilter: `{whatsapp_id}='${code}'`,
-        linkFieldName: 'patient_id'
-      },
-      code
-    );
+    const recordId = await createPrescription({ code, prescription, authorEmail: triggeredBy, creationSource, physicianId });
 
     logger.info('[PrescriptionController] Prescription created', { code, physicianId });
-    res.status(201).json({ success: true, message: 'Prescription created', recordId: record?.id || null });
+    res.status(201).json({ success: true, message: 'Prescription created', recordId });
   } catch (error) {
     logger.error('[PrescriptionController] Error creating prescription', { error: error.message, code });
     res.status(500).json({ success: false, error: 'Failed to create prescription' });

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<void>;
+    processSystemMessage(code: string, messages: string | string[], role?: string, options?: { triggeredBy?: string; reply?: boolean }): Promise<{ delivery: Record<string, unknown> | null; sendThrew: boolean } | 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

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

package/lib/services/assistantMessageService.js

@@ -26,9 +26,9 @@ const ASSISTANT_MESSAGE_FAILURES = {
 };
 
 class AssistantMessageError extends Error {
-  constructor(reasonCode, acceptedCount = 0) {
+  constructor(reasonCode, acceptedCount = 0, cause = undefined) {
     const [statusCode, message] = ASSISTANT_MESSAGE_FAILURES[reasonCode];
-    super(message);
+    super(message, cause === undefined ? undefined : { cause });
     this.reasonCode = reasonCode;
     this.statusCode = statusCode;
     this.acceptedCount = acceptedCount;
@@ -117,8 +117,10 @@ async function processAssistantSystemMessage(code, messages, role = 'system', op
   if (!reply) return;
   recordPatientSend?.({ code, channel: 'assistant_instruction', sentBy: triggeredBy, text: input.messages.join('\n') });
 
+  let turn;
+  let settled = null;
   try {
-    await executeWithPipeline(code, 'system', 'queue',
+    turn = await executeWithPipeline(code, 'system', 'queue',
       async (preProcessResult, shouldContinue, runId) => {
         return await assistantProcessor.process({
           code,
@@ -131,11 +133,15 @@ async function processAssistantSystemMessage(code, messages, role = 'system', op
             signal: getAbortSignal(runId),
           }
         });
-      }
+      },
+      { onSendSettled: async (outcome) => { settled = outcome; } },
     );
-  } catch {
-    throw new AssistantMessageError('MESSAGE_REPLY_FAILED', acceptedCount);
+  } catch (error) {
+    // The cause stays internal: callers tell a drain that refused the turn from one that may have answered.
+    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' };
 }
 
 module.exports = { AssistantMessageError, injectAssistantMessages, processAssistantSystemMessage };

package/lib/services/escalationReviewService.js

@@ -33,7 +33,9 @@ const { doctorAlertHeadline, doctorAlertOpener, renderDoctorMessage, templateSum
 const { generateKeyQuestions } = require('../clinical/services/escalationQuestionsService');
 const { drugsNamedIn } = require('../clinical/services/treatmentProposalService');
 const { characterizationSeedOf } = require('../clinical/helpers/reviewUpdateHelper');
-const { approvedInstructions, needsPrescriber, planInstructions, planOf, proposedPlanOf } = require('../clinical/helpers/doctorPlanHelper');
+const {
+  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, proposedPlanOf,
+} = require('../clinical/helpers/doctorPlanHelper');
 const { readNoteFacts, assertionOf } = require('../clinical/services/escalationNoteFactsService');
 const { humanReplyFilter } = require('../clinical/config/safetyNetConfig');
 const {
@@ -53,6 +55,7 @@ const { getPatientInformation, logPatientChange } = require('./patientService');
 const { MAX_NOTE_LENGTH, openCaseIds, readPatientCases, updatePatientTask } = require('./patientTaskService');
 const { countMessages } = require('./messageService');
 const { getEscalationApprover, listEscalationApprovers } = require('./physicianService');
+const { createPrescription } = require('./prescriptionService');
 const { getThreadInfo, switchThreadStoppedStatus } = require('./threadService');
 const { effectiveUrgencyOf, levelsOf, patientTimerMinutes, responseDeadlineOf, responseDeadlinePolicy } = require('./reviewDeadlineService');
 const { caseTaskLive, scheduleCaseSync } = require('./escalationCaseTaskService');
@@ -2033,10 +2036,10 @@ async function sendApprovedIndications({ id, outsideWindowRoute = null, sentBy,
   const claim = newOperationClaim();
   const claimed = await updateReview(reviewId, SENDABLE_STATUSES, { $set: { status: 'sending', operationClaim: claim } });
   const decisionNumber = claimed.decisions.length;
-  const { finalText, decision } = claimed.decisions[decisionNumber - 1];
+  const { finalText, decision, plan } = claimed.decisions[decisionNumber - 1];
   const claimedFrom = statusAfter(decision);
 
-  if (!finalText) {
+  if (!finalText && !plan) {
     await releaseReview(reviewId, 'sending', claimedFrom, claim).catch((releaseError) => {
       logger.error('[EscalationReview] The claim was not released after a decision with no text', {
         escalationReviewId: String(claimed._id), error: releaseError.message,
@@ -2054,6 +2057,7 @@ async function sendApprovedIndications({ id, outsideWindowRoute = null, sentBy,
     });
     throw httpError(409, 'The agent characterized the case after this decision; it went back to documenting for a new draft and decision');
   }
+  if (plan) return sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan, operator, requestId });
 
   // Built outside the try: composing reads Mongo and Airtable, and failing there never sent.
   let message;
@@ -2109,6 +2113,100 @@ async function sendApprovedIndications({ id, outsideWindowRoute = null, sentBy,
   return syncCase(review, operator, requestId);
 }
 
+const PRESCRIBER_EMAIL_KEY = 'ESCALATION_PRESCRIBER_EMAIL';
+
+// The PDF goes out from the Airtable automations; a failed receta never undoes the message already sent.
+async function issuePrescription(review, plan, prescriberEmail) {
+  try {
+    return await createPrescription({
+      code: review.patientCode, prescription: prescriptionText(plan), authorEmail: prescriberEmail, creationSource: 'patient case',
+    });
+  } catch (error) {
+    logger.error('[EscalationReview] The prescription was not created after the plan was sent', {
+      escalationReviewId: String(review._id), error: redactedError(error),
+    });
+    return null;
+  }
+}
+
+// How the assistant's reply left: sent, queued for the patient's reply window, not sent, or unknown.
+function replyOutcome(delivery, sendThrew) {
+  if (sendThrew) return 'unknown';
+  if (!delivery) return 'not_sent';
+  if (delivery.success === true && delivery.deferred === true) return 'queued';
+  if (delivery.success === true && typeof delivery.messageId === 'string' && delivery.messageId) return 'sent';
+  if (delivery.success === false && delivery.deferred !== true && delivery.duplicate !== true) return 'not_sent';
+  return 'unknown';
+}
+
+// The assistant writes the patient message from the doctor's instructions; the review closes unless a follow-up was chosen.
+async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan, operator, requestId }) {
+  const reviewId = claimed._id;
+  const release = () => releaseReview(reviewId, 'sending', 'approved', claim).catch((releaseError) => {
+    logger.error('[EscalationReview] The claim was not released after a plan the assistant did not send', {
+      escalationReviewId: String(reviewId), error: releaseError.message,
+    });
+  });
+
+  let prescriberEmail = null;
+  let delivery;
+  let sendThrew;
+  try {
+    if (needsPrescriber(plan)) prescriberEmail = configured(PRESCRIBER_EMAIL_KEY);
+    ({ delivery = null, sendThrew = false } = await getMessaging().processSystemMessage(
+      claimed.patientCode, [assistantInstructionsOf(plan)], 'system', { reply: true, triggeredBy: operator },
+    ) ?? {});
+  } catch (error) {
+    // A turn refused by a deploy's drain never ran; any other failure after the instructions were stored may have answered.
+    if (error?.reasonCode === 'MESSAGE_REPLY_FAILED' && !(error.cause instanceof DrainingError)) {
+      logger.error('[EscalationReview] The assistant turn failed after the instructions were stored; leaving the review in sending', {
+        escalationReviewId: String(reviewId),
+      });
+      throw httpError(502, 'The assistant turn failed after the instructions were stored; check the chat before sending again');
+    }
+    await release();
+    if (error?.cause instanceof DrainingError) throw httpError(503, 'The server is restarting; send the plan again in a minute');
+    throw error;
+  }
+
+  const outcome = replyOutcome(delivery, sendThrew);
+  if (outcome === 'not_sent') {
+    await release();
+    throw httpError(502, 'The assistant did not send a message to the patient; check the chat and send the plan again');
+  }
+  if (outcome === 'unknown') {
+    logger.error('[EscalationReview] The assistant reply could not be confirmed; leaving the review in sending', { escalationReviewId: String(reviewId) });
+    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 record = {
+    decisionNumber, messageId: delivery.messageId || null, status: delivery.status || null, transport: 'assistant', deferred: queued, sentBy: operator,
+    ...(prescriptionRecordId && { prescriptionRecordId }),
+  };
+  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' }),
+  });
+  // 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) {
+    try {
+      return await closeEscalationReview({ id: reviewId, closedBy: operator, requestId });
+    } catch (error) {
+      logger.error('[EscalationReview] The review was not closed after its plan was sent', {
+        escalationReviewId: String(reviewId), error: redactedError(error),
+      });
+      return syncCase(await loadReview(reviewId), operator, requestId);
+    }
+  }
+  return syncCase(review, operator, requestId);
+}
+
 const EPISODE_TRUST = 0.7;
 const EPISODE_VARIABLE = 'intercurrent_events_summary';
 const EPISODE_SOURCE = 'doctor';

package/lib/services/prescriptionService.js

@@ -0,0 +1,30 @@
+const { Monitoreo_ID } = require('../config/airtableConfig');
+
+const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
+
+const { addLinkedRecord } = require('./airtableService');
+
+// physicianId links the receta to a physicians row; the Airtable automation picks the PDF template from that physician's specialty.
+async function createPrescription({ code, prescription, authorEmail, creationSource = 'other', physicianId }) {
+  const patientCode = ensureWhatsAppFormat(code);
+  const record = await addLinkedRecord(
+    Monitoreo_ID,
+    'patient_prescriptions',
+    {
+      prescription,
+      author_email: authorEmail,
+      creation_source: creationSource,
+      created: new Date().toISOString(),
+      ...(physicianId && { physician: [physicianId] })
+    },
+    {
+      referenceTable: 'estado_general',
+      referenceFilter: `{whatsapp_id}='${patientCode}'`,
+      linkFieldName: 'patient_id'
+    },
+    patientCode
+  );
+  return record?.id || null;
+}
+
+module.exports = { createPrescription };

package/package.json

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