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

package/lib/clinical/helpers/doctorPlanHelper.js

@@ -1,94 +1,12 @@
-const { httpError } = require('../../utils/httpErrorUtils');
 const { oneLineOf } = require('../../utils/coercionUtils');
-const { PLAN_FOLLOW_UPS } = require('../../models/escalationReviewModel');
+const { normalizeForAnchor: drugKey } = require('../../utils/textMatchUtils');
+const { DURATION_SOURCE, durationDays, isRouteOnly } = require('./planTextHelper');
 
-const DEFAULT_FOLLOW_UP_HOURS = { check_in: 24, vigilancia: 48 };
-const FIRST_LINE = '1L';
-const MAX_ENTRIES = 10;
-const MAX_FIELD_LENGTH = 300;
-const MAX_NOTE_LENGTH = 1000;
-const MAX_INSTRUCTIONS_LENGTH = 4000;
-const MAX_DAYS = 90;
-const MAX_FOLLOW_UP_HOURS = 168;
-// A route is not a dose: the doctor still says how many tablets.
-const ROUTE_ONLY = /^(vo|v[ií]a oral|oral)$/i;
-
-const textOf = (value, name, max = MAX_FIELD_LENGTH) => {
-  if (value != null && typeof value !== 'string') throw httpError(400, `${name} must be text`);
-  const text = oneLineOf(value);
-  if (text.length > max) throw httpError(400, `${name} exceeds ${max} characters`);
-  return text || null;
-};
-
-const neededText = (value, name) => {
-  const text = textOf(value, name);
-  if (!text) throw httpError(400, `${name} is required`);
-  return text;
-};
-
-const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
-// Only a number or a string of digits: `true`, `[5]` and `'1e1'` are not days.
-const wholeNumber = (value, name, max) => {
-  const number = typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value.trim())) ? Number(value) : NaN;
-  if (!Number.isInteger(number) || number < 1 || number > max) throw httpError(400, `${name} must be a whole number from 1 to ${max}`);
-  return number;
-};
-
-const listOf = (value, name) => {
-  if (value == null) return [];
-  if (!Array.isArray(value)) throw httpError(400, `${name} must be a list`);
-  if (value.length > MAX_ENTRIES) throw httpError(400, `${name} allows at most ${MAX_ENTRIES} entries`);
-  return value;
-};
-
-function itemOf(item, index) {
-  const name = `plan.items[${index}]`;
-  const position = textOf(item?.position, `${name}.position`);
-  const reason = textOf(item?.reason, `${name}.reason`);
-  // An alternative to the first line has to say why the first line does not fit.
-  if (position && position !== FIRST_LINE && !reason) throw httpError(400, `${name}.reason is required for a drug that is not first line`);
-  return {
-    drug: neededText(item?.drug, `${name}.drug`),
-    strength: textOf(item?.strength, `${name}.strength`),
-    dose: neededText(item?.dose, `${name}.dose`),
-    frequency: neededText(item?.frequency, `${name}.frequency`),
-    days: wholeNumber(item?.days, `${name}.days`, MAX_DAYS),
-    position,
-    reason,
-    formularyKey: textOf(item?.formularyKey, `${name}.formularyKey`),
-  };
-}
-
-function followUpOf(value) {
-  if (value != null && !isPlainObject(value)) throw httpError(400, 'plan.followUp must be an object with a kind');
-  const kind = value?.kind ?? 'none';
-  if (!PLAN_FOLLOW_UPS.includes(kind)) throw httpError(400, `plan.followUp.kind must be one of: ${PLAN_FOLLOW_UPS.join(', ')}`);
-  if (kind === 'none') return { kind, hours: null };
-  return { kind, hours: wholeNumber(value?.hours ?? DEFAULT_FOLLOW_UP_HOURS[kind], 'plan.followUp.hours', MAX_FOLLOW_UP_HOURS) };
-}
-
-// The plan as the doctor approved it, refused whole when any line is incomplete.
-function planOf(input) {
-  if (!isPlainObject(input)) throw httpError(400, 'plan is required');
-  const plan = {
-    items: listOf(input.items, 'plan.items').map((item, index) => {
-      if (!isPlainObject(item)) throw httpError(400, `plan.items[${index}] must be an object`);
-      return itemOf(item, index);
-    }),
-    studies: listOf(input.studies, 'plan.studies').map((study, index) => ({
-      name: neededText(study?.name, `plan.studies[${index}].name`),
-      instructions: textOf(study?.instructions, `plan.studies[${index}].instructions`),
-    })),
-    homeCare: listOf(input.homeCare, 'plan.homeCare').map((entry, index) => neededText(entry, `plan.homeCare[${index}]`)),
-    note: textOf(input.note, 'plan.note', MAX_NOTE_LENGTH),
-    followUp: followUpOf(input.followUp),
-  };
-  if (!plan.items.length && !plan.studies.length && !plan.homeCare.length && !plan.note) {
-    throw httpError(400, 'plan needs a drug, a study, a home care measure or a note');
-  }
-  return plan;
-}
+const DEFAULT_FOLLOW_UP_HOURS = Object.freeze({ check_in: 24, vigilancia: 48 });
+// «1 tableta» «cada 8 horas | c/8h» «por 5 días», then «, …» what else the formulary says.
+const DOSING = new RegExp(`^(.*?)\\s+((?:cada|c\\/)\\s*[^,;]+?)(?:\\s+(${DURATION_SOURCE}))?(?:\\s*[,;]\\s*(.*))?$`, 'i');
+// Only a clause of its own: «…, y tragar, por 7 días» gives the days, «…, no manejar durante 2 días» does not.
+const LATE_DURATION = new RegExp(`(?:^|[,;]\\s*)(${DURATION_SOURCE})\\s*$`, 'i');
 
 const needsPrescriber = (plan) => plan.items.length > 0 || plan.studies.length > 0;
 
@@ -120,7 +38,7 @@ function planInstructions(plan) {
 
 // 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;
+  if (!needsPrescriber(plan) || oneLineOf(plan.instructions).includes(PRESCRIPTION_LINE)) return plan.instructions;
   return `${plan.instructions}\n${PRESCRIPTION_LINE}`;
 }
 
@@ -139,29 +57,20 @@ function prescriptionText(plan) {
   return lines.join('\n');
 }
 
-// The doctor's edit wins; with none, the instructions follow the plan.
-function approvedInstructions(plan, edited) {
-  if (edited != null && typeof edited !== 'string') throw httpError(400, 'instructions must be text');
-  if (!edited?.trim()) return { instructions: planInstructions(plan), instructionsEdited: false };
-  const instructions = edited.trim();
-  if (instructions.length > MAX_INSTRUCTIONS_LENGTH) throw httpError(400, `instructions exceed ${MAX_INSTRUCTIONS_LENGTH} characters`);
-  return { instructions, instructionsEdited: instructions !== planInstructions(plan) };
-}
-
 // «1 tableta cada 24 horas por 5 días; además, …» → dose, frequency, days and the rest; what does not match is left for the doctor.
 function dosingOf(instructions) {
   const text = oneLineOf(instructions);
-  const match = text.match(/^(.*?)\s+(cada [^,;]+?)(?:\s+por\s+(\d+)\s+d[ií]as?)?(?:\s*[,;]\s*(.*))?$/i);
+  const match = text.match(DOSING);
   if (!match) return { dose: text || null, frequency: null, days: null, rest: null };
-  const [, dose, frequency, days, rest] = match;
+  const [, dose, frequency, duration, , , , rest] = match;
   // A duration said after other directions («…, y tragar, por 7 días») is still the days.
-  const lateDays = !days && rest?.match(/(?:^|[,;]\s*|\s)por\s+(\d+)\s+d[ií]as?\s*$/i);
-  return {
-    dose: ROUTE_ONLY.test(dose) ? null : dose,
-    frequency,
-    days: Number(days ?? lateDays?.[1]) || null,
-    rest: (lateDays ? rest.slice(0, lateDays.index).replace(/[,;\s]+$/, '') : rest) || null,
-  };
+  const late = !duration ? rest?.match(LATE_DURATION) : null;
+  const said = duration ?? late?.[1];
+  const days = durationDays(said);
+  const others = late ? rest.slice(0, late.index).replace(/[,;\s]+$/, '') : rest;
+  // A range («por 3 a 5 días») is the doctor's to settle, so it stays in view with the rest.
+  const left = [others, said && !days ? said : null].filter(Boolean).join(', ');
+  return { dose: isRouteOnly(dose) ? null : dose, frequency, days, rest: left || null };
 }
 
 // The doctor's starting point: the drugs the bot proposed and confirmed, once each, and a 24 h check-in.
@@ -172,7 +81,7 @@ function proposedPlanOf(draft) {
   const items = (draft?.symptoms ?? [])
     .filter((entry) => entry?.proposal?.confirmed)
     .flatMap((entry) => (entry.proposal.items ?? []).map((item) => ({ item, formularyKey: entry.proposal.formularyKey })))
-    .filter(({ item }) => !seen.has(oneLineOf(item.drug).toLowerCase()) && seen.add(oneLineOf(item.drug).toLowerCase()))
+    .filter(({ item }) => !seen.has(drugKey(item.drug)) && seen.add(drugKey(item.drug)))
     .map(({ item, formularyKey }) => {
       const { rest, ...dosing } = dosingOf(item.instructions);
       if (rest) rests.push(`${item.drug}: ${rest}`);
@@ -181,13 +90,6 @@ 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`]),
@@ -196,37 +98,13 @@ const plannedTextOf = (plan) => [
   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,
+  DEFAULT_FOLLOW_UP_HOURS,
   assistantInstructionsOf,
   needsPrescriber,
   planInstructions,
-  planOf,
   planSummary,
+  plannedTextOf,
   prescriptionText,
   proposedPlanOf,
-  plannedTextOf,
-  replyIssues,
 };

package/lib/clinical/helpers/planTextHelper.js

@@ -0,0 +1,104 @@
+const { foldAccents } = require('../../utils/formatUtils');
+const { normalizeForAnchor } = require('../../utils/textMatchUtils');
+
+// Reading the Spanish of a doctor's plan and of the assistant's reply about it.
+
+const NUMBER_WORDS = Object.freeze({
+  un: 1, uno: 1, una: 1, dos: 2, tres: 3, cuatro: 4, cinco: 5, seis: 6, siete: 7, ocho: 8, nueve: 9, diez: 10,
+  once: 11, doce: 12, trece: 13, catorce: 14, quince: 15, dieciseis: 16, dieciocho: 18, veinte: 20, veinticuatro: 24,
+  treinta: 30, 'treinta y seis': 36, cuarenta: 40, 'cuarenta y ocho': 48, 'setenta y dos': 72,
+});
+const WORDS = Object.keys(NUMBER_WORDS).sort((a, b) => b.length - a.length).join('|');
+const COUNT = `(?:\\d+|${WORDS})`;
+// «y» is left out: «treinta y cinco» is one number, not a range.
+const TO = '\\s*(?:a|-|o|u)\\s*';
+const DAYS_PER = Object.freeze({ d: 1, dia: 1, dias: 1, semana: 7, semanas: 7, mes: 30, meses: 30 });
+const DAY_UNITS = 'd[ií]as?|semanas?|mes(?:es)?|d\\b';
+
+// «por 5 días», «durante una semana», «x 7 días», «por unos 5 días», «por 3 a 5 días»
+const DURATION_SOURCE = `(?:por|durante|x)\\s+(?:(?:unos|unas|los|las|pr[oó]ximos|otros)\\s+)*(${COUNT})(?:${TO}(${COUNT}))?\\s*(${DAY_UNITS})`;
+const DURATION = new RegExp(`^${DURATION_SOURCE}$`, 'i');
+
+// «VO», «v.o.», «vía oral», «por vía oral», «IV», «SL»…
+const ROUTES = new Set(['vo', 'po', 'oral', 'iv', 'ev', 'intravenosa', 'im', 'intramuscular', 'sc', 'subcutanea', 'sl', 'sublingual', 'topica', 'rectal']);
+// What a drug's name may carry that does not name it: «Ondansetrón 8 mg», «Metoclopramida gotas».
+const NOT_A_NAME = /^(?:\d+(?:mg|ml|mcg|g|ui)?|mg|ml|mcg|g|ui|vo|iv|im|sc|sl|oral|tabletas?|capsulas?|comprimidos?|gotas|jarabe|crema|gel|unguento|solucion|suspension|sobres?|ampolletas?|ampulas?|parches?|spray|colirio)$/;
+
+const URGENCY_WORDS = /\b(urgencias?|urgente|de inmediato|inmediatamente|emergencias?|911|lo antes posible|cuanto antes|no esperes)\b/g;
+// «no es urgente», «no hay urgencia», «no necesitas ir a urgencias»: the word calms instead of sending the patient.
+// Only filler words may sit between the negation and the word, so «no es normal, ve a urgencias» still counts.
+const CALMING_BEFORE = /\b(?:no\s+(?:es|son|parece|hay|hace\s+falta|necesitas?|requiere|requieres|tienes\s+(?:que|por\s+que))|sin\s+necesidad\s+de)(?:\s+(?:ir|acudir|a|al|una|un|de|la|que))*\s*$/;
+
+const folded = (text) => foldAccents(text).toLowerCase();
+
+const countOf = (word) => (/^\d+$/.test(word) ? Number(word) : NUMBER_WORDS[folded(word).replace(/\s+/g, ' ')] ?? null);
+const daysPer = (unit) => DAYS_PER[folded(unit)];
+
+const isRouteOnly = (text) => ROUTES.has(folded(text).replace(/\./g, '').replace(/^(?:por\s+)?(?:via\s+)?/, '').trim());
+
+// The name in a drug line, without the dose or the form beside it.
+const drugNameOf = (text) => normalizeForAnchor(text).split(' ').filter((word) => word && !NOT_A_NAME.test(word)).join(' ');
+
+// The days a duration phrase says; null for a range or an unknown count, which the doctor settles.
+function durationDays(phrase) {
+  const match = String(phrase ?? '').trim().match(DURATION);
+  if (!match || match[2]) return null;
+  const count = countOf(match[1]);
+  return count ? count * daysPer(match[3]) : null;
+}
+
+const NUMBER_WORD = new RegExp(`\\b(${WORDS})\\b`, 'g');
+const IN_DAYS = new RegExp(`\\b(\\d+)(?:${TO}(\\d+))?\\s*(semanas?|mes(?:es)?|d)\\b`, 'g');
+const DAYS_IN_UNIT = (_, from, to, unit) => [from, to].filter(Boolean).map((value) => value * daysPer(unit)).join(' a ').concat(' dias');
+const TIMES_A_DAY = (written, ...counts) => {
+  const times = counts.slice(0, 2).filter(Boolean).map(Number);
+  return times.every((count) => count > 0 && 24 % count === 0) ? times.map((count) => `cada ${24 / count} horas`).join(' o ') : written;
+};
+
+// One spelling to compare dosing in: no accents, digits for number words, «c/8hs» as «cada 8 horas»,
+// «3 veces al día» as «cada 8 horas», weeks and months as days. A dot stays decimal, as written in Mexico.
+function dosingTextOf(text) {
+  return folded(text)
+    .replace(/\b[1-9]\d{0,2}(?:,\d{3})+\b/g, (thousands) => thousands.replace(/,/g, ''))
+    .replace(/(\d),(\d)/g, '$1.$2')
+    .replace(NUMBER_WORD, (word) => String(countOf(word)))
+    .replace(/\bc\/\s*(\d+)\s*(?:h|hs|hrs?|horas?)\b/g, 'cada $1 horas')
+    .replace(new RegExp(`\\b(\\d+)(?:${TO}(\\d+))?\\s+ve(?:z|ces)\\s+(?:al|por|cada)\\s+dia\\b`, 'g'), TIMES_A_DAY)
+    .replace(/\bcada\s+hora\b/g, 'cada 1 horas')
+    .replace(/\bcada\s+dia\b/g, 'cada 24 horas')
+    .replace(/\b(?:por|durante|x)\s+(?:(?:unos|unas|los|las|proximos|otros)\s+)*(?=\d)/g, 'por ')
+    .replace(IN_DAYS, DAYS_IN_UNIT)
+    .replace(/\s+/g, ' ');
+}
+
+const RANGE = `(\\d+)(?:${TO}(\\d+))?`;
+const HOURS = new RegExp(`cada\\s+${RANGE}\\s*h(?:s|rs?|oras?)?\\b`, 'g');
+const DAYS = new RegExp(`por\\s+${RANGE}\\s+dias?\\b`, 'g');
+const AMOUNTS = /\b(\d+(?:\.\d+)?)\s*(microgramos?|miligramos?|gramos?|mcg|µg|ug|mg|gr?|ml|ui)(?![a-z])/g;
+const UNIT_SCALE = Object.freeze({
+  microgramo: ['mg', 0.001], microgramos: ['mg', 0.001], mcg: ['mg', 0.001], µg: ['mg', 0.001], ug: ['mg', 0.001],
+  miligramo: ['mg', 1], miligramos: ['mg', 1], mg: ['mg', 1],
+  gramo: ['mg', 1000], gramos: ['mg', 1000], g: ['mg', 1000], gr: ['mg', 1000],
+  ml: ['ml', 1], ui: ['ui', 1],
+});
+
+const valuesIn = (text, pattern) => new Set([...text.matchAll(pattern)].flatMap((match) => [match[1], match[2]]).filter(Boolean).map(Number));
+
+// The hours, days and amounts a text gives; amounts are keyed in mg, ml or UI, so «1 g» and «1000 mg» meet.
+function dosingFactsOf(text) {
+  const dosing = dosingTextOf(text);
+  const amounts = new Map([...dosing.matchAll(AMOUNTS)].map(([written, value, unit]) => {
+    const [base, scale] = UNIT_SCALE[unit];
+    return [`${Math.round(Number(value) * scale * 1000) / 1000} ${base}`, written];
+  }));
+  return { hours: valuesIn(dosing, HOURS), days: valuesIn(dosing, DAYS), amounts };
+}
+
+function urgencyWordsIn(text) {
+  const plain = folded(text);
+  return new Set([...plain.matchAll(URGENCY_WORDS)]
+    .filter((match) => !CALMING_BEFORE.test(plain.slice(0, match.index)))
+    .map((match) => match[1]));
+}
+
+module.exports = { DURATION_SOURCE, dosingFactsOf, drugNameOf, durationDays, isRouteOnly, urgencyWordsIn };

package/lib/clinical/services/doctorPlanService.js

@@ -0,0 +1,121 @@
+const { DEFAULT_FOLLOW_UP_HOURS, planInstructions, plannedTextOf } = require('../helpers/doctorPlanHelper');
+const { dosingFactsOf, urgencyWordsIn } = require('../helpers/planTextHelper');
+const { httpError } = require('../../utils/httpErrorUtils');
+const { oneLineOf } = require('../../utils/coercionUtils');
+const { PLAN_FOLLOW_UPS } = require('../../models/escalationReviewModel');
+const { isDrugNamed, unplannedDrugsIn } = require('./treatmentProposalService');
+
+const FIRST_LINE = '1L';
+const MAX_ENTRIES = 10;
+const MAX_FIELD_LENGTH = 300;
+const MAX_NOTE_LENGTH = 1000;
+const MAX_INSTRUCTIONS_LENGTH = 4000;
+const MAX_DAYS = 90;
+const MAX_FOLLOW_UP_HOURS = 168;
+
+const textOf = (value, name, max = MAX_FIELD_LENGTH) => {
+  if (value != null && typeof value !== 'string') throw httpError(400, `${name} must be text`);
+  const text = oneLineOf(value);
+  if (text.length > max) throw httpError(400, `${name} exceeds ${max} characters`);
+  return text || null;
+};
+
+const neededText = (value, name) => {
+  const text = textOf(value, name);
+  if (!text) throw httpError(400, `${name} is required`);
+  return text;
+};
+
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+// Only a number or a string of digits: `true`, `[5]` and `'1e1'` are not days.
+const wholeNumber = (value, name, max) => {
+  const number = typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value.trim())) ? Number(value) : NaN;
+  if (!Number.isInteger(number) || number < 1 || number > max) throw httpError(400, `${name} must be a whole number from 1 to ${max}`);
+  return number;
+};
+
+const listOf = (value, name) => {
+  if (value == null) return [];
+  if (!Array.isArray(value)) throw httpError(400, `${name} must be a list`);
+  if (value.length > MAX_ENTRIES) throw httpError(400, `${name} allows at most ${MAX_ENTRIES} entries`);
+  return value;
+};
+
+function itemOf(item, index) {
+  const name = `plan.items[${index}]`;
+  const position = textOf(item?.position, `${name}.position`)?.toUpperCase() ?? null;
+  const reason = textOf(item?.reason, `${name}.reason`);
+  // An alternative to the first line has to say why the first line does not fit.
+  if (position && position !== FIRST_LINE && !reason) throw httpError(400, `${name}.reason is required for a drug that is not first line`);
+  return {
+    drug: neededText(item?.drug, `${name}.drug`),
+    strength: textOf(item?.strength, `${name}.strength`),
+    dose: neededText(item?.dose, `${name}.dose`),
+    frequency: neededText(item?.frequency, `${name}.frequency`),
+    days: wholeNumber(item?.days, `${name}.days`, MAX_DAYS),
+    position,
+    reason,
+    formularyKey: textOf(item?.formularyKey, `${name}.formularyKey`),
+  };
+}
+
+function followUpOf(value) {
+  if (value != null && !isPlainObject(value)) throw httpError(400, 'plan.followUp must be an object with a kind');
+  const kind = value?.kind ?? 'none';
+  if (!PLAN_FOLLOW_UPS.includes(kind)) throw httpError(400, `plan.followUp.kind must be one of: ${PLAN_FOLLOW_UPS.join(', ')}`);
+  if (kind === 'none') return { kind, hours: null };
+  return { kind, hours: wholeNumber(value?.hours ?? DEFAULT_FOLLOW_UP_HOURS[kind], 'plan.followUp.hours', MAX_FOLLOW_UP_HOURS) };
+}
+
+// The plan as the doctor approved it, refused whole when any line is incomplete.
+function planOf(input) {
+  if (!isPlainObject(input)) throw httpError(400, 'plan is required');
+  const plan = {
+    items: listOf(input.items, 'plan.items').map((item, index) => {
+      if (!isPlainObject(item)) throw httpError(400, `plan.items[${index}] must be an object`);
+      return itemOf(item, index);
+    }),
+    studies: listOf(input.studies, 'plan.studies').map((study, index) => ({
+      name: neededText(study?.name, `plan.studies[${index}].name`),
+      instructions: textOf(study?.instructions, `plan.studies[${index}].instructions`),
+    })),
+    homeCare: listOf(input.homeCare, 'plan.homeCare').map((entry, index) => neededText(entry, `plan.homeCare[${index}]`)),
+    note: textOf(input.note, 'plan.note', MAX_NOTE_LENGTH),
+    followUp: followUpOf(input.followUp),
+  };
+  if (!plan.items.length && !plan.studies.length && !plan.homeCare.length && !plan.note) {
+    throw httpError(400, 'plan needs a drug, a study, a home care measure or a note');
+  }
+  return plan;
+}
+
+// The doctor's edit wins; with none, the instructions follow the plan.
+function approvedInstructions(plan, edited) {
+  if (edited != null && typeof edited !== 'string') throw httpError(400, 'instructions must be text');
+  if (!edited?.trim()) return { instructions: planInstructions(plan), instructionsEdited: false };
+  const instructions = edited.trim();
+  if (instructions.length > MAX_INSTRUCTIONS_LENGTH) throw httpError(400, `instructions exceed ${MAX_INSTRUCTIONS_LENGTH} characters`);
+  return { instructions, instructionsEdited: instructions !== planInstructions(plan) };
+}
+
+const strays = (said, planned) => [...said].filter((value) => !planned.has(value));
+
+// What in the assistant's reply strays from the plan, for the team to check.
+function replyIssues(plan, reply) {
+  if (!oneLineOf(reply)) return ['no se pudo leer el mensaje enviado'];
+  const planned = plannedTextOf(plan);
+  const said = dosingFactsOf(reply);
+  const allowed = dosingFactsOf(planned);
+  const issues = plan.items.filter((item) => !isDrugNamed(reply, item.drug)).map((item) => `no menciona ${item.drug}`);
+  for (const hours of strays(said.hours, allowed.hours)) issues.push(`dice «cada ${hours} horas», que no está en el plan`);
+  for (const days of strays(said.days, allowed.days)) issues.push(`dice «por ${days} días», que no está en el plan`);
+  for (const [amount, written] of said.amounts) {
+    if (!allowed.amounts.has(amount)) issues.push(`dice «${written}», que no está en el plan`);
+  }
+  for (const name of unplannedDrugsIn(reply, planned)) issues.push(`menciona ${name}, que el médico no indicó`);
+  for (const word of strays(urgencyWordsIn(reply), urgencyWordsIn(planned))) issues.push(`usa «${word}», que el médico no indicó`);
+  return issues;
+}
+
+module.exports = { approvedInstructions, planOf, replyIssues };

package/lib/clinical/services/treatmentProposalService.js

@@ -1,3 +1,4 @@
+const { drugNameOf } = require('../helpers/planTextHelper');
 const { TREATMENT_FORMULARY, findDrug, formularyFor } = require('../protocols/treatmentFormulary');
 
 const { normalizeForAnchor: key } = require('../../utils/textMatchUtils');
@@ -90,7 +91,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 FORMULARY_DRUGS = TREATMENT_FORMULARY.flatMap((entry) => entry.drugs).filter((drug) => drug.isPharmacological !== false);
+const ALL_FORMULARY_DRUGS = TREATMENT_FORMULARY.flatMap((entry) => entry.drugs);
+const FORMULARY_DRUGS = ALL_FORMULARY_DRUGS.filter((drug) => drug.isPharmacological !== false);
 const DRUG_NAMES = [...new Set(FORMULARY_DRUGS.flatMap(namesOf))];
 
 function resolvedDrugs(proposals) {
@@ -134,8 +136,22 @@ function crossSymptomIssues(proposals) {
   return issues;
 }
 
+// The text names the drug: every part of it («Paracetamol/Codeína»), a name in parentheses, or a formulary brand of it.
+// The dose or the form beside the name («Ondansetrón 8 mg», «(400 mg)») does not have to be said.
+function isDrugNamed(text, drugName) {
+  const padded = ` ${key(text)} `;
+  const says = (name) => Boolean(name) && padded.includes(` ${name} `);
+  const name = String(drugName ?? '');
+  const outside = name.replace(/\(.*?\)/g, ' ');
+  const inside = [...name.matchAll(/\((.*?)\)/g)].map((match) => drugNameOf(match[1]));
+  const brands = ALL_FORMULARY_DRUGS.filter((drug) => drugNameOf(drug.drug) === drugNameOf(outside)).flatMap((drug) => String(drug.brand ?? '').split('/').map(key));
+  const parts = outside.split(/\s*[/+]\s*/).map(drugNameOf).filter(Boolean);
+  return (parts.length > 0 && parts.every(says)) || [...inside, ...brands].some(says);
+}
+
 module.exports = {
   JUSTIFICATION_KINDS,
+  isDrugNamed,
   validateProposal,
   unproposedDrugsIn,
   unplannedDrugsIn,

package/lib/services/escalationReviewService.js

@@ -31,11 +31,10 @@ const { generateEscalationDraft } = require('../clinical/services/escalationDraf
 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, unplannedDrugsIn } = require('../clinical/services/treatmentProposalService');
+const { drugsNamedIn } = require('../clinical/services/treatmentProposalService');
 const { characterizationSeedOf } = require('../clinical/helpers/reviewUpdateHelper');
-const {
-  approvedInstructions, assistantInstructionsOf, needsPrescriber, planInstructions, planOf, planSummary, prescriptionText, plannedTextOf, proposedPlanOf, replyIssues,
-} = require('../clinical/helpers/doctorPlanHelper');
+const { assistantInstructionsOf, needsPrescriber, planInstructions, planSummary, prescriptionText, proposedPlanOf } = require('../clinical/helpers/doctorPlanHelper');
+const { approvedInstructions, planOf, replyIssues } = require('../clinical/services/doctorPlanService');
 const { readNoteFacts, assertionOf } = require('../clinical/services/escalationNoteFactsService');
 const { humanReplyFilter } = require('../clinical/config/safetyNetConfig');
 const {
@@ -2219,8 +2218,7 @@ async function sendPlanThroughAssistant({ claimed, claim, decisionNumber, plan,
   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 issues = [...replyIssues(plan, reply), ...(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 }),

package/package.json

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