@peopl-health/nexus 5.11.0-dev.1128 → 5.11.0-dev.1130

package/lib/clinical/AssistantProcessor.js

@@ -8,7 +8,7 @@ const { overlayCohortPreset } = require('./helpers/cohortHelper');
 const { forkShadowTurn } = require('./services/shadowService');
 const { diverge } = require('./services/divergenceService');
 const { getAssistantById } = require('./services/assistantResolver');
-const { maybeSendBridge, clearBridgeState } = require('./services/bridgeService');
+const { maybeSendBridge } = require('./services/bridgeService');
 const { getBridgePresetId } = require('./flags/bridgeConfig');
 const { ToolRuntimeContext } = require('./context/ToolRuntimeContext');
 
@@ -45,11 +45,7 @@ class AssistantProcessor {
 
     if (thread.isInCohort && !runOptions.toolRuntimeContext && runOptions.runId && thread.code) {
       try {
-        runOptions.toolRuntimeContext = new ToolRuntimeContext({
-          patientCode: thread.code,
-          turnId: runOptions.runId,
-          shouldContinue: runOptions.shouldContinue,
-        });
+        runOptions.toolRuntimeContext = new ToolRuntimeContext({ patientCode: thread.code, turnId: runOptions.runId });
       } catch (error) {
         logger.warn('[AssistantProcessor] turn will run untraced', { code: thread.code, error: error.message });
       }
@@ -87,6 +83,7 @@ class AssistantProcessor {
         outbound: output,
         completed: runResult?.completed,
         predictionTimeMs,
+        shouldContinue: runOptions.shouldContinue,
       });
     } catch (error) {
       logger.warn('[AssistantProcessor] trace not stored', {
@@ -139,7 +136,6 @@ class AssistantProcessor {
     if (!this.sendMessage) throw new Error('sendMessage function not configured');
     if (!result?.output) return null;
     await this.sendMessage({ code, body: result.output, processed: true, origin: 'assistant', tools_executed: result.tools_executed, prompt: result.prompt, preset: result.preset, response_id: result.response_id, turnId: result.turnId, traceId: result.traceId });
-    clearBridgeState(code);
     return result.output;
   }
 }

package/lib/clinical/context/ToolRuntimeContext.js

@@ -8,7 +8,6 @@ class ToolRuntimeContext {
     repos = {},
     contextSource = null,
     shadow = false,
-    shouldContinue = null,
   } = {}) {
     if (typeof patientCode !== 'string' || !patientCode) {
       throw new Error('ToolRuntimeContext requires a non-empty patientCode');
@@ -23,7 +22,6 @@ class ToolRuntimeContext {
     this.patientCode = patientCode;
     this.turnId = turnId;
     this.sessionId = sessionId;
-    this.shouldContinue = shouldContinue;
     this.repos = repos;
     this.contextSource = contextSource;
     this.enabledSkills = [];
@@ -44,17 +42,13 @@ class ToolRuntimeContext {
     return toolData;
   }
 
-  isLive() {
-    return typeof this.shouldContinue !== 'function' || this.shouldContinue();
-  }
-
-  async store({ outbound = null, completed = false, predictionTimeMs = null } = {}) {
+  async store({ outbound = null, completed = false, predictionTimeMs = null, shouldContinue = null } = {}) {
     this.trace.setSignals({ activatedSkills: [...this.activatedSkills].sort() });
     this.trace.setOutbound(outbound);
-    const superseded = !this.isLive();
-    this.trace.setStatus(superseded ? 'superseded' : (completed ? 'completed' : 'incomplete'));
+    this.trace.setStatus(completed ? 'completed' : 'incomplete');
     this.trace.setTimings({ predictionTimeMs });
-    await this.trace.save();
+    const superseded = shouldContinue && !shouldContinue();
+    if (!superseded) await this.trace.save();
   }
 
   setSafetyArtifact(artifact) {

package/lib/clinical/providers/AnthropicProvider.js

@@ -11,7 +11,7 @@ const { logger } = require('../../utils/logger');
 
 const runtimeConfig = require('../../config/runtimeConfig');
 
-const { BaseLLMProvider, CONVERSATION_CONTINUATION, DELIVERY_NUDGE, MAX_DELIVERY_NUDGES, TERMINAL_DELIVERY_TOOLS, isSuperseded } = require('./BaseLLMProvider');
+const { BaseLLMProvider, CONVERSATION_CONTINUATION, DELIVERY_NUDGE, MAX_DELIVERY_NUDGES, TERMINAL_DELIVERY_TOOLS } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const DEFAULT_MAX_FUNCTION_ROUNDS = 12;
@@ -69,7 +69,7 @@ class AnthropicProvider extends BaseLLMProvider {
   async _invokeModel({
     instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
     modelConfig, assistant, phiProcessor = null, trace = null, onFirstIteration = null,
-    resolvedPromptId = null, resolvedPresetId = null, shouldContinue = null
+    resolvedPromptId = null, resolvedPresetId = null
   }, options = {}) {
     const executeTools = options.toolExecutor || handleFunctionCalls;
     let totalRetries = 0;
@@ -170,7 +170,7 @@ class AnthropicProvider extends BaseLLMProvider {
         && (response.content || []).some(block => block.type === 'tool_use');
       try {
         const decision = onFirstIteration({ narrationText, hasToolCalls });
-        if (decision?.dedupNote) bridgeNote = decision.dedupNote;
+        if (decision?.sent && decision.dedupNote) bridgeNote = decision.dedupNote;
       } catch (err) {
         logger.warn('[AnthropicProvider] bridge callback failed', { error: err.message });
       }
@@ -187,10 +187,6 @@ class AnthropicProvider extends BaseLLMProvider {
       let deliveryBreak = false;
       const maxIterations = this.maxFunctionRounds + MAX_DELIVERY_NUDGES + LOOP_ITERATION_HEADROOM;
       for (let iteration = 1; iteration <= maxIterations; iteration++) {
-        if (isSuperseded(shouldContinue)) {
-          logger.info('[AnthropicProvider] turn superseded — aborting tool loop', { iteration });
-          break;
-        }
         const content = finalResponse.content || [];
         const toolUses = content.filter(block => block.type === 'tool_use');
         const ended = finalResponse.stop_reason !== 'tool_use' || !toolUses.length;
@@ -255,9 +251,9 @@ class AnthropicProvider extends BaseLLMProvider {
       }
 
       // Budget exhausted mid-work: the loop stopped while the model still wanted tools, so the reply may be empty. Make it
-      // visible — but not on a supersede or delivery break, which also exit with pending calls and are not exhaustion.
+      // visible — but not on a delivery break, which also exits with pending calls and is not exhaustion.
       const pendingTools = (finalResponse.content || []).filter(block => block.type === 'tool_use');
-      if (finalResponse.stop_reason === 'tool_use' && pendingTools.length && !deliveryBreak && !isSuperseded(shouldContinue)) {
+      if (finalResponse.stop_reason === 'tool_use' && pendingTools.length && !deliveryBreak) {
         logger.warn('[AnthropicProvider] Tool-iteration budget exhausted with pending tool calls', { maxFunctionRounds: this.maxFunctionRounds, pending: pendingTools.map(b => b.name) });
         trace?.setSignals?.({ toolBudgetExhausted: true });
       }

package/lib/clinical/providers/BaseLLMProvider.js

@@ -18,10 +18,6 @@ const TERMINAL_DELIVERY_TOOLS = new Set(['DeliverPatientMessage']);
 const DELIVERY_NUDGE = 'sistema: el turno no puede cerrar sin un mensaje para el paciente. Llama ahora a DeliverPatientMessage con message_text en español. No repitas herramientas clínicas ya ejecutadas en este turno.';
 const MAX_DELIVERY_NUDGES = 1;
 
-function isSuperseded(shouldContinue) {
-  return typeof shouldContinue === 'function' && !shouldContinue();
-}
-
 class BaseLLMProvider {
   constructor(options = {}) {
     if (new.target === BaseLLMProvider) {
@@ -336,8 +332,8 @@ class BaseLLMProvider {
           return result;
         }
 
-        if (isSuperseded(config.shouldContinue)) {
-          logger.info('[runConversation] Superseded — returning without retry', { attempt, shadow: config.shadow });
+        if (config.shadow && !config.shouldContinue()) {
+          logger.info('[runConversation] Shadow superseded — returning without retry', { attempt });
           return result;
         }
 
@@ -348,8 +344,8 @@ class BaseLLMProvider {
         await new Promise(r => setTimeout(r, 500));
       } catch (error) {
         logger.error('[runConversation] Attempt failed', { attempt, error: error.message });
-        if (isSuperseded(config.shouldContinue)) {
-          logger.info('[runConversation] Superseded — abandoning after error', { attempt, shadow: config.shadow });
+        if (config.shadow && !config.shouldContinue()) {
+          logger.info('[runConversation] Shadow superseded — abandoning after error', { attempt });
           return { status: 'cancelled', output_text: '', tools_executed: [], retries: 0 };
         }
         if (attempt === maxRetries) throw error;
@@ -532,5 +528,4 @@ module.exports = {
   DELIVERY_NUDGE,
   MAX_DELIVERY_NUDGES,
   TERMINAL_DELIVERY_TOOLS,
-  isSuperseded,
 };

package/lib/clinical/providers/OpenAIResponsesProvider.js

@@ -9,7 +9,7 @@ const { logger } = require('../../utils/logger');
 
 const runtimeConfig = require('../../config/runtimeConfig');
 
-const { BaseLLMProvider, isSuperseded } = require('./BaseLLMProvider');
+const { BaseLLMProvider } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const DEFAULT_MAX_FUNCTION_ROUNDS = 12;
@@ -69,7 +69,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     shadow = false, shouldContinue = null, onFirstIteration = null
   }, options = {}) {
     const executeTools = options.toolExecutor || handleFunctionCalls;
-    const superseded = () => isSuperseded(shouldContinue);
+    const shadowSuperseded = () => shadow && !shouldContinue();
     let totalRetries = 0;
     const allToolsExecuted = [];
     const allToolCalls = [];
@@ -127,7 +127,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
       const hasToolCalls = Boolean(assistant) && (response.output || []).some(item => item.type === 'function_call');
       try {
         const decision = onFirstIteration({ narrationText, hasToolCalls });
-        if (decision?.dedupNote) bridgeNote = decision.dedupNote;
+        if (decision?.sent && decision.dedupNote) bridgeNote = decision.dedupNote;
       } catch (err) {
         logger.warn('[OpenAIResponsesProvider] bridge callback failed', { error: err.message });
       }
@@ -140,8 +140,8 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
       apiCallConfig.tool_choice = followUpToolChoice;
 
       for (let round = 1; round <= this.maxFunctionRounds; round++) {
-        if (superseded()) {
-          logger.info('[OpenAIResponsesProvider] turn superseded — aborting tool loop', { round, shadow });
+        if (shadowSuperseded()) {
+          logger.info('[OpenAIResponsesProvider] shadow superseded — aborting tool loop', { round });
           break;
         }
         const functionCalls = finalResponse.output.filter(item => item.type === 'function_call');
@@ -167,9 +167,9 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
       }
 
       // Budget exhausted mid-work: the loop stopped while the model still wanted tools, so the reply may be empty. Make it
-      // visible — but not on a supersede or delivery break, which also exit with pending calls and are not exhaustion.
+      // visible — but not on a shadow-supersede or delivery break, which also exit with pending calls and are not exhaustion.
       const pendingCalls = (finalResponse.output || []).filter(item => item.type === 'function_call');
-      if (pendingCalls.length && !superseded() && !deliveryBreak) {
+      if (pendingCalls.length && !shadowSuperseded() && !deliveryBreak) {
         logger.warn('[OpenAIResponsesProvider] Tool-iteration budget exhausted with pending tool calls', { maxFunctionRounds: this.maxFunctionRounds, pending: pendingCalls.map(c => c.name) });
         trace?.setSignals?.({ toolBudgetExhausted: true });
       }

package/lib/clinical/providers/OpenRouterProvider.js

@@ -1,12 +1,10 @@
 const { OpenAI } = require('openai');
 
-const { logger } = require('../../utils/logger');
 const { retryWithBackoff } = require('../../utils/retryUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
 const { safeParse } = require('../../utils/jsonUtils');
 
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
-const { isSuperseded } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
@@ -39,7 +37,7 @@ class OpenRouterProvider extends OpenAIResponsesProvider {
 
   async _invokeModel({
     instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
-    modelConfig, assistant, phiProcessor = null, trace = null, shouldContinue = null
+    modelConfig, assistant, phiProcessor = null, trace = null
   }, options = {}) {
     const executeTools = options.toolExecutor || handleFunctionCalls;
     let totalRetries = 0;
@@ -76,10 +74,6 @@ class OpenRouterProvider extends OpenAIResponsesProvider {
       apiCallConfig.tool_choice = followUpToolChoice;
 
       for (let round = 1; round <= this.maxFunctionRounds; round++) {
-        if (isSuperseded(shouldContinue)) {
-          logger.info('[OpenRouterProvider] turn superseded — aborting tool loop', { round });
-          break;
-        }
         const message = finalResponse.choices?.[0]?.message;
         const toolCalls = message?.tool_calls || [];
         if (!toolCalls.length) break;

package/lib/clinical/services/bridgeService.js

@@ -25,9 +25,9 @@ function buildDedupNote(bridgeText) {
 function maybeSendBridge({ narrationText, hasToolCalls, code, turnId = null, traceId = null, shouldContinue, sendMessage }) {
   if (!isBridgeEnabled()) return { sent: false };
 
-  const skip = (reason, extra = {}) => {
+  const skip = (reason) => {
     logger.info('[bridge] skipped', { code, reason });
-    return { sent: false, ...extra };
+    return { sent: false };
   };
 
   if (typeof shouldContinue === 'function' && !shouldContinue()) return skip('superseded');
@@ -36,44 +36,20 @@ function maybeSendBridge({ narrationText, hasToolCalls, code, turnId = null, tra
   const text = sanitizeBridgeText(narrationText);
   if (!text) return skip('no_usable_narration');
 
-  const pending = bridgeTimestamps.get(code);
-  if (pending !== undefined) {
-    return skip('recent_bridge_in_thread', pending.delivered ? { dedupNote: pending.dedupNote } : {});
-  }
+  if (bridgeTimestamps.get(code) !== undefined) return skip('recent_bridge_in_thread');
 
-  const dedupNote = buildDedupNote(text);
-  const entry = { dedupNote, delivered: false, clearWhenDelivered: false };
-  bridgeTimestamps.set(code, entry);
-  const failed = (err) => {
-    bridgeTimestamps.delete(code);
-    logger.warn('[bridge] send failed', { code, error: err.message });
-  };
-  const delivered = () => {
-    entry.delivered = true;
-    if (entry.clearWhenDelivered && bridgeTimestamps.get(code) === entry) bridgeTimestamps.delete(code);
-  };
+  bridgeTimestamps.set(code, true);
   try {
     Promise.resolve(sendMessage({ code, body: text, processed: true, origin: 'assistant', raw: { bridge: true }, turnId, traceId }))
-      .then(delivered)
-      .catch(failed);
+      .catch(err => logger.warn('[bridge] send failed', { code, error: err.message }));
   } catch (err) {
-    failed(err);
+    logger.warn('[bridge] send failed', { code, error: err.message });
   }
 
   logger.info('[bridge] sent', { code });
-  return { sent: true, text, dedupNote };
-}
-
-function clearBridgeState(code) {
-  const pending = bridgeTimestamps.get(code);
-  if (pending && !pending.delivered) {
-    pending.clearWhenDelivered = true;
-    return;
-  }
-  bridgeTimestamps.delete(code);
+  return { sent: true, text, dedupNote: buildDedupNote(text) };
 }
 
 module.exports = {
   maybeSendBridge,
-  clearBridgeState,
 };

package/lib/clinical/services/clinicalAirtableService.js

@@ -21,21 +21,16 @@ const INTAKE_SOURCE_TO_AIRTABLE = {
   team_relay: 'doctor',
 };
 
-async function auditedWrite({ trace, code, table, write, isLive = null }) {
+async function auditedWrite({ trace, code, table, write }) {
   const entry = { table, at: new Date().toISOString(), ok: false };
-  if (isLive && !isLive()) {
-    entry.skipped = 'superseded';
-    logger.info('[clinicalAirtableService] Airtable write skipped — turn superseded', { table, code });
-  } else {
-    try {
-      const result = await write();
-      entry.ok = true;
-      const record = Array.isArray(result) ? result[0] : result;
-      if (record?.id) entry.recordId = record.id;
-    } catch (err) {
-      entry.error = err?.message || String(err);
-      logger.error('[clinicalAirtableService] Airtable write failed', { table, code, error: entry.error });
-    }
+  try {
+    const result = await write();
+    entry.ok = true;
+    const record = Array.isArray(result) ? result[0] : result;
+    if (record?.id) entry.recordId = record.id;
+  } catch (err) {
+    entry.error = err?.message || String(err);
+    logger.error('[clinicalAirtableService] Airtable write failed', { table, code, error: entry.error });
   }
   if (trace?.setSignals) {
     const existing = Array.isArray(trace.signals?.airtableWrites) ? trace.signals.airtableWrites : [];
@@ -97,11 +92,10 @@ async function recordEmergency({ code, trace, symptom, suspectedCondition = '',
   });
 }
 
-async function recordClinicalIntake({ code, trace, messageRaw, source = 'self', isLive = null }) {
+async function recordClinicalIntake({ code, trace, messageRaw, source = 'self' }) {
   return auditedWrite({
     trace,
     code,
-    isLive,
     table: 'intake',
     write: async () => {
       const patientId = await findIntakePatientRecordId(code);
@@ -116,13 +110,12 @@ async function recordClinicalIntake({ code, trace, messageRaw, source = 'self',
   });
 }
 
-async function recordReminder({ code, trace, actionType, reminderId, reminderDateUtc, reminderType, description, isLive = null }) {
+async function recordReminder({ code, trace, actionType, reminderId, reminderDateUtc, reminderType, description }) {
   const type = REMINDER_TYPE_TO_AIRTABLE[reminderType] || reminderType;
   if (actionType === 'update') {
     return auditedWrite({
       trace,
       code,
-      isLive,
       table: 'reminder',
       write: async () => {
         const updated = await airtableService.updateRecordByFilter(
@@ -140,7 +133,6 @@ async function recordReminder({ code, trace, actionType, reminderId, reminderDat
   return auditedWrite({
     trace,
     code,
-    isLive,
     table: 'reminder',
     write: () => airtableService.addLinkedRecord(
       Monitoreo_ID,

package/lib/clinical/services/shadowService.js

@@ -27,7 +27,7 @@ async function runShadowTurn({
   const shadowAssistant = resolveAssistant(shadowThread);
 
   const context = new ToolRuntimeContext({
-    patientCode: code, turnId: runId, sessionId, shadow: true, shouldContinue,
+    patientCode: code, turnId: runId, sessionId, shadow: true,
   });
 
   const runOptions = {

package/lib/clinical/tools/extractClinicalInfoTool.js

@@ -153,7 +153,6 @@ async function handler(args, context = {}) {
       trace,
       messageRaw: intakeSummary,
       source: intakeSource,
-      isLive: runtime.isLive?.bind(runtime),
     });
   }
 

package/lib/clinical/tools/schedulePatientReminderTool.js

@@ -107,18 +107,11 @@ async function handler(args = {}, context = {}) {
     };
     trace.setSignals({ reminderIntents: [...existing, intent] });
 
-    const isLive = runtime.isLive?.bind(runtime);
-    const superseded = Boolean(isLive) && !isLive();
-
     if (runtime.patientCode) {
-      if (superseded) {
-        logger.info('[schedulePatientReminder] reminder projection skipped — turn superseded', { turnId });
-      } else {
-        try {
-          await dispatchReminder({ intent, patientId: runtime.patientCode });
-        } catch (err) {
-          logger.warn('[schedulePatientReminder] reminder FHIR projection failed; ack unaffected', { turnId, error: err?.message });
-        }
+      try {
+        await dispatchReminder({ intent, patientId: runtime.patientCode });
+      } catch (err) {
+        logger.warn('[schedulePatientReminder] reminder FHIR projection failed; ack unaffected', { turnId, error: err?.message });
       }
     }
 
@@ -131,7 +124,6 @@ async function handler(args = {}, context = {}) {
         reminderDateUtc: fireMoment.toISOString(),
         reminderType,
         description: storedDescription,
-        isLive,
       });
     }
 

package/lib/fhir/constants/extensionSlugs.js

@@ -1,5 +1,3 @@
-const CONTINGENCY_CATEGORY_PREFIX = 'contingency-';
-
 const SYMPTOM_CASE_EXT = {
   STATUS: 'symptom-case-status',
   LEGACY_ABATEMENT: 'legacy-abatement',
@@ -74,17 +72,6 @@ const PALLIATIVE_EXT = {
   FINDING_CLUSTER_NOTE: 'palliative-finding-cluster-note',
 };
 
-const CONTINGENCY_EXT = {
-  STATUS: 'contingency-status',
-  AWAITING_CHARACTERIZATION: 'contingency-awaiting-characterization',
-  WHY_THIS_MATTERS: 'contingency-why-this-matters',
-  CREATION_REASONING: 'contingency-creation-reasoning',
-  RESOLVED_REASON: 'contingency-resolved-reason',
-  STEP_PRIORITY: 'contingency-step-priority',
-  ACTION_REQUESTED: 'contingency-action-requested',
-  FIRES_AFTER_SILENCE_MINUTES: 'fires-after-silence-minutes',
-};
-
 const RISK_EXT = {
   PREDICTION_KIND: 'risk-prediction-kind',
   MINIMUM_SYMPTOM_SET: 'risk-minimum-symptom-set',
@@ -105,7 +92,5 @@ module.exports = {
   ROUTING_EXT,
   CLUSTER_EXT,
   PALLIATIVE_EXT,
-  CONTINGENCY_EXT,
-  CONTINGENCY_CATEGORY_PREFIX,
   RISK_EXT,
 };

package/lib/fhir/helpers/resourceHelper.js

@@ -0,0 +1,28 @@
+const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
+const { fhirId } = require('./fhirHelper');
+const { identifier, patientReference, reference, codeableConcept, toIso } = require('./elementHelper');
+
+function baseResource(resourceType, id, slug, patientId) {
+  return {
+    resourceType,
+    id: fhirId(id),
+    identifier: [identifier(slug, id)],
+    subject: patientReference(patientId),
+  };
+}
+
+function provenance({ provenanceId, targetRefs, recordedAt, activityText }) {
+  return {
+    resourceType: 'Provenance',
+    id: fhirId(provenanceId),
+    target: targetRefs,
+    recorded: toIso(recordedAt),
+    agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
+    activity: codeableConcept(activityText),
+  };
+}
+
+module.exports = {
+  baseResource,
+  provenance,
+};

package/lib/fhir/projections/contingencyProjection.js

@@ -1,36 +1,193 @@
-const { CarePlan } = require('../resources/CarePlan');
-const { CommunicationRequest } = require('../resources/CommunicationRequest');
-const { Provenance } = require('../resources/Provenance');
+const { ZodError } = require('zod');
+
+const { getOrganizationId } = require('../config/fhirConfig');
+const { fhirId } = require('../helpers/fhirHelper');
+const { patientReference, reference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
+const { baseResource, provenance } = require('../helpers/resourceHelper');
+const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
+const { CONTINGENCY_PLAN_SLUG, CONTINGENCY_STEP_SLUG } = require('../constants/projectionSlugs');
+const { ContingencySafetyNet } = require('../../shared/dtos/ContingencySafetyNet');
+const { logger } = require('../../utils/logger');
 
-const PROJECTOR_NAME = 'contingency';
 const ACTIVITY_TEXT = 'contingency-safety-net';
+const CATEGORY_PREFIX = 'contingency-';
 
-function projectContingency(net) {
-  const { carePlan, teamEscalation, patientReminder } = net;
-  const stepArgs = {
-    planId: carePlan.planId,
-    patientId: carePlan.patientId,
-    createdAt: carePlan.createdAt,
-    parentStatus: carePlan.status,
-  };
+const EXT = {
+  STATUS: 'contingency-status',
+  AWAITING_CHARACTERIZATION: 'contingency-awaiting-characterization',
+  WHY_THIS_MATTERS: 'contingency-why-this-matters',
+  CREATION_REASONING: 'contingency-creation-reasoning',
+  RESOLVED_REASON: 'contingency-resolved-reason',
+  STEP_PRIORITY: 'contingency-step-priority',
+  ACTION_REQUESTED: 'contingency-action-requested',
+  FIRES_AFTER_SILENCE_MINUTES: 'fires-after-silence-minutes',
+};
+
+const STATUS_TO_FHIR = {
+  armed: 'active',
+  fired_reminder: 'active',
+  fired_team: 'active',
+  auto_resolved: 'completed',
+  cancelled: 'revoked',
+};
 
+const PRIORITY_CROSSWALK = {
+  critical: 'stat',
+  high: 'urgent',
+  medium: 'routine',
+  low: 'routine',
+  routine: 'routine',
+  urgent: 'urgent',
+  asap: 'asap',
+  stat: 'stat',
+};
+
+const RESOURCE_TYPES = ['CarePlan', 'CommunicationRequest'];
+
+function toFhir(contingency) {
+  const { carePlan, teamEscalation, patientReminder } = contingency;
   const steps = [teamEscalation];
   if (patientReminder) steps.push(patientReminder);
 
-  const out = [CarePlan.fromContingency({ carePlan })];
+  const resources = [carePlanResource(carePlan)];
+  for (const step of steps) resources.push(stepResource(step, carePlan));
+
+  const targetRefs = [{ reference: `CarePlan/${fhirId(carePlan.planId)}` }];
   for (const step of steps) {
-    out.push(CommunicationRequest.fromContingencyStep({ step, ...stepArgs }));
+    targetRefs.push({ reference: `CommunicationRequest/${fhirId(`${carePlan.planId}-${step.recipient}`)}` });
   }
-  out.push(Provenance.fromContingency({
-    planId: carePlan.planId,
-    recipients: steps.map((step) => step.recipient),
+  resources.push(provenance({
+    provenanceId: `${carePlan.planId}-prov`,
+    targetRefs,
     recordedAt: carePlan.createdAt,
     activityText: ACTIVITY_TEXT,
   }));
+  return resources;
+}
+
+function carePlanResource(carePlan) {
+  const payload = {
+    ...baseResource('CarePlan', carePlan.planId, CONTINGENCY_PLAN_SLUG, carePlan.patientId),
+    status: STATUS_TO_FHIR[carePlan.status],
+    intent: 'plan',
+    created: toIso(carePlan.createdAt),
+    period: carePlanPeriod(carePlan),
+  };
+  if (carePlan.concern) payload.description = carePlan.concern;
+  if (carePlan.relatedCaseId) payload.addresses = [{ reference: reference('Condition', carePlan.relatedCaseId) }];
+  if (carePlan.relatedClusterId) payload.supportingInfo = [reference('ClinicalImpression', carePlan.relatedClusterId)];
+  const ext = carePlanExtensions(carePlan);
+  if (ext.length) payload.extension = ext;
+  return payload;
+}
+
+function carePlanPeriod(carePlan) {
+  const period = { start: toIso(carePlan.createdAt) };
+  if (carePlan.resolvedAt) period.end = toIso(carePlan.resolvedAt);
+  return period;
+}
+
+function carePlanExtensions(carePlan) {
+  const out = [extension(EXT.STATUS, { valueString: carePlan.status })];
+  if (carePlan.awaitingCharacterization) out.push(extension(EXT.AWAITING_CHARACTERIZATION, { valueString: carePlan.awaitingCharacterization }));
+  if (carePlan.whyThisMatters) out.push(extension(EXT.WHY_THIS_MATTERS, { valueString: carePlan.whyThisMatters }));
+  if (carePlan.creationReasoning) out.push(extension(EXT.CREATION_REASONING, { valueString: carePlan.creationReasoning }));
+  if (carePlan.resolvedReason) out.push(extension(EXT.RESOLVED_REASON, { valueString: carePlan.resolvedReason }));
   return out;
 }
 
+function stepResource(step, carePlan) {
+  const stepId = `${carePlan.planId}-${step.recipient}`;
+  const payload = {
+    ...baseResource('CommunicationRequest', stepId, CONTINGENCY_STEP_SLUG, carePlan.patientId),
+    status: STATUS_TO_FHIR[carePlan.status],
+    intent: 'plan',
+    category: [codeableConcept(`${CATEGORY_PREFIX}${step.recipient}`)],
+    recipient: [step.recipient === 'patient'
+      ? patientReference(carePlan.patientId)
+      : { reference: `Organization/${fhirId(getOrganizationId())}` }],
+    payload: [{ contentCodeableConcept: codeableConcept(step.message) }],
+    authoredOn: toIso(carePlan.createdAt),
+    basedOn: [{ reference: `CarePlan/${fhirId(carePlan.planId)}` }],
+  };
+  const priority = step.priority ? PRIORITY_CROSSWALK[step.priority] || 'routine' : null;
+  if (priority) payload.priority = priority;
+  const ext = stepExtensions(step);
+  if (ext.length) payload.extension = ext;
+  return payload;
+}
+
+function stepExtensions(step) {
+  const out = [];
+  if (step.priority) out.push(extension(EXT.STEP_PRIORITY, { valueString: step.priority }));
+  if (step.actionRequested) out.push(extension(EXT.ACTION_REQUESTED, { valueString: step.actionRequested }));
+  if (step.firesAfterSilenceMinutes !== null && step.firesAfterSilenceMinutes !== undefined) {
+    out.push(extension(EXT.FIRES_AFTER_SILENCE_MINUTES, { valueInteger: step.firesAfterSilenceMinutes }));
+  }
+  return out;
+}
+
+function fromFhir(resources, { patientId }) {
+  const requests = resources.filter((r) => r.resourceType === 'CommunicationRequest' && identifierValue(r, CONTINGENCY_STEP_SLUG));
+  return resources
+    .filter((r) => r.resourceType === 'CarePlan' && identifierValue(r, CONTINGENCY_PLAN_SLUG))
+    .map((plan) => reconstruct(plan, requests, patientId))
+    .filter(Boolean);
+}
+
+function reconstruct(plan, requests, patientId) {
+  const planId = identifierValue(plan, CONTINGENCY_PLAN_SLUG);
+  const ext = extMap(plan);
+  const stepFor = (recipient) => {
+    const resource = requests.find((r) => identifierValue(r, CONTINGENCY_STEP_SLUG) === `${planId}-${recipient}`);
+    return resource ? reconstructStep(resource, recipient) : null;
+  };
+  const address = plan.addresses && plan.addresses[0] && plan.addresses[0].reference;
+  const reconstructed = {
+    schemaVersion: '1',
+    carePlan: {
+      planId,
+      patientId,
+      relatedCaseId: refToId(address && address.reference),
+      relatedClusterId: refToId(plan.supportingInfo && plan.supportingInfo[0] && plan.supportingInfo[0].reference),
+      concern: plan.description || '',
+      awaitingCharacterization: ext[EXT.AWAITING_CHARACTERIZATION] || '',
+      whyThisMatters: ext[EXT.WHY_THIS_MATTERS] || '',
+      creationReasoning: ext[EXT.CREATION_REASONING] || '',
+      status: ext[EXT.STATUS] || 'armed',
+      createdAt: plan.created,
+      resolvedAt: (plan.period && plan.period.end) || null,
+      resolvedReason: ext[EXT.RESOLVED_REASON] || null,
+    },
+    teamEscalation: stepFor('care_team'),
+    patientReminder: stepFor('patient'),
+  };
+  try {
+    return new ContingencySafetyNet(reconstructed);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      logger.warn({ planId }, 'skipping malformed contingency CarePlan');
+      return null;
+    }
+    throw error;
+  }
+}
+
+function reconstructStep(resource, recipient) {
+  const ext = extMap(resource);
+  const silence = ext[EXT.FIRES_AFTER_SILENCE_MINUTES];
+  const firstPayload = resource.payload && resource.payload[0];
+  return {
+    recipient,
+    message: (firstPayload && firstPayload.contentCodeableConcept && firstPayload.contentCodeableConcept.text) || null,
+    priority: ext[EXT.STEP_PRIORITY] || resource.priority || null,
+    actionRequested: ext[EXT.ACTION_REQUESTED] || null,
+    firesAfterSilenceMinutes: typeof silence === 'number' ? silence : null,
+  };
+}
+
 module.exports = {
-  projectContingency,
-  PROJECTOR_NAME,
+  toFhir,
+  fromFhir,
+  RESOURCE_TYPES,
 };

package/lib/fhir/projections/registerProjectors.js

@@ -6,7 +6,6 @@ const { projectSymptomCase, PROJECTOR_NAME: SYMPTOM_CASE_PROJECTOR_NAME } = requ
 const { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./riskProjection');
 const { projectSafetyGate, PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('./safetyGateProjection');
 const { projectRecommendationPlan, PROJECTOR_NAME: RECOMMENDATION_PLAN_PROJECTOR_NAME } = require('./recommendationPlanProjection');
-const { projectContingency, PROJECTOR_NAME: CONTINGENCY_PROJECTOR_NAME } = require('./contingencyProjection');
 const { projectIntervention, PROJECTOR_NAME: INTERVENTION_PROJECTOR_NAME } = require('./interventionProjection');
 const { projectCluster, PROJECTOR_NAME: CLUSTER_PROJECTOR_NAME } = require('./clusterProjection');
 const { projectRoutingDecision, PROJECTOR_NAME: ROUTING_PROJECTOR_NAME } = require('./routingProjection');
@@ -21,7 +20,6 @@ const PROJECTORS = [
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },
   { name: SAFETY_GATE_PROJECTOR_NAME, project: projectSafetyGate },
   { name: RECOMMENDATION_PLAN_PROJECTOR_NAME, project: projectRecommendationPlan },
-  { name: CONTINGENCY_PROJECTOR_NAME, project: projectContingency },
   { name: INTERVENTION_PROJECTOR_NAME, project: projectIntervention },
   { name: CLUSTER_PROJECTOR_NAME, project: projectCluster },
   { name: ROUTING_PROJECTOR_NAME, project: projectRoutingDecision },

package/lib/fhir/resources/CarePlan.js

@@ -7,45 +7,14 @@ const {
   extension,
   toIso,
 } = require('../helpers/elementHelper');
-const { CONTINGENCY_PLAN_SLUG, ROUTING_DISPOSITION_SLUG, RECOMMENDATION_PLAN_SLUG, PALLIATIVE_CAREPLAN_SLUG } = require('../constants/projectionSlugs');
-const { CONTINGENCY_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
-
-const CONTINGENCY_STATUS_TO_FHIR = {
-  armed: 'active',
-  fired_reminder: 'active',
-  fired_team: 'active',
-  auto_resolved: 'completed',
-  cancelled: 'revoked',
-};
+const { ROUTING_DISPOSITION_SLUG, RECOMMENDATION_PLAN_SLUG, PALLIATIVE_CAREPLAN_SLUG } = require('../constants/projectionSlugs');
+const { PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 class CarePlan {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromContingency({ carePlan }) {
-    const payload = {
-      resourceType: 'CarePlan',
-      id: fhirId(carePlan.planId),
-      identifier: [identifier(CONTINGENCY_PLAN_SLUG, carePlan.planId)],
-      status: CONTINGENCY_STATUS_TO_FHIR[carePlan.status],
-      intent: 'plan',
-      subject: patientReference(carePlan.patientId),
-      created: toIso(carePlan.createdAt),
-      period: contingencyPeriod(carePlan),
-    };
-    if (carePlan.concern) payload.description = carePlan.concern;
-    if (carePlan.relatedCaseId) {
-      payload.addresses = [{ reference: reference('Condition', carePlan.relatedCaseId) }];
-    }
-    if (carePlan.relatedClusterId) {
-      payload.supportingInfo = [reference('ClinicalImpression', carePlan.relatedClusterId)];
-    }
-    const ext = contingencyExtensions(carePlan);
-    if (ext.length) payload.extension = ext;
-    return new CarePlan(payload);
-  }
-
   static fromRecommendationPlan({ plan, taskIds, hasSafetyGate }) {
     const payload = {
       resourceType: 'CarePlan',
@@ -110,30 +79,6 @@ class CarePlan {
   }
 }
 
-function contingencyPeriod(carePlan) {
-  const period = { start: toIso(carePlan.createdAt) };
-  if (carePlan.resolvedAt) period.end = toIso(carePlan.resolvedAt);
-  return period;
-}
-
-function contingencyExtensions(carePlan) {
-  const out = [extension(CONTINGENCY_EXT.STATUS, { valueString: carePlan.status })];
-  if (carePlan.awaitingCharacterization) {
-    out.push(extension(CONTINGENCY_EXT.AWAITING_CHARACTERIZATION, { valueString: carePlan.awaitingCharacterization }));
-  }
-  if (carePlan.whyThisMatters) {
-    out.push(extension(CONTINGENCY_EXT.WHY_THIS_MATTERS, { valueString: carePlan.whyThisMatters }));
-  }
-  if (carePlan.creationReasoning) {
-    out.push(extension(CONTINGENCY_EXT.CREATION_REASONING, { valueString: carePlan.creationReasoning }));
-  }
-  if (carePlan.resolvedReason) {
-    out.push(extension(CONTINGENCY_EXT.RESOLVED_REASON, { valueString: carePlan.resolvedReason }));
-  }
-  return out;
-}
-
 module.exports = {
   CarePlan,
-  CONTINGENCY_STATUS_TO_FHIR,
 };

package/lib/fhir/resources/CommunicationRequest.js

@@ -1,4 +1,3 @@
-const { getOrganizationId } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const {
   identifier,
@@ -16,25 +15,11 @@ const {
   REMINDER_SLUG,
   REMINDER_KIND_SLUG,
   COMMUNICATION_CHANNEL_SLUG,
-  CONTINGENCY_STEP_SLUG,
   INTERVENTION_SLUG,
   INTERVENTION_KIND_SLUG,
   ROUTING_DISPOSITION_SLUG,
 } = require('../constants/projectionSlugs');
-const { CONTINGENCY_EXT, CONTINGENCY_CATEGORY_PREFIX } = require('../constants/extensionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
-const { CONTINGENCY_STATUS_TO_FHIR } = require('./CarePlan');
-
-const CONTINGENCY_PRIORITY_CROSSWALK = {
-  critical: 'stat',
-  high: 'urgent',
-  medium: 'routine',
-  low: 'routine',
-  routine: 'routine',
-  urgent: 'urgent',
-  asap: 'asap',
-  stat: 'stat',
-};
 const { interventionExtensions } = require('./interventionExtensions');
 
 const NOTIFY_STATUS_TO_CR_STATUS = {
@@ -106,35 +91,6 @@ class CommunicationRequest {
     return new CommunicationRequest(payload);
   }
 
-  static fromContingencyStep({ step, planId, patientId, createdAt, parentStatus }) {
-    const stepId = `${planId}-${step.recipient}`;
-    const payload = {
-      resourceType: 'CommunicationRequest',
-      id: fhirId(stepId),
-      identifier: [identifier(CONTINGENCY_STEP_SLUG, stepId)],
-      status: CONTINGENCY_STATUS_TO_FHIR[parentStatus],
-      intent: 'plan',
-      category: [codeableConcept(`${CONTINGENCY_CATEGORY_PREFIX}${step.recipient}`)],
-      subject: patientReference(patientId),
-      recipient: [step.recipient === 'patient'
-        ? patientReference(patientId)
-        : { reference: `Organization/${fhirId(getOrganizationId())}` }],
-      payload: [{ contentCodeableConcept: codeableConcept(step.message) }],
-      authoredOn: toIso(createdAt),
-      basedOn: [{ reference: `CarePlan/${fhirId(planId)}` }],
-    };
-    const priority = step.priority ? CONTINGENCY_PRIORITY_CROSSWALK[step.priority] || 'routine' : null;
-    if (priority) payload.priority = priority;
-    const ext = [];
-    if (step.priority) ext.push(extension(CONTINGENCY_EXT.STEP_PRIORITY, { valueString: step.priority }));
-    if (step.actionRequested) ext.push(extension(CONTINGENCY_EXT.ACTION_REQUESTED, { valueString: step.actionRequested }));
-    if (step.firesAfterSilenceMinutes !== null && step.firesAfterSilenceMinutes !== undefined) {
-      ext.push(extension(CONTINGENCY_EXT.FIRES_AFTER_SILENCE_MINUTES, { valueInteger: step.firesAfterSilenceMinutes }));
-    }
-    if (ext.length) payload.extension = ext;
-    return new CommunicationRequest(payload);
-  }
-
   static fromIntervention({ intervention }) {
     const payload = {
       resourceType: 'CommunicationRequest',

package/lib/fhir/resources/Provenance.js

@@ -109,21 +109,6 @@ class Provenance {
     });
   }
 
-  static fromContingency({ planId, recipients, recordedAt, activityText }) {
-    const targets = [{ reference: `CarePlan/${fhirId(planId)}` }];
-    for (const recipient of recipients) {
-      targets.push({ reference: `CommunicationRequest/${fhirId(`${planId}-${recipient}`)}` });
-    }
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(`${planId}-prov`),
-      target: targets,
-      recorded: toIso(recordedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-    });
-  }
-
   static fromResultObservations({ targetIds, provenanceId, activityText, now }) {
     return new Provenance({
       resourceType: 'Provenance',

package/lib/fhir/services/contingencyService.js

@@ -1,117 +1,23 @@
-const { ZodError } = require('zod');
-
 const { fhirId } = require('../helpers/fhirHelper');
-const { extMap, identifierValue, refToId } = require('../helpers/fhirReadHelper');
-const {
-  CONTINGENCY_PLAN_SLUG,
-  CONTINGENCY_STEP_SLUG,
-} = require('../constants/projectionSlugs');
-const { CONTINGENCY_EXT, CONTINGENCY_CATEGORY_PREFIX } = require('../constants/extensionSlugs');
-const { CONTINGENCY_STATUS_TO_FHIR } = require('../resources/CarePlan');
-const { PROJECTOR_NAME } = require('../projections/contingencyProjection');
 const { getFhirStore } = require('../stores/fhirStore');
-const { ContingencySafetyNet, RECIPIENTS } = require('../../shared/dtos/ContingencySafetyNet');
-const { logger } = require('../../utils/logger');
-const { project, storeResources } = require('./fhirService');
-
-const FHIR_TO_CONTINGENCY_STATUS = invert(CONTINGENCY_STATUS_TO_FHIR);
+const { toFhir, fromFhir, RESOURCE_TYPES } = require('../projections/contingencyProjection');
+const { storeResources } = require('./fhirService');
 
 async function storeContingency({ patientId, contingency }) {
   if (contingency.carePlan.patientId !== patientId) {
     throw new Error(`storeContingency patientId mismatch: expected ${patientId}`);
   }
-  const bundle = project([{ name: PROJECTOR_NAME, aggregate: contingency }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
+  const { stored } = await storeResources(toFhir(contingency));
   return { count: stored.length, ids: stored };
 }
 
 async function readContingencies({ patientId, caseId = null, clusterId = null }) {
   const store = getFhirStore();
   const patient = `Patient/${fhirId(patientId)}`;
-  const plans = (await store.find({ patient, resourceType: 'CarePlan' }))
-    .filter((plan) => identifierValue(plan, CONTINGENCY_PLAN_SLUG));
-  const requests = (await store.find({ patient, resourceType: 'CommunicationRequest' }))
-    .filter((request) => identifierValue(request, CONTINGENCY_STEP_SLUG));
-
-  const nets = [];
-  for (const plan of plans) {
-    const net = reconstructContingency(plan, requests, patientId);
-    if (caseId && net.carePlan.relatedCaseId !== caseId) continue;
-    if (clusterId && net.carePlan.relatedClusterId !== clusterId) continue;
-    try {
-      nets.push(new ContingencySafetyNet(net));
-    } catch (error) {
-      if (error instanceof ZodError) {
-        logger.warn({ planId: net.carePlan.planId }, 'skipping malformed contingency CarePlan');
-        continue;
-      }
-      throw error;
-    }
-  }
-  return nets;
-}
-
-function reconstructContingency(plan, requests, patientId) {
-  const planId = identifierValue(plan, CONTINGENCY_PLAN_SLUG);
-  const ext = extMap(plan);
-  const stepIds = new Set([`${planId}-care_team`, `${planId}-patient`]);
-  const planSteps = requests
-    .filter((resource) => stepIds.has(identifierValue(resource, CONTINGENCY_STEP_SLUG)))
-    .map(reconstructStep);
-  const teamEscalation = planSteps.find((step) => step.recipient === 'care_team') || null;
-  const patientReminder = planSteps.find((step) => step.recipient === 'patient') || null;
-  const address = plan.addresses && plan.addresses[0] && plan.addresses[0].reference;
-  return {
-    schemaVersion: '1',
-    carePlan: {
-      planId,
-      patientId,
-      relatedCaseId: refToId(address && address.reference),
-      relatedClusterId: refToId(plan.supportingInfo && plan.supportingInfo[0] && plan.supportingInfo[0].reference),
-      concern: plan.description || '',
-      awaitingCharacterization: ext[CONTINGENCY_EXT.AWAITING_CHARACTERIZATION] || '',
-      whyThisMatters: ext[CONTINGENCY_EXT.WHY_THIS_MATTERS] || '',
-      creationReasoning: ext[CONTINGENCY_EXT.CREATION_REASONING] || '',
-      status: ext[CONTINGENCY_EXT.STATUS] || FHIR_TO_CONTINGENCY_STATUS[plan.status] || 'armed',
-      createdAt: plan.created,
-      resolvedAt: (plan.period && plan.period.end) || null,
-      resolvedReason: ext[CONTINGENCY_EXT.RESOLVED_REASON] || null,
-    },
-    teamEscalation,
-    patientReminder,
-  };
-}
-
-function reconstructStep(resource) {
-  const ext = extMap(resource);
-  const silence = ext[CONTINGENCY_EXT.FIRES_AFTER_SILENCE_MINUTES];
-  const firstPayload = resource.payload && resource.payload[0];
-  return {
-    recipient: recipientOf(resource),
-    message: (firstPayload && firstPayload.contentCodeableConcept && firstPayload.contentCodeableConcept.text) || null,
-    priority: ext[CONTINGENCY_EXT.STEP_PRIORITY] || resource.priority || null,
-    actionRequested: ext[CONTINGENCY_EXT.ACTION_REQUESTED] || null,
-    firesAfterSilenceMinutes: typeof silence === 'number' ? silence : null,
-  };
-}
-
-function recipientOf(resource) {
-  const category = resource.category && resource.category[0] && resource.category[0].text;
-  if (category && category.startsWith(CONTINGENCY_CATEGORY_PREFIX)) {
-    const recipient = category.slice(CONTINGENCY_CATEGORY_PREFIX.length);
-    if (RECIPIENTS.includes(recipient)) return recipient;
-  }
-  const ref = resource.recipient && resource.recipient[0] && resource.recipient[0].reference;
-  return ref && ref.startsWith('Organization/') ? 'care_team' : 'patient';
-}
-
-function invert(map) {
-  const out = {};
-  for (const [key, value] of Object.entries(map)) {
-    if (!(value in out)) out[value] = key;
-  }
-  return out;
+  const found = await Promise.all(RESOURCE_TYPES.map((resourceType) => store.find({ patient, resourceType })));
+  return fromFhir(found.flat(), { patientId })
+    .filter((contingency) => !caseId || contingency.carePlan.relatedCaseId === caseId)
+    .filter((contingency) => !clusterId || contingency.carePlan.relatedClusterId === clusterId);
 }
 
 module.exports = {

package/lib/shared/dtos/ContingencySafetyNet.js

@@ -52,5 +52,4 @@ module.exports = {
   ContingencySafetyNet,
   ESCALATION_PRIORITIES,
   ACTIVE_CARE_PLAN_STATUSES,
-  RECIPIENTS,
 };

package/package.json

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