@peopl-health/nexus 6.3.0-dev.18380 → 6.3.0-dev.18429

package/lib/clinical/services/escalationDraftService.js

@@ -1,6 +1,6 @@
 const { getEscalationDraft } = require('../config/subAgentsConfig');
 
-const { FORMULARY_VERSION, TREATMENT_FORMULARY } = require('../protocols/treatmentFormulary');
+const { FORMULARY_VERSION, TREATMENT_FORMULARY, findDrug, formularyFor } = require('../protocols/treatmentFormulary');
 
 const { createLLMProvider } = require('../providers/createLLMProvider');
 
@@ -9,12 +9,12 @@ const { readStructuredText } = require('../helpers/structuredTextHelper');
 
 const { getEscalationContext } = require('../../services/escalationContextService');
 
-const { normalizedKeyOf } = require('../../utils/coercionUtils');
+const { inlineOf, normalizedKeyOf } = require('../../utils/coercionUtils');
 const { logger } = require('../../utils/logger');
 const { arrayArg, safeParse } = require('../../utils/jsonUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
 
-const { crossSymptomIssues, drugsNamedIn, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
+const { JUSTIFICATION_KINDS, crossSymptomIssues, drugsNamedIn, unproposedDrugsIn, validateProposal } = require('./treatmentProposalService');
 
 const CONVERSATION_TURNS = 40;
 const TRIAGE_LIMIT = 3;
@@ -46,6 +46,38 @@ function settleProposal(parsed) {
 
 const textList = (value) => (Array.isArray(value) ? value.map(trimmed).filter(Boolean) : []);
 
+function symptomRecordOf({ block, proposal, conduct }, confirmed) {
+  const { present, absent, unassessed } = flagsByStatus(block);
+  const entry = proposal && formularyFor(proposal.symptom);
+  const itemOf = (item) => {
+    const drug = findDrug(entry, item);
+    return {
+      drug: drug.drug,
+      brand: drug.brand ?? null,
+      strength: drug.strength ?? null,
+      instructions: drug.instructions ?? null,
+      position: drug.position,
+      justification: trimmed(item.justification?.text) || null,
+      justificationKind: JUSTIFICATION_KINDS.includes(item.justification?.kind) ? item.justification.kind : null,
+    };
+  };
+  return {
+    symptom: inlineOf(block.symptom) || null,
+    grade: [1, 2, 3, 4, 5].includes(block.grade) ? block.grade : null,
+    presentRedFlags: present,
+    absentRedFlags: absent,
+    unassessedRedFlags: unassessed,
+    proposal: proposal ? {
+      formularyKey: entry.key,
+      items: proposal.items.map(itemOf),
+      conditions: textList(proposal.conditions),
+      ruledOut: textList(proposal.ruledOut),
+      confirmed,
+    } : null,
+    conduct: conduct ?? null,
+  };
+}
+
 function suggestCallOf(value) {
   if (typeof value?.value !== 'boolean') return null;
   return { value: value.value, reason: trimmed(value.reason) || null };
@@ -231,6 +263,7 @@ async function generateEscalationDraft({
     blockingFlag: sufficientForDoctor === false ? trimmed(parsed?.blockingFlag) || null : null,
     suggestCall: suggestCallOf(parsed?.suggestCall),
     sectionsUnavailable: context.degradedSections ?? [],
+    symptoms: settled.map((entry) => symptomRecordOf(entry, isConfirmed(entry))),
   };
 }
 

package/lib/clinical/services/treatmentProposalService.js

@@ -129,6 +129,7 @@ function crossSymptomIssues(proposals) {
 }
 
 module.exports = {
+  JUSTIFICATION_KINDS,
   validateProposal,
   unproposedDrugsIn,
   drugsNamedIn,

package/lib/models/escalationReviewModel.js

@@ -133,6 +133,35 @@ const suggestCallSchema = new mongoose.Schema({
   reason: { type: String, default: null },
 }, { _id: false });
 
+const proposedItemSchema = new mongoose.Schema({
+  drug: { type: String, required: true },
+  brand: { type: String, default: null },
+  strength: { type: String, default: null },
+  instructions: { type: String, default: null },
+  position: { type: String, default: null },
+  justification: { type: String, default: null },
+  justificationKind: { type: String, default: null },
+}, { _id: false });
+
+const draftSymptomSchema = new mongoose.Schema({
+  symptom: { type: String, default: null },
+  grade: { type: Number, default: null },
+  presentRedFlags: { type: [String], default: undefined },
+  absentRedFlags: { type: [String], default: undefined },
+  unassessedRedFlags: { type: [String], default: undefined },
+  proposal: {
+    type: new mongoose.Schema({
+      formularyKey: { type: String, required: true },
+      items: { type: [proposedItemSchema], default: undefined },
+      conditions: { type: [String], default: undefined },
+      ruledOut: { type: [String], default: undefined },
+      confirmed: { type: Boolean, default: false },
+    }, { _id: false }),
+    default: null,
+  },
+  conduct: { type: String, default: null },
+}, { _id: false });
+
 const draftSchema = new mongoose.Schema({
   doctorText: { type: String, required: true },
   patientMessage: { type: String, required: true },
@@ -149,6 +178,7 @@ const draftSchema = new mongoose.Schema({
   missingCharacterization: { type: [String], default: undefined },
   suggestCall: { type: suggestCallSchema, default: undefined },
   sectionsUnavailable: { type: [String], default: undefined },
+  symptoms: { type: [draftSymptomSchema], default: undefined },
   snapshotAt: { type: Date, default: undefined },
 }, { timestamps: { createdAt: true, updatedAt: false } });
 

package/lib/services/characterizationOutcomeService.js

@@ -57,7 +57,6 @@ const graveDueAt = (review, clock, flag) => {
 function outcomeOf(review, clock, now) {
   const wait = pendingWaitMinutes(clock?.level);
   if (!wait || !OUTCOME_LEVELS.includes(clock.level) || !['draft_ready', 'awaiting_doctor'].includes(review.status)) return null;
-  // Handoffs count since the last decision, so a higher alarm on a case already with the doctor goes as an update.
   const decidedAt = Math.max(0, ...(review.decisions ?? []).map((decision) => timeOf(decision.createdAt)));
   const handoffs = (review.doctorHandoffs ?? []).filter((handoff) => timeOf(handoff.createdAt) > decidedAt);
   const last = handoffs.at(-1);
@@ -74,7 +73,7 @@ function outcomeOf(review, clock, now) {
   const present = latest.urgentPresentRedFlags ?? [];
   // An update reaches the doctor's phone only with a grave flag the draft they have did not show; the panel always shows the latest draft.
   const handedPresent = new Set((update ? review.drafts[last.draftNumber - 1]?.urgentPresentRedFlags ?? [] : []).map(flagKey));
-  // A higher alarm already rang the doctor's phone since the last handoff, so its update shows in the panel only; Airtable's alert goes to the team.
+  // Airtable's alert reaches the team, not the doctor's phone.
   const raisedSince = (level) => (review.alarms ?? []).some((alarm) => alarm.urgencyLevel === level && timeOf(alarm.raisedAt) > timeOf(last.createdAt));
   const rangSince = update && (review.doctorAlerts ?? []).some((sent) => sent.kind === 'initial' && !sent.error
     && sent.transport && sent.transport !== 'airtable' && timeOf(sent.sentAt) > timeOf(last.createdAt) && raisedSince(sent.urgencyLevel));

package/lib/services/escalationReviewService.js

@@ -1030,7 +1030,7 @@ async function caseTakenReason(review, from, level) {
   const changes = review.urgencyReclassifications ?? [];
   const levelsAt = (at) => levelsOf(currentAlarms(review).filter((alarm) => new Date(alarm.raisedAt) <= new Date(at)), changes.filter((change) => new Date(change.at) < new Date(at)), appliedLevelOf);
   if (level !== 'stat' && levelsAt(new Date(8.64e15)).some((entry) => entry.level === 'stat')) return 'stat_alarm';
-  // Lowering the level, from what this episode's alarms were at, means someone looked at the case; a raise restarts the clock instead.
+  // A lowering means someone looked at the case; a raise restarts the clock instead.
   const lowered = (change) => (URGENCY_RANK[change.toLevel] || 0) < Math.max(0, ...levelsAt(change.at).map((entry) => URGENCY_RANK[entry.level] || 0));
   if (changes.some((change) => atOrAfter(change.at) && lowered(change))) return 'reclassified';
   if ((review.callLogs ?? []).some((call) => call.outcome === 'contacted' && atOrAfter(call.calledAt))) return 'call_contacted';
@@ -1489,6 +1489,7 @@ async function generateBotDraft({ id, lease = null } = {}) {
     missingCharacterization: draft.missingCharacterization,
     ...(draft.suggestCall && { suggestCall: draft.suggestCall }),
     ...(draft.sectionsUnavailable?.length && { sectionsUnavailable: draft.sectionsUnavailable }),
+    ...(draft.symptoms?.length && { symptoms: draft.symptoms }),
   };
   const EscalationReview = getEscalationReview();
   const saved = await EscalationReview.findOneAndUpdate(

package/lib/services/gravePendingService.js

@@ -20,7 +20,6 @@ function pendingFlagsOf(review, since) {
   return { latest: drafts.at(-1) ?? null, flags: [...firstSeen].map(([flag, firstSeenAt]) => ({ flag, firstSeenAt, unobtainable: unobtainable.includes(flag) })) };
 }
 
-// The bot keeps documenting a case it handed to the doctor itself while it still redrafts it, so its grave questions still wait for the patient there.
 const stillDocumented = (review) => DOCUMENTING_STATUSES.includes(review.status) || updatesDoctor(review);
 
 // The latest draft speaks for the case only while no newer patient turn or redraft is waiting to replace it.

package/lib/services/reviewDeadlineService.js

@@ -45,7 +45,7 @@ function responseDeadlinePolicy() {
   };
 }
 
-// Each alarm at the level the team set for it since it was raised; a raise restarts its clock, a lowering keeps it.
+// A raise restarts the alarm's clock; a lowering keeps it.
 function levelsOf(alarms, reclassifications, startLevel = (alarm) => alarm.urgencyLevel) {
   const changes = [...(reclassifications ?? [])].sort((a, b) => timeOf(a.at) - timeOf(b.at));
   return (alarms ?? []).map((alarm) => changes

package/lib/services/untakenAlertService.js

@@ -34,8 +34,7 @@ const duration = (minutes) => {
   return rest ? `${hours} h ${rest} min` : `${hours} h`;
 };
 
-// The clock runs at the highest level since the last decision, its stages from the first alarm or team raise at that level.
-// The episode keeps the start the alarms' own levels give it, so a reclassification never re-keys its drafts or grave alerts.
+// Only the stages restart on a raise; the episode start ignores reclassifications so drafts and grave alerts keep their key.
 function episodeStartOf(alarms) {
   const top = alarms.reduce((level, alarm) => ((URGENCY_RANK[appliedLevelOf(alarm)] || 0) > (URGENCY_RANK[level] || 0) ? appliedLevelOf(alarm) : level), null);
   return new Date(Math.min(...alarms.filter((alarm) => appliedLevelOf(alarm) === top).map((alarm) => new Date(alarm.raisedAt).getTime())));

package/package.json

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