@peopl-health/nexus 5.11.0-dev.1120 → 5.11.0-dev.1123

package/lib/clinical/tools/analyzeSymptomPatternsTool.js

@@ -1,4 +1,5 @@
 const { readSymptomCases, readPatientRisk } = require('../../fhir');
+const { OPEN_STATUSES, CLOSED_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
 const _CHECKPOINT_KEYWORDS = [
   'pembrolizumab', 'nivolumab', 'atezolizumab', 'durvalumab',
@@ -101,10 +102,6 @@ const _PATTERN_CATALOG = [
 
 const _SCOPES = ['all_active_cases', 'specific_cases', 'include_recent_resolved'];
 
-const _OPEN_STATUSES = ['characterizing', 'monitoring'];
-
-const _TERMINAL_STATUSES = ['closed', 'resolved', 'inactive'];
-
 const definition = {
   name: 'analyzeSymptomPatterns',
   description: '**Does:** VALIDATES a clinical pattern you propose against the patient\'s active symptom landscape + treatment context. You pick a `specific_pattern_to_validate` (one of 6 frozen catalog patterns) from your reasoning over the symptoms + regimen + grades; the tool deterministically confirms whether the data matches. Read-only — never writes.\n\n**Required inputs:** `specific_pattern_to_validate` — one of `pattern-pneumonitis`, `pattern-cinv`, `pattern-febrile-syndrome`, `pattern-neuro-constellation`, `pattern-cord-compression`, `pattern-pain-insomnia-fatigue`. Optional `scope` (`all_active_cases` default | `specific_cases` | `include_recent_resolved`); `specific_case_ids` (required only for `scope=specific_cases`).\n\n**Returns:** `pattern_validated` (bool). When validated: `match` (pattern_id, type, hypothesis_label_suggestion, treatment_context, member_case_ids_matching, key_symptoms_present/missing, disconfirming_symptoms, match_strength, confidence). When not: `pattern_id`, `reason`, `key_symptoms_present[]`, `key_symptoms_missing[]`. Requires ≥2 key-symptom overlaps and a compatible treatment context.',
@@ -194,10 +191,10 @@ async function gatherCases({ patientId, scope, specificCaseIds }) {
     return cases.filter((symptomCase) => ids.has(symptomCase.condition.conditionId));
   }
   const cases = await readSymptomCases({ patientId });
-  const open = cases.filter((symptomCase) => _OPEN_STATUSES.includes(symptomCase.condition.clinicalStatus));
+  const open = cases.filter((symptomCase) => OPEN_STATUSES.includes(symptomCase.condition.clinicalStatus));
   if (scope !== 'include_recent_resolved') return open;
   const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
-  const recentTerminal = cases.filter((symptomCase) => _TERMINAL_STATUSES.includes(symptomCase.condition.clinicalStatus)
+  const recentTerminal = cases.filter((symptomCase) => CLOSED_STATUSES.includes(symptomCase.condition.clinicalStatus)
     && symptomCase.condition.abatementAt && new Date(symptomCase.condition.abatementAt).getTime() >= cutoff);
   return [...open, ...recentTerminal];
 }

package/lib/clinical/tools/getActiveSymptomLandscapeTool.js

@@ -1,4 +1,5 @@
 const { readSymptomCases, readClusters } = require('../../fhir');
+const { OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
 const definition = {
   name: 'getActiveSymptomLandscape',
@@ -18,7 +19,6 @@ const definition = {
 };
 
 const PRIORITY_LEVEL = { low: 0, medium: 1, high: 2 };
-const OPEN_STATUSES = ['characterizing', 'monitoring'];
 
 function priorityAndFlags(managedSymptom, clusterMemberships) {
   const flags = [];
@@ -69,7 +69,7 @@ function openedEpoch(openedAt) {
 async function assembleLandscape(patientId, minimumPriorityArg) {
   const minimumPriority = (typeof minimumPriorityArg === 'string' ? minimumPriorityArg : 'low').toLowerCase();
   if (!(minimumPriority in PRIORITY_LEVEL)) {
-    throw new Error(`unknown minimum_priority: '${minimumPriority}'. Must be low | medium | high.`);
+    throw new Error(`unknown minimum_priority: '${minimumPriority}'. Must be ${Object.keys(PRIORITY_LEVEL).join(' | ')}.`);
   }
   const minLevel = PRIORITY_LEVEL[minimumPriority];
 

package/lib/clinical/tools/getPatientHistoryTool.js

@@ -2,6 +2,7 @@ const { readSymptomCases, readInterventions, patientSnapshot } = require('../../
 const { fhirId } = require('../../fhir/helpers/fhirHelper');
 const { identifierValue } = require('../../fhir/helpers/fhirReadHelper');
 const { INTERVENTION_SLUG } = require('../../fhir/constants/projectionSlugs');
+const { CLOSED_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
 const SUPPORTED_SCOPES = new Set([
   'closed_cases_30d',
@@ -16,7 +17,6 @@ const SUPPORTED_SCOPES = new Set([
 
 const DEFAULT_SCOPE = ['closed_cases_30d', 'recurrence_patterns'];
 const TIMEFRAME_DAYS = { last_7_days: 7, last_30_days: 30, last_90_days: 90 };
-const CLOSED_STATUSES = ['resolved', 'inactive', 'closed'];
 const POSITION_E_DEFAULT_WINDOW_DAYS = 30;
 const POSITION_E_SCOPES = ['recent_medications', 'appointment_mentions', 'patient_reported_procedures'];
 

package/lib/clinical/tools/openClusterHypothesisTool.js

@@ -2,14 +2,10 @@ const crypto = require('node:crypto');
 
 const { patternConsultStore } = require('../models/patternConsultModel');
 const { readSymptomCases, readClusters, storeCluster } = require('../../fhir');
-const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
+const { ClusterImpression, HYPOTHESIS_TYPES, CONFIDENCE_LEVELS, CLINICAL_SIGNIFICANCE } = require('../../shared/dtos/ClusterImpression');
 const { ClusterHistoryRecord } = require('../../shared/dtos/ClusterHistoryRecord');
 const { patternConsultLive } = require('../flags/patternConsultFlags');
-
-const HYPOTHESIS_TYPES = ['ae_profile', 'symptom_syndrome', 'disease_complication', 'relational_causal'];
-const CONFIDENCE_LEVELS = ['speculative', 'moderate', 'strong'];
-const CLINICAL_SIGNIFICANCE = ['benign', 'moderate', 'safety_relevant', 'emergency'];
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
+const { OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
 const definition = {
   name: 'openClusterHypothesis',
@@ -134,7 +130,7 @@ async function handler(args = {}, context = {}) {
     for (const caseId of memberCaseIds) {
       const managedSymptom = cases.find((c) => c.condition.conditionId === caseId);
       if (!managedSymptom) return fail('member_case_not_found_or_wrong_patient', { member_case_id: caseId });
-      if (!OPEN_CASE_STATUSES.includes(managedSymptom.condition.clinicalStatus)) return fail('member_case_not_open', { case_id: caseId, status: managedSymptom.condition.clinicalStatus });
+      if (!OPEN_STATUSES.includes(managedSymptom.condition.clinicalStatus)) return fail('member_case_not_open', { case_id: caseId, status: managedSymptom.condition.clinicalStatus });
     }
 
     const now = new Date().toISOString();

package/lib/clinical/tools/openConditionTool.js

@@ -1,7 +1,7 @@
 const crypto = require('node:crypto');
 
 const { readSymptomCases, storeSymptomCase } = require('../../fhir');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
+const { ManagedSymptom, OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 const { GRADE_MIN, GRADE_MAX, parseGradeEstimate } = require('../helpers/gradeEstimateHelper');
 
 const definition = {
@@ -62,7 +62,7 @@ async function handler(args = {}, context = {}) {
 
     const patientId = runtime.patientCode;
     const casesForTerm = await readSymptomCases({ patientId, ctcaeTerm });
-    const openCase = casesForTerm.find((symptomCase) => ['characterizing', 'monitoring'].includes(symptomCase.condition.clinicalStatus));
+    const openCase = casesForTerm.find((symptomCase) => OPEN_STATUSES.includes(symptomCase.condition.clinicalStatus));
     if (openCase) {
       return JSON.stringify({
         success: false,

package/lib/clinical/tools/recordClinicalImpressionTool.js

@@ -1,7 +1,7 @@
 const crypto = require('node:crypto');
 
 const { readSymptomCases, storeSymptomCase } = require('../../fhir');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
+const { ManagedSymptom, OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 const { GRADE_MIN, GRADE_MAX, parseGradeEstimate } = require('../helpers/gradeEstimateHelper');
 
 const definition = {
@@ -62,7 +62,6 @@ const definition = {
 const EVENTS = definition.parameters.properties.event.enum;
 const TRAJECTORIES = definition.parameters.properties.trajectory_direction.enum;
 const POSTURES = definition.parameters.properties.decision_posture.enum;
-const OPEN_STATUSES = ['characterizing', 'monitoring'];
 
 const uid = (prefix) => `${prefix}_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
 

package/lib/clinical/tools/recordInterventionTool.js

@@ -1,11 +1,9 @@
 const crypto = require('node:crypto');
 
 const { readSymptomCases, readInterventions, storeIntervention } = require('../../fhir');
-const { Intervention } = require('../../shared/dtos/Intervention');
+const { Intervention, KINDS, OUTCOMES } = require('../../shared/dtos/Intervention');
+const { OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
-const KINDS = ['otc', 'self_care', 'other', 'education', 'team_escalation', 'follow_up_check'];
-const OUTCOMES = ['pending', 'improved', 'no_relief', 'side_effects', 'worsened', 'unknown'];
 const ACTIONS = ['create', 'record_outcome'];
 
 const definition = {
@@ -88,7 +86,7 @@ async function create(patientId, args) {
 
   const targetCase = (await readSymptomCases({ patientId })).find((c) => c.condition.conditionId === caseId);
   if (!targetCase) return fail('case_not_found_or_wrong_patient', { case_id: caseId });
-  if (!OPEN_CASE_STATUSES.includes(targetCase.condition.clinicalStatus)) {
+  if (!OPEN_STATUSES.includes(targetCase.condition.clinicalStatus)) {
     return fail('case_is_dormant — interventions attach to open cases; if the symptom recurred, reactivate the case via recordClinicalImpression first.', { case_id: caseId, status: targetCase.condition.clinicalStatus });
   }
 

package/lib/clinical/tools/setContingencyPlanTool.js

@@ -1,13 +1,9 @@
 const crypto = require('node:crypto');
 
 const { readSymptomCases, readClusters, readContingencies, storeContingency } = require('../../fhir');
-const {
-  ContingencySafetyNet,
-  ESCALATION_PRIORITIES,
-  ACTIVE_CARE_PLAN_STATUSES,
-} = require('../../shared/dtos/ContingencySafetyNet');
+const { ContingencySafetyNet, ESCALATION_PRIORITIES, ACTIVE_CARE_PLAN_STATUSES } = require('../../shared/dtos/ContingencySafetyNet');
+const { OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
 const STEP_SHAPE = '{recipient, message, priority, action_requested, fires_after_silence_minutes}';
 
 const definition = {
@@ -124,7 +120,7 @@ async function handler(args = {}, context = {}) {
     if (relatedCaseId) {
       const targetCase = (await readSymptomCases({ patientId })).find((c) => c.condition.conditionId === relatedCaseId);
       if (!targetCase) return fail('case_not_found_or_wrong_patient', { related_case_id: relatedCaseId });
-      if (!OPEN_CASE_STATUSES.includes(targetCase.condition.clinicalStatus)) {
+      if (!OPEN_STATUSES.includes(targetCase.condition.clinicalStatus)) {
         return fail('target_not_open — contingency plans require an active case', { related_case_id: relatedCaseId, current_status: targetCase.condition.clinicalStatus });
       }
     }

package/lib/clinical/tools/submitSafetyGateTool.js

@@ -1,11 +1,7 @@
 const { ZodError } = require('zod');
 
 const { storeSafetyGate, safetyGateExists } = require('../../fhir');
-const {
-  RecommendationSafetyGate,
-  ESCALATION_ROUTES,
-  RED_FLAG_STATUSES,
-} = require('../../shared/dtos/RecommendationSafetyGate');
+const { RecommendationSafetyGate, ESCALATION_ROUTES, RED_FLAG_STATUSES } = require('../../shared/dtos/RecommendationSafetyGate');
 const { logger } = require('../../utils/logger');
 
 const definition = {

package/lib/clinical/tools/updateClusterHypothesisTool.js

@@ -1,11 +1,8 @@
 const { readSymptomCases, readClusters, storeCluster } = require('../../fhir');
-const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
+const { ClusterImpression, CLUSTER_STATUSES, CONFIDENCE_LEVELS, CLINICAL_SIGNIFICANCE } = require('../../shared/dtos/ClusterImpression');
 const { ClusterHistoryRecord } = require('../../shared/dtos/ClusterHistoryRecord');
+const { OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 
-const CONFIDENCE_LEVELS = ['speculative', 'moderate', 'strong'];
-const STATUS_LEVELS = ['active', 'dissolved'];
-const CLINICAL_SIGNIFICANCE = ['benign', 'moderate', 'safety_relevant', 'emergency'];
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
 const UPDATE_KEYS = ['add_members', 'remove_members', 'label_new', 'confidence_new', 'status_new', 'clinical_significance_new', 'relationship_model_new', 'strengthens_if_new', 'weakens_if_new'];
 
 const definition = {
@@ -72,7 +69,7 @@ async function handler(args = {}, context = {}) {
     const weakensNew = update.weakens_if_new;
 
     if (confidenceNew !== null && !CONFIDENCE_LEVELS.includes(confidenceNew)) return fail(`invalid confidence_new. Must be one of ${CONFIDENCE_LEVELS.join(' | ')}.`, { confidence_new: confidenceNew });
-    if (statusNew !== null && !STATUS_LEVELS.includes(statusNew)) return fail(`invalid status_new. Must be one of ${STATUS_LEVELS.join(' | ')}.`, { status_new: statusNew });
+    if (statusNew !== null && !CLUSTER_STATUSES.includes(statusNew)) return fail(`invalid status_new. Must be one of ${CLUSTER_STATUSES.join(' | ')}.`, { status_new: statusNew });
     if (significanceNew !== null && !CLINICAL_SIGNIFICANCE.includes(significanceNew)) return fail(`invalid clinical_significance_new. Must be one of ${CLINICAL_SIGNIFICANCE.join(' | ')}.`, { clinical_significance_new: significanceNew });
     if (relModelNew !== undefined && (typeof relModelNew !== 'string' || !relModelNew.trim())) return fail('relationship_model_new must be a non-empty string');
 
@@ -91,7 +88,7 @@ async function handler(args = {}, context = {}) {
       if (currentMembers.includes(caseId)) return fail('add_member_already_in_cluster', { case_id: caseId });
       const managedSymptom = cases.find((c) => c.condition.conditionId === caseId);
       if (!managedSymptom) return fail('add_member_not_found_or_wrong_patient', { case_id: caseId });
-      if (!OPEN_CASE_STATUSES.includes(managedSymptom.condition.clinicalStatus)) return fail('add_member_not_open', { case_id: caseId, status: managedSymptom.condition.clinicalStatus });
+      if (!OPEN_STATUSES.includes(managedSymptom.condition.clinicalStatus)) return fail('add_member_not_open', { case_id: caseId, status: managedSymptom.condition.clinicalStatus });
     }
     for (const caseId of removeMembers) {
       if (!currentMembers.includes(caseId)) return fail('remove_member_not_in_cluster', { case_id: caseId });

package/lib/clinical/tools/updateConditionStatusTool.js

@@ -1,5 +1,5 @@
 const { readSymptomCases, storeSymptomCase, readContingencies, storeContingency, readClusters, storeCluster } = require('../../fhir');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
+const { ManagedSymptom, OPEN_STATUSES } = require('../../shared/dtos/ManagedSymptom');
 const { RESOLUTION_CLOSE_REASONS } = require('../../fhir/resources/Condition');
 const { ContingencySafetyNet, ACTIVE_CARE_PLAN_STATUSES } = require('../../shared/dtos/ContingencySafetyNet');
 const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
@@ -7,7 +7,6 @@ const { ClusterHistoryRecord } = require('../../shared/dtos/ClusterHistoryRecord
 const { logger } = require('../../utils/logger');
 
 const DEACTIVATE_CLOSE_REASONS = ['escalated_to_team', 'patient_transferred', 'stale_no_activity'];
-const OPEN_STATUSES = ['characterizing', 'monitoring'];
 const CLUSTER_MEMBER_FLOOR = 2;
 
 const definition = {

package/lib/fhir/constants/extensionSlugs.js

@@ -0,0 +1,111 @@
+const CONTINGENCY_CATEGORY_PREFIX = 'contingency-';
+
+const SYMPTOM_CASE_EXT = {
+  STATUS: 'symptom-case-status',
+  LEGACY_ABATEMENT: 'legacy-abatement',
+  CLOSE_REASON: 'symptom-close-reason',
+  TEMPORALITY: 'symptom-temporality',
+  CURRENT_EPISODE_ID: 'symptom-current-episode-id',
+  EVIDENCE_EPISODE_IDS: 'symptom-evidence-episode-ids',
+  EVIDENCE_MENTION_IDS: 'symptom-evidence-mention-ids',
+  RECURRENCE_COUNT: 'symptom-recurrence-count',
+  REACTIVATED_AT: 'symptom-reactivated-at',
+};
+
+const ASSESSMENT_EXT = {
+  TRAJECTORY: 'trajectory',
+  DECISION_POSTURE: 'decision-posture',
+  POSTURE_REASON: 'posture-reason',
+  REASONING: 'assessment-reasoning',
+};
+
+const GRADE_EXT = {
+  CONFIDENCE: 'grade-confidence',
+  RANGE: 'grade-range',
+  REASONING: 'grade-reasoning',
+  VERIFICATION: 'grade-verification',
+  THRESHOLD_CLAUSE: 'grade-threshold-clause',
+};
+
+const ROUTING_EXT = {
+  TURN_ID: 'routing-turn-id',
+  DECISION_ID: 'routing-decision-id',
+  COMMITTED_AT: 'routing-committed-at',
+  PRIMARY_CASE_ID: 'routing-primary-case-id',
+  DEFERRED_ITEM: 'routing-deferred-item',
+  DEFERRED_REASON: 'routing-deferred-reason',
+  FINDING_CASE_ID: 'routing-finding-case-id',
+  FINDING_REASONING: 'routing-finding-reasoning',
+  FINDING_ACTION: 'routing-finding-action',
+};
+
+const CLUSTER_EXT = {
+  HYPOTHESIS_TYPE: 'clusterHypothesisType',
+  CONFIDENCE: 'clusterHypothesisConfidence',
+  CLINICAL_SIGNIFICANCE: 'clusterClinicalSignificance',
+  STRENGTHENS_IF: 'clusterStrengthensIf',
+  WEAKENS_IF: 'clusterWeakensIf',
+  STATUS: 'cluster-status',
+  CONSULTATION_ID: 'cluster-consultation-id',
+  DISSOLVE_REASON: 'cluster-dissolve-reason',
+};
+
+const PALLIATIVE_EXT = {
+  TURN_ID: 'palliative-turn-id',
+  ASSESSMENT_ID: 'palliative-assessment-id',
+  ESCALATION_RANK: 'palliative-escalation-rank',
+  CAREPLAN_REC_RANK: 'palliative-careplan-rec-rank',
+  CAREPLAN_OTC_OFFER: 'palliative-careplan-otc-offer',
+  FINDING_RANK: 'palliative-finding-rank',
+  FINDING_ELEMENT_TYPE: 'palliative-finding-element-type',
+  FINDING_TIME_WINDOW: 'palliative-finding-time-window',
+  FINDING_SYMPTOM_TERM: 'palliative-finding-symptom-term',
+  FINDING_CLINICAL_DESCRIPTION: 'palliative-finding-clinical-description',
+  FINDING_WHY_RELEVANT: 'palliative-finding-why-relevant',
+  FINDING_QOL_IMPACT: 'palliative-finding-qol-impact',
+  FINDING_QOL_CRITERIA: 'palliative-finding-qol-criteria',
+  FINDING_IMPROVEMENT_CAPACITY: 'palliative-finding-improvement-capacity',
+  FINDING_IMPROVEMENT_CRITERIA: 'palliative-finding-improvement-criteria',
+  FINDING_ARE_MEDS_NEEDED: 'palliative-finding-are-meds-needed',
+  FINDING_NEEDS_CHARACTERIZATION: 'palliative-finding-needs-characterization',
+  FINDING_CHARACTERIZATION_CRITERIA: 'palliative-finding-characterization-criteria',
+  FINDING_PROBE_QUESTION: 'palliative-finding-probe-question',
+  FINDING_AUDIT_NOTES: 'palliative-finding-audit-notes',
+  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',
+  DISEASE_COMPLICATION: 'risk-disease-complication',
+  DISEASE_WARNING_SYMPTOM: 'risk-disease-warning-symptom',
+  DISEASE_AMPLIFIER: 'risk-disease-amplifier',
+  COMORBIDITY_CLINICAL_NOTE: 'risk-comorbidity-clinical-note',
+  SOURCE_REGIMEN: 'assessed-source-regimen',
+  SOURCE_DIAGNOSIS: 'assessed-source-diagnosis',
+  SOURCE_PHASE: 'assessed-source-phase',
+  ASSESSED_BY_MODEL: 'assessed-by-model',
+};
+
+module.exports = {
+  SYMPTOM_CASE_EXT,
+  ASSESSMENT_EXT,
+  GRADE_EXT,
+  ROUTING_EXT,
+  CLUSTER_EXT,
+  PALLIATIVE_EXT,
+  CONTINGENCY_EXT,
+  CONTINGENCY_CATEGORY_PREFIX,
+  RISK_EXT,
+};

package/lib/fhir/resources/CarePlan.js

@@ -8,6 +8,7 @@ const {
   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',
@@ -77,11 +78,11 @@ class CarePlan {
       category: [codeableConcept(PALLIATIVE_CAREPLAN_SLUG)],
       subject: patientReference(carePlan.patientId),
       created: toIso(carePlan.committedAt),
-      extension: [extension('palliative-turn-id', { valueString: carePlan.turnId })],
+      extension: [extension(PALLIATIVE_EXT.TURN_ID, { valueString: carePlan.turnId })],
     };
     if (carePlan.summary) payload.description = carePlan.summary;
     if (carePlan.assessmentId) {
-      payload.extension.push(extension('palliative-assessment-id', { valueString: carePlan.assessmentId }));
+      payload.extension.push(extension(PALLIATIVE_EXT.ASSESSMENT_ID, { valueString: carePlan.assessmentId }));
       payload.supportingInfo = [reference('ClinicalImpression', carePlan.assessmentId)];
     }
     if (taskIds.length) {
@@ -116,18 +117,18 @@ function contingencyPeriod(carePlan) {
 }
 
 function contingencyExtensions(carePlan) {
-  const out = [extension('contingency-status', { valueString: carePlan.status })];
+  const out = [extension(CONTINGENCY_EXT.STATUS, { valueString: carePlan.status })];
   if (carePlan.awaitingCharacterization) {
-    out.push(extension('contingency-awaiting-characterization', { valueString: carePlan.awaitingCharacterization }));
+    out.push(extension(CONTINGENCY_EXT.AWAITING_CHARACTERIZATION, { valueString: carePlan.awaitingCharacterization }));
   }
   if (carePlan.whyThisMatters) {
-    out.push(extension('contingency-why-this-matters', { valueString: carePlan.whyThisMatters }));
+    out.push(extension(CONTINGENCY_EXT.WHY_THIS_MATTERS, { valueString: carePlan.whyThisMatters }));
   }
   if (carePlan.creationReasoning) {
-    out.push(extension('contingency-creation-reasoning', { valueString: carePlan.creationReasoning }));
+    out.push(extension(CONTINGENCY_EXT.CREATION_REASONING, { valueString: carePlan.creationReasoning }));
   }
   if (carePlan.resolvedReason) {
-    out.push(extension('contingency-resolved-reason', { valueString: carePlan.resolvedReason }));
+    out.push(extension(CONTINGENCY_EXT.RESOLVED_REASON, { valueString: carePlan.resolvedReason }));
   }
   return out;
 }

package/lib/fhir/resources/ClinicalImpression.js

@@ -1,6 +1,7 @@
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { SYMPTOM_ASSESSMENT_SLUG, CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { ASSESSMENT_EXT, ROUTING_EXT, CLUSTER_EXT, PALLIATIVE_EXT } = require('../constants/extensionSlugs');
 
 const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
 const CLUSTER_LIST_SEPARATOR = '; ';
@@ -12,19 +13,19 @@ class ClinicalImpression {
 
   static fromClusterImpression({ cluster }) {
     const epistemicExts = [
-      extension('clusterHypothesisType', { valueString: cluster.hypothesisType }),
-      extension('clusterHypothesisConfidence', { valueString: cluster.confidence }),
-      extension('clusterClinicalSignificance', { valueString: cluster.clinicalSignificance }),
+      extension(CLUSTER_EXT.HYPOTHESIS_TYPE, { valueString: cluster.hypothesisType }),
+      extension(CLUSTER_EXT.CONFIDENCE, { valueString: cluster.confidence }),
+      extension(CLUSTER_EXT.CLINICAL_SIGNIFICANCE, { valueString: cluster.clinicalSignificance }),
     ];
     if (cluster.strengthensIf.length) {
-      epistemicExts.push(extension('clusterStrengthensIf', { valueString: cluster.strengthensIf.join(CLUSTER_LIST_SEPARATOR) }));
+      epistemicExts.push(extension(CLUSTER_EXT.STRENGTHENS_IF, { valueString: cluster.strengthensIf.join(CLUSTER_LIST_SEPARATOR) }));
     }
     if (cluster.weakensIf.length) {
-      epistemicExts.push(extension('clusterWeakensIf', { valueString: cluster.weakensIf.join(CLUSTER_LIST_SEPARATOR) }));
+      epistemicExts.push(extension(CLUSTER_EXT.WEAKENS_IF, { valueString: cluster.weakensIf.join(CLUSTER_LIST_SEPARATOR) }));
     }
-    const lifecycleExts = [extension('cluster-status', { valueString: cluster.status })];
-    if (cluster.consultationId) lifecycleExts.push(extension('cluster-consultation-id', { valueString: cluster.consultationId }));
-    if (cluster.dissolveReason) lifecycleExts.push(extension('cluster-dissolve-reason', { valueString: cluster.dissolveReason }));
+    const lifecycleExts = [extension(CLUSTER_EXT.STATUS, { valueString: cluster.status })];
+    if (cluster.consultationId) lifecycleExts.push(extension(CLUSTER_EXT.CONSULTATION_ID, { valueString: cluster.consultationId }));
+    if (cluster.dissolveReason) lifecycleExts.push(extension(CLUSTER_EXT.DISSOLVE_REASON, { valueString: cluster.dissolveReason }));
 
     const identifiers = [identifier(CLUSTER_IMPRESSION_SLUG, cluster.clusterId)];
     if (cluster.label) identifiers.push(identifier(CLUSTER_LABEL_SLUG, cluster.label));
@@ -52,10 +53,10 @@ class ClinicalImpression {
 
   static fromSymptomAssessment({ assessment, dropPreviousTo = null, hasGradeSignal = false }) {
     const extensions = [];
-    if (assessment.trajectory) extensions.push(extension('trajectory', { valueString: assessment.trajectory }));
-    if (assessment.decisionPosture) extensions.push(extension('decision-posture', { valueString: assessment.decisionPosture }));
-    if (assessment.postureReason) extensions.push(extension('posture-reason', { valueString: assessment.postureReason }));
-    if (assessment.reasoning) extensions.push(extension('assessment-reasoning', { valueString: assessment.reasoning }));
+    if (assessment.trajectory) extensions.push(extension(ASSESSMENT_EXT.TRAJECTORY, { valueString: assessment.trajectory }));
+    if (assessment.decisionPosture) extensions.push(extension(ASSESSMENT_EXT.DECISION_POSTURE, { valueString: assessment.decisionPosture }));
+    if (assessment.postureReason) extensions.push(extension(ASSESSMENT_EXT.POSTURE_REASON, { valueString: assessment.postureReason }));
+    if (assessment.reasoning) extensions.push(extension(ASSESSMENT_EXT.REASONING, { valueString: assessment.reasoning }));
     const payload = {
       resourceType: 'ClinicalImpression',
       id: fhirId(assessment.assessmentId),
@@ -102,14 +103,14 @@ class ClinicalImpression {
 
   static fromRoutingAssessment({ assessment, decisionId, committedAt, deferredItems = [], primaryCaseId = null }) {
     const extensions = [
-      extension('routing-turn-id', { valueString: assessment.turnId }),
-      extension('routing-decision-id', { valueString: decisionId }),
-      extension('routing-committed-at', { valueDateTime: toIso(committedAt) }),
+      extension(ROUTING_EXT.TURN_ID, { valueString: assessment.turnId }),
+      extension(ROUTING_EXT.DECISION_ID, { valueString: decisionId }),
+      extension(ROUTING_EXT.COMMITTED_AT, { valueDateTime: toIso(committedAt) }),
     ];
-    if (primaryCaseId) extensions.push(extension('routing-primary-case-id', { valueString: primaryCaseId }));
+    if (primaryCaseId) extensions.push(extension(ROUTING_EXT.PRIMARY_CASE_ID, { valueString: primaryCaseId }));
     for (const deferred of deferredItems) {
-      extensions.push(extension('routing-deferred-item', { valueString: deferred.item }));
-      extensions.push(extension('routing-deferred-reason', { valueString: deferred.deferReason }));
+      extensions.push(extension(ROUTING_EXT.DEFERRED_ITEM, { valueString: deferred.item }));
+      extensions.push(extension(ROUTING_EXT.DEFERRED_REASON, { valueString: deferred.deferReason }));
     }
     const payload = {
       resourceType: 'ClinicalImpression',
@@ -124,11 +125,11 @@ class ClinicalImpression {
         // A caseless mention (caseId null) has no case to point at: no Condition item and no case-id extension, so absence stays absence in the FHIR.
         if (finding.caseId) {
           projected.item = reference('Condition', finding.caseId);
-          findingExts.push(extension('routing-finding-case-id', { valueString: finding.caseId }));
+          findingExts.push(extension(ROUTING_EXT.FINDING_CASE_ID, { valueString: finding.caseId }));
         }
         findingExts.push(
-          extension('routing-finding-reasoning', { valueString: finding.clinicalReasoning }),
-          extension('routing-finding-action', { valueString: finding.decisionAction }),
+          extension(ROUTING_EXT.FINDING_REASONING, { valueString: finding.clinicalReasoning }),
+          extension(ROUTING_EXT.FINDING_ACTION, { valueString: finding.decisionAction }),
         );
         projected.extension = findingExts;
         return projected;
@@ -150,7 +151,7 @@ class ClinicalImpression {
       subject: patientReference(assessment.patientId),
       effectiveDateTime: toIso(assessment.committedAt),
       finding: assessment.findings.map(palliativeFinding),
-      extension: [extension('palliative-turn-id', { valueString: assessment.turnId })],
+      extension: [extension(PALLIATIVE_EXT.TURN_ID, { valueString: assessment.turnId })],
     };
     if (assessment.evaluationSummary) payload.summary = assessment.evaluationSummary;
     if (assessment.rankingRationale) payload.description = assessment.rankingRationale;
@@ -161,23 +162,23 @@ class ClinicalImpression {
 
 function palliativeFinding(finding) {
   const extensions = [
-    extension('palliative-finding-rank', { valueInteger: finding.rank }),
-    extension('palliative-finding-element-type', { valueString: finding.elementType }),
-    extension('palliative-finding-time-window', { valueString: finding.timeWindow }),
-    extension('palliative-finding-clinical-description', { valueString: finding.clinicalDescription }),
-    extension('palliative-finding-why-relevant', { valueString: finding.whyRelevant }),
-    extension('palliative-finding-qol-criteria', { valueString: finding.qolCriteria }),
-    extension('palliative-finding-improvement-criteria', { valueString: finding.improvementCriteria }),
-    extension('palliative-finding-characterization-criteria', { valueString: finding.characterizationCriteria }),
-    extension('palliative-finding-audit-notes', { valueString: finding.auditNotes }),
+    extension(PALLIATIVE_EXT.FINDING_RANK, { valueInteger: finding.rank }),
+    extension(PALLIATIVE_EXT.FINDING_ELEMENT_TYPE, { valueString: finding.elementType }),
+    extension(PALLIATIVE_EXT.FINDING_TIME_WINDOW, { valueString: finding.timeWindow }),
+    extension(PALLIATIVE_EXT.FINDING_CLINICAL_DESCRIPTION, { valueString: finding.clinicalDescription }),
+    extension(PALLIATIVE_EXT.FINDING_WHY_RELEVANT, { valueString: finding.whyRelevant }),
+    extension(PALLIATIVE_EXT.FINDING_QOL_CRITERIA, { valueString: finding.qolCriteria }),
+    extension(PALLIATIVE_EXT.FINDING_IMPROVEMENT_CRITERIA, { valueString: finding.improvementCriteria }),
+    extension(PALLIATIVE_EXT.FINDING_CHARACTERIZATION_CRITERIA, { valueString: finding.characterizationCriteria }),
+    extension(PALLIATIVE_EXT.FINDING_AUDIT_NOTES, { valueString: finding.auditNotes }),
   ];
-  for (const term of finding.symptomTerms) extensions.push(extension('palliative-finding-symptom-term', { valueString: term }));
-  for (const question of finding.probeQuestions) extensions.push(extension('palliative-finding-probe-question', { valueString: question }));
-  if (finding.qolImpact !== null) extensions.push(extension('palliative-finding-qol-impact', { valueString: finding.qolImpact }));
-  if (finding.improvementCapacity !== null) extensions.push(extension('palliative-finding-improvement-capacity', { valueString: finding.improvementCapacity }));
-  if (finding.areMedsNeeded !== null) extensions.push(extension('palliative-finding-are-meds-needed', { valueBoolean: finding.areMedsNeeded }));
-  if (finding.needsCharacterization !== null) extensions.push(extension('palliative-finding-needs-characterization', { valueBoolean: finding.needsCharacterization }));
-  if (finding.clusterNote !== null) extensions.push(extension('palliative-finding-cluster-note', { valueString: finding.clusterNote }));
+  for (const term of finding.symptomTerms) extensions.push(extension(PALLIATIVE_EXT.FINDING_SYMPTOM_TERM, { valueString: term }));
+  for (const question of finding.probeQuestions) extensions.push(extension(PALLIATIVE_EXT.FINDING_PROBE_QUESTION, { valueString: question }));
+  if (finding.qolImpact !== null) extensions.push(extension(PALLIATIVE_EXT.FINDING_QOL_IMPACT, { valueString: finding.qolImpact }));
+  if (finding.improvementCapacity !== null) extensions.push(extension(PALLIATIVE_EXT.FINDING_IMPROVEMENT_CAPACITY, { valueString: finding.improvementCapacity }));
+  if (finding.areMedsNeeded !== null) extensions.push(extension(PALLIATIVE_EXT.FINDING_ARE_MEDS_NEEDED, { valueBoolean: finding.areMedsNeeded }));
+  if (finding.needsCharacterization !== null) extensions.push(extension(PALLIATIVE_EXT.FINDING_NEEDS_CHARACTERIZATION, { valueBoolean: finding.needsCharacterization }));
+  if (finding.clusterNote !== null) extensions.push(extension(PALLIATIVE_EXT.FINDING_CLUSTER_NOTE, { valueString: finding.clusterNote }));
   return { item: { concept: codeableConcept(finding.nameShort) }, extension: extensions };
 }
 

package/lib/fhir/resources/CommunicationRequest.js

@@ -21,6 +21,7 @@ const {
   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');
 
@@ -113,7 +114,7 @@ class CommunicationRequest {
       identifier: [identifier(CONTINGENCY_STEP_SLUG, stepId)],
       status: CONTINGENCY_STATUS_TO_FHIR[parentStatus],
       intent: 'plan',
-      category: [codeableConcept(`contingency-${step.recipient}`)],
+      category: [codeableConcept(`${CONTINGENCY_CATEGORY_PREFIX}${step.recipient}`)],
       subject: patientReference(patientId),
       recipient: [step.recipient === 'patient'
         ? patientReference(patientId)
@@ -125,10 +126,10 @@ class CommunicationRequest {
     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-step-priority', { valueString: step.priority }));
-    if (step.actionRequested) ext.push(extension('contingency-action-requested', { valueString: step.actionRequested }));
+    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('fires-after-silence-minutes', { valueInteger: step.firesAfterSilenceMinutes }));
+      ext.push(extension(CONTINGENCY_EXT.FIRES_AFTER_SILENCE_MINUTES, { valueInteger: step.firesAfterSilenceMinutes }));
     }
     if (ext.length) payload.extension = ext;
     return new CommunicationRequest(payload);

package/lib/fhir/resources/Condition.js

@@ -2,6 +2,7 @@ const { getSystems } = require('../config/fhirConfig');
 const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 const { SYMPTOM_CASE_SLUG } = require('../constants/projectionSlugs');
+const { SYMPTOM_CASE_EXT } = require('../constants/extensionSlugs');
 
 const CLINICAL_STATUS_TO_FHIR = {
   resolved: 'resolved',
@@ -39,7 +40,7 @@ class Condition {
     const code = condition.ctcaeTerm && condition.ctcaeTerm !== 'other'
       ? codeableConcept(condition.ctcaeTerm, { code: condition.ctcaeTerm, system: codeSystemUrl('pro-ctcae'), display: condition.ctcaeTerm })
       : codeableConcept(condition.ctcaeTerm || 'other');
-    const extensions = [extension('symptom-case-status', { valueString: condition.clinicalStatus })];
+    const extensions = [extension(SYMPTOM_CASE_EXT.STATUS, { valueString: condition.clinicalStatus })];
     const payload = {
       resourceType: 'Condition',
       id: fhirId(condition.conditionId),
@@ -63,21 +64,21 @@ class Condition {
       if (clinicalStatusCode === 'resolved') {
         payload.abatementDateTime = toIso(condition.abatementAt);
       } else {
-        extensions.push(extension('legacy-abatement', { valueDateTime: toIso(condition.abatementAt) }));
+        extensions.push(extension(SYMPTOM_CASE_EXT.LEGACY_ABATEMENT, { valueDateTime: toIso(condition.abatementAt) }));
       }
     }
     if (condition.closeReason) {
-      extensions.push(extension('symptom-close-reason', { valueString: condition.closeReason }));
+      extensions.push(extension(SYMPTOM_CASE_EXT.CLOSE_REASON, { valueString: condition.closeReason }));
       if (clinicalStatusCode === 'inactive' && condition.closeReason === 'stale_no_activity') {
         extensions.push(extension('presumed-inactive-by-gap', { valueBoolean: true }));
       }
     }
-    if (condition.temporality) extensions.push(extension('symptom-temporality', { valueString: condition.temporality }));
-    if (condition.currentEpisodeId) extensions.push(extension('symptom-current-episode-id', { valueString: condition.currentEpisodeId }));
-    for (const id of condition.evidenceEpisodeIds) extensions.push(extension('symptom-evidence-episode-ids', { valueString: id }));
-    for (const id of condition.evidenceMentionIds) extensions.push(extension('symptom-evidence-mention-ids', { valueString: id }));
-    extensions.push(extension('symptom-recurrence-count', { valueInteger: condition.recurrenceCount }));
-    if (condition.reactivatedAt) extensions.push(extension('symptom-reactivated-at', { valueDateTime: toIso(condition.reactivatedAt) }));
+    if (condition.temporality) extensions.push(extension(SYMPTOM_CASE_EXT.TEMPORALITY, { valueString: condition.temporality }));
+    if (condition.currentEpisodeId) extensions.push(extension(SYMPTOM_CASE_EXT.CURRENT_EPISODE_ID, { valueString: condition.currentEpisodeId }));
+    for (const id of condition.evidenceEpisodeIds) extensions.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_EPISODE_IDS, { valueString: id }));
+    for (const id of condition.evidenceMentionIds) extensions.push(extension(SYMPTOM_CASE_EXT.EVIDENCE_MENTION_IDS, { valueString: id }));
+    extensions.push(extension(SYMPTOM_CASE_EXT.RECURRENCE_COUNT, { valueInteger: condition.recurrenceCount }));
+    if (condition.reactivatedAt) extensions.push(extension(SYMPTOM_CASE_EXT.REACTIVATED_AT, { valueDateTime: toIso(condition.reactivatedAt) }));
     if (condition.lastTransitionReason) payload.note = [{ text: condition.lastTransitionReason }];
     const evidence = [
       ...condition.evidenceEpisodeIds.map((id) => ({ reference: reference('Observation', id) })),