@peopl-health/nexus 5.9.0-dev.921 → 6.0.0-dev.611

package/lib/clinical/tools/submitRoutingDecisionTool.js

@@ -1,291 +0,0 @@
-const crypto = require('node:crypto');
-
-const { storeRoutingDecision, readRoutingByTurn } = require('../../fhir');
-const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
-
-const _ROUTING_ACTIONS = [
-  'emergency_escalation', 'team_escalation', 'palliative_referral',
-  'symptom_recommendation', 'symptom_probe',
-  'acknowledge_improvement_on_case',
-  'follow_up_on_open_case', 'revisit_neglected_case',
-  'educate_about_symptom', 'educate_about_treatment', 'preparation_guidance',
-  'emotional_support', 'acknowledge_only',
-  'request_clarification',
-  'weekly_triage_recommendations',
-  'generate_recommendations',
-];
-
-const _COMPOSE_AS_VALUES = [
-  'opener', 'woven_into_primary', 'closer',
-  'brief_checkin', 'separate_if_space',
-];
-
-const _ACTION_SYNONYMS = {
-  acknowledge: 'acknowledge_only',
-  clarify: 'request_clarification',
-  clarification: 'request_clarification',
-  probe: 'symptom_probe',
-  recommend: 'symptom_recommendation',
-  recommendation: 'symptom_recommendation',
-  referral: 'palliative_referral',
-  escalate: 'team_escalation',
-  emergency: 'emergency_escalation',
-};
-
-const _COMPOSE_SYNONYMS = {
-  open: 'opener',
-  opening: 'opener',
-  close: 'closer',
-  closing: 'closer',
-  weave: 'woven_into_primary',
-  woven: 'woven_into_primary',
-  checkin: 'brief_checkin',
-  check_in: 'brief_checkin',
-  separate: 'separate_if_space',
-};
-
-const _ACTION_TO_DISPOSITION_KIND = {
-  emergency_escalation: 'task',
-  team_escalation: 'task',
-  palliative_referral: 'task',
-  symptom_recommendation: 'care_plan',
-  follow_up_on_open_case: 'care_plan',
-  revisit_neglected_case: 'care_plan',
-  preparation_guidance: 'care_plan',
-  weekly_triage_recommendations: 'care_plan',
-  generate_recommendations: 'care_plan',
-  symptom_probe: 'communication_request',
-  acknowledge_improvement_on_case: 'communication',
-  emotional_support: 'communication',
-  educate_about_symptom: 'communication',
-  educate_about_treatment: 'communication',
-  acknowledge_only: 'communication',
-  request_clarification: 'communication',
-};
-
-const _DOWNSTREAM_SKILL = {
-  emergency_escalation: 'emergency',
-  palliative_referral: 'accompaniment',
-  symptom_recommendation: 'symptom_management',
-  follow_up_on_open_case: 'symptom_management',
-  revisit_neglected_case: 'symptom_management',
-  preparation_guidance: 'accompaniment',
-  emotional_support: 'accompaniment',
-  educate_about_symptom: 'patient_education',
-  educate_about_treatment: 'patient_education',
-  weekly_triage_recommendations: 'symptom_management',
-  generate_recommendations: 'symptom_management',
-};
-
-const definition = {
-  name: 'submitRoutingDecision',
-  description: '**Does:** The terminal routing checkpoint — call ONCE per turn to commit the turn plan. Decomposes `trace` (the per-mention evaluation record) and `turn_plan` (the primary action + optional secondary/deferred) into a persisted RoutingDecision (assessment + disposition + provenance), sets the turn\'s outbound signals, and hands the agent the next skill to invoke.\n\n**Required inputs:** `trace.mentions_evaluated[]` — one entry per clinical mention: `case_id_opened_or_updated`, `clinical_reasoning`, `decision.action`, plus `safety_flag_disposition` when `safety_flags_received` is non-empty. `turn_plan.primary` — exactly one `{action, reason, case_id?}`; `turn_plan.secondary[]` — up to 2 `{action, compose_as}`; `turn_plan.deferred[]` — optional `{item?, defer_reason}`.\n\n**Enum coercion:** primary/secondary `action` and secondary `compose_as` are folded (case/accent/separator) and synonym-mapped to canonical values; each repair is disclosed via `auto_repairs`. A genuinely unknown action is rejected.\n\n**Returns:** `decision_id`, `downstream_skill_to_invoke` (emergency | accompaniment | symptom_management | patient_education | null, derived from `primary.action`), and `auto_repairs` (only when non-empty). Fails hard with `decision_already_committed_for_turn` if called twice in one turn.\n\n**Side effects:** persists the RoutingDecision; sets `branch_taken=ai_agent` on the turn trace.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      trace: {
-        type: 'object',
-        description: 'Per-mention evaluation record. `mentions_evaluated[]`: each `{case_id_opened_or_updated, clinical_reasoning, decision:{action}, safety_flags_received?, safety_flag_disposition?}`. A safety_flag_disposition is required for any mention with a non-empty safety_flags_received.',
-      },
-      turn_plan: {
-        type: 'object',
-        description: 'The routing plan. `primary` (required): `{action, reason, case_id?}`. `secondary` (0-2): `[{action, compose_as}]`. `deferred` (optional): `[{item?, defer_reason}]`.',
-      },
-    },
-    required: ['trace', 'turn_plan'],
-  },
-};
-
-const uid = (prefix) => `${prefix}_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-function foldToken(value) {
-  const folded = String(value).trim().toLowerCase()
-    .normalize('NFD').replace(/[\u0300-\u036f]/g, '');
-  return folded.replace(/[\s\-/]+/g, '_');
-}
-
-function unwrapScalar(value) {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    for (const key of ['value', 'action', 'name']) {
-      if (typeof value[key] === 'string') return value[key];
-    }
-  }
-  if (Array.isArray(value) && value.length === 1) return value[0];
-  return value;
-}
-
-function coerceRoutingEnum(value, valid, synonyms, field, repairs) {
-  const raw = unwrapScalar(value);
-  if (typeof raw !== 'string') return value;
-  const trimmed = raw.trim();
-  if (valid.includes(trimmed)) return trimmed;
-  const folded = foldToken(trimmed);
-  const hit = valid.find((m) => foldToken(m) === folded) || synonyms[folded];
-  if (!hit || !valid.includes(hit)) return trimmed;
-  repairs.push(`${field}: '${trimmed}' → '${hit}'`);
-  return hit;
-}
-
-function derivedDownstreamSkill(primaryAction) {
-  return _DOWNSTREAM_SKILL[primaryAction] || null;
-}
-
-function validateTurnPlan(turnPlan, repairs) {
-  const primary = turnPlan.primary;
-  if (!primary || typeof primary !== 'object' || Array.isArray(primary)) {
-    return { error: fail('turn_plan.primary is required — exactly one action') };
-  }
-  const primaryAction = coerceRoutingEnum(primary.action, _ROUTING_ACTIONS, _ACTION_SYNONYMS, 'primary.action', repairs);
-  if (!_ROUTING_ACTIONS.includes(primaryAction)) {
-    return { error: fail(`primary.action '${primaryAction}' not in action-taxonomy`, { primary_action: primaryAction, valid_actions: [..._ROUTING_ACTIONS].sort() }) };
-  }
-  const primaryReason = typeof primary.reason === 'string' ? primary.reason.trim() : '';
-  if (!primaryReason) return { error: fail('turn_plan.primary.reason is required (non-empty string)') };
-  const primaryCaseId = (typeof primary.case_id === 'string' ? primary.case_id.trim() : '') || null;
-
-  const secondaryRaw = turnPlan.secondary || [];
-  if (!Array.isArray(secondaryRaw)) return { error: fail('turn_plan.secondary must be a list (0-2 items)') };
-  if (secondaryRaw.length > 2) return { error: fail('turn_plan.secondary has at most 2 items', { n: secondaryRaw.length }) };
-  const secondaryActions = [];
-  for (let i = 0; i < secondaryRaw.length; i += 1) {
-    const secondary = secondaryRaw[i];
-    if (!secondary || typeof secondary !== 'object' || Array.isArray(secondary)) return { error: fail('turn_plan.secondary[*] must be objects', { index: i }) };
-    const action = coerceRoutingEnum(secondary.action, _ROUTING_ACTIONS, _ACTION_SYNONYMS, 'secondary.action', repairs);
-    if (!_ROUTING_ACTIONS.includes(action)) return { error: fail(`secondary[${i}].action '${action}' not in action-taxonomy`, { index: i, action }) };
-    const composeAs = coerceRoutingEnum(secondary.compose_as, _COMPOSE_AS_VALUES, _COMPOSE_SYNONYMS, 'secondary.compose_as', repairs);
-    if (!_COMPOSE_AS_VALUES.includes(composeAs)) return { error: fail(`secondary[${i}].compose_as must be one of ${[..._COMPOSE_AS_VALUES].sort().join(', ')}`, { index: i, compose_as: composeAs }) };
-    secondaryActions.push({ action, composeAs });
-  }
-
-  const deferredRaw = turnPlan.deferred || [];
-  if (!Array.isArray(deferredRaw)) return { error: fail('turn_plan.deferred must be a list') };
-  const deferredItems = [];
-  for (let i = 0; i < deferredRaw.length; i += 1) {
-    const deferred = deferredRaw[i];
-    if (!deferred || typeof deferred !== 'object' || Array.isArray(deferred)) return { error: fail('turn_plan.deferred[*] must be objects', { index: i }) };
-    const reason = typeof deferred.defer_reason === 'string' ? deferred.defer_reason.trim() : '';
-    if (!reason) return { error: fail(`deferred[${i}].defer_reason is required (non-empty)`, { index: i }) };
-    const item = (typeof deferred.item === 'string' ? deferred.item.trim() : '') || reason;
-    deferredItems.push({ item, deferReason: reason });
-  }
-
-  return { primaryAction, primaryReason, primaryCaseId, secondaryActions, deferredItems };
-}
-
-function validateTrace(trace) {
-  const mentionsRaw = trace.mentions_evaluated || [];
-  if (!Array.isArray(mentionsRaw)) return { error: fail('trace.mentions_evaluated must be a list') };
-  const findings = [];
-  for (let i = 0; i < mentionsRaw.length; i += 1) {
-    const mention = mentionsRaw[i];
-    if (!mention || typeof mention !== 'object' || Array.isArray(mention)) return { error: fail('trace.mentions_evaluated[*] must be objects', { index: i }) };
-    const caseId = (typeof mention.case_id_opened_or_updated === 'string' ? mention.case_id_opened_or_updated.trim() : '');
-    if (!caseId) return { error: fail(`mentions_evaluated[${i}].case_id_opened_or_updated is required`, { index: i }) };
-    const reasoning = typeof mention.clinical_reasoning === 'string' ? mention.clinical_reasoning.trim() : '';
-    if (!reasoning) return { error: fail(`mentions_evaluated[${i}].clinical_reasoning is required`, { index: i }) };
-    let decision = mention.decision;
-    if (typeof decision === 'string' && decision.trim()) decision = { action: decision.trim() };
-    if (!decision || typeof decision !== 'object' || Array.isArray(decision)) {
-      return { error: fail(`mentions_evaluated[${i}].decision is required (object with at least \`action\`)`, { index: i }) };
-    }
-    const decisionAction = typeof decision.action === 'string' ? decision.action.trim() : '';
-    if (!decisionAction) return { error: fail(`mentions_evaluated[${i}].decision.action is required (string)`, { index: i }) };
-    const flags = mention.safety_flags_received || [];
-    if (flags != null && !Array.isArray(flags)) {
-      return { error: fail(`mentions_evaluated[${i}].safety_flags_received must be a list`, { index: i }) };
-    }
-    if (Array.isArray(flags) && flags.length) {
-      const disposition = mention.safety_flag_disposition;
-      if (!disposition || typeof disposition !== 'object' || Array.isArray(disposition)) {
-        return { error: fail(`mentions_evaluated[${i}].safety_flag_disposition is required when safety_flags_received is non-empty`, { index: i, mention_id: mention.mention_id }) };
-      }
-    }
-    findings.push({ caseId, clinicalReasoning: reasoning, decisionAction });
-  }
-  return { findings };
-}
-
-function buildDecision({ patientId, turnId, plan, findings, now }) {
-  const kind = plan.secondaryActions.length ? 'orchestration' : (_ACTION_TO_DISPOSITION_KIND[plan.primaryAction] || 'communication');
-  return new RoutingDecision({
-    schemaVersion: '1',
-    decisionId: uid('decision'),
-    patientId,
-    turnId,
-    committedAt: now,
-    assessment: {
-      assessmentId: uid('assessment'),
-      patientId,
-      turnId,
-      performedAt: now,
-      previousId: null,
-      summary: plan.primaryReason,
-      notes: [],
-      findings,
-    },
-    disposition: {
-      dispositionId: uid('disposition'),
-      patientId,
-      kind,
-      primaryAction: plan.primaryAction,
-      primaryReason: plan.primaryReason,
-      primaryCaseId: plan.primaryCaseId,
-      secondaryActions: plan.secondaryActions,
-      deferredItems: plan.deferredItems,
-      authoredAt: now,
-    },
-    provenance: {
-      agentDevice: 'clinical-agent-v2',
-      onBehalfOf: 'peopl-health',
-      recordedAt: now,
-    },
-  });
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode || !runtime?.trace) {
-      return fail('submitRoutingDecision requires an active turn context (turnId, patientCode, trace).');
-    }
-    const trace = args?.trace;
-    const turnPlan = args?.turn_plan;
-    if (!trace || typeof trace !== 'object' || Array.isArray(trace)) return fail('trace is required (non-empty object)');
-    if (!turnPlan || typeof turnPlan !== 'object' || Array.isArray(turnPlan)) return fail('turn_plan is required (non-empty object)');
-
-    const repairs = [];
-    const plan = validateTurnPlan(turnPlan, repairs);
-    if (plan.error) return plan.error;
-    const traceResult = validateTrace(trace);
-    if (traceResult.error) return traceResult.error;
-
-    const patientId = runtime.patientCode;
-    const turnId = runtime.turnId;
-
-    const existing = await readRoutingByTurn({ patientId, turnId });
-    if (existing) {
-      return fail('decision_already_committed_for_turn', { existing_decision_id: existing.decisionId, committed_at: existing.committedAt });
-    }
-
-    const decision = buildDecision({ patientId, turnId, plan, findings: traceResult.findings, now: new Date().toISOString() });
-    await storeRoutingDecision({ patientId, routingDecision: decision });
-
-    runtime.trace.setSignals({ branchTaken: 'ai_agent' });
-
-    const data = { decision_id: decision.decisionId, downstream_skill_to_invoke: derivedDownstreamSkill(plan.primaryAction) };
-    if (repairs.length) data.auto_repairs = repairs;
-    return JSON.stringify({ success: true, data });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'submitRoutingDecision failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/updateClusterHypothesisTool.js

@@ -1,159 +0,0 @@
-const { readSymptomCases, readClusters, storeCluster } = require('../../fhir');
-const { ClusterImpression } = require('../../shared/dtos/ClusterImpression');
-const { ClusterHistoryRecord } = require('../../shared/dtos/ClusterHistoryRecord');
-
-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 = {
-  name: 'updateClusterHypothesis',
-  description: '**Does:** Evolves an ACTIVE cluster hypothesis — add/remove member cases, rename, re-grade confidence or clinical significance, revise the relationship model or the strengthens/weakens signals, or dissolve it. Dissolve is terminal.\n\n**Required inputs:** `cluster_id`, `transition_reason` (audit trail), `update` (an object with at least one of `add_members`, `remove_members`, `label_new`, `confidence_new`, `status_new`, `clinical_significance_new`, `relationship_model_new`, `strengthens_if_new`, `weakens_if_new`).\n\n**When to call:** when new evidence changes the cluster, or to end it (`status_new: \'dissolved\'`).\n\n**When NOT to call:** on a dissolved cluster (terminal), or to open a new cluster (use `openClusterHypothesis`).\n\n**Returns:** `cluster_id`, `what_changed` (list of applied deltas). Fails hard on `cluster_not_found_or_wrong_patient`, `cluster_already_dissolved`, invalid vocab, `label_already_in_use`, a bad member mutation, dropping below 2 members without dissolving, or a noop.\n\n**Side effects:** re-projects the ClusterImpression and appends an \'updated\'/\'dissolved\' Provenance.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      cluster_id: {
-        type: 'string',
-        description: 'The cluster_id returned by openClusterHypothesis (or from getActiveSymptomLandscape.active_clusters[]).',
-      },
-      transition_reason: {
-        type: 'string',
-        description: 'Why the cluster is changing this turn (audit trail).',
-      },
-      update: {
-        type: 'object',
-        description: 'At least one mutation key: `add_members`, `remove_members`, `label_new`, `confidence_new`, `status_new` (`active`|`dissolved`), `clinical_significance_new`, `relationship_model_new`, `strengthens_if_new`, `weakens_if_new`.',
-      },
-    },
-    required: ['cluster_id', 'transition_reason', 'update'],
-  },
-};
-
-const strList = (raw) => (Array.isArray(raw) ? raw.filter((s) => typeof s === 'string') : []);
-const normLower = (v) => (typeof v === 'string' && v.trim() ? v.trim().toLowerCase() : null);
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return fail('updateClusterHypothesis requires an active turn context (turnId, patientCode).');
-    }
-    const clusterId = (typeof args?.cluster_id === 'string' ? args.cluster_id : '').trim();
-    const transitionReason = (typeof args?.transition_reason === 'string' ? args.transition_reason : '').trim();
-    const update = args?.update;
-    if (!clusterId) return fail('cluster_id is required');
-    if (!transitionReason) return fail('transition_reason is required (audit trail)');
-    if (!update || typeof update !== 'object' || Array.isArray(update) || !Object.keys(update).length) {
-      return fail('update object with at least one mutation key is required');
-    }
-    const unknown = Object.keys(update).filter((k) => !UPDATE_KEYS.includes(k));
-    if (unknown.length) return fail(`unknown update keys: ${unknown.join(', ')}`, { unknown_keys: unknown });
-
-    const patientId = runtime.patientCode;
-    const cluster = (await readClusters({ patientId })).find((c) => c.clusterId === clusterId);
-    if (!cluster) return fail('cluster_not_found_or_wrong_patient', { cluster_id: clusterId });
-    if (cluster.status === 'dissolved') {
-      return fail('cluster_already_dissolved — dissolve is terminal', { cluster_id: clusterId, dissolved_at: cluster.dissolvedAt, dissolve_reason: cluster.dissolveReason });
-    }
-
-    const labelNew = 'label_new' in update ? (typeof update.label_new === 'string' ? update.label_new : '').trim() : null;
-    const confidenceNew = 'confidence_new' in update ? normLower(update.confidence_new) : null;
-    const statusNew = 'status_new' in update ? normLower(update.status_new) : null;
-    const significanceNew = 'clinical_significance_new' in update ? normLower(update.clinical_significance_new) : null;
-    const relModelNew = update.relationship_model_new;
-    const strengthensNew = update.strengthens_if_new;
-    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 (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');
-
-    const currentLabel = cluster.label || '';
-    if (labelNew && labelNew !== currentLabel) {
-      const clash = (await readClusters({ patientId, label: labelNew })).find((c) => c.status === 'active' && c.clusterId !== clusterId);
-      if (clash) return fail('label_already_in_use', { existing_cluster_id: clash.clusterId, label_new: labelNew });
-    }
-
-    const currentMembers = [...cluster.memberCaseIds];
-    const addMembers = [...new Set(strList(update.add_members))];
-    const removeMembers = [...new Set(strList(update.remove_members))];
-
-    const cases = await readSymptomCases({ patientId });
-    for (const caseId of addMembers) {
-      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 });
-    }
-    for (const caseId of removeMembers) {
-      if (!currentMembers.includes(caseId)) return fail('remove_member_not_in_cluster', { case_id: caseId });
-    }
-
-    const finalMembers = currentMembers.filter((m) => !removeMembers.includes(m)).concat(addMembers.filter((m) => !currentMembers.includes(m)));
-    const dissolving = statusNew === 'dissolved';
-    if (!dissolving && finalMembers.length < 2) {
-      return fail('would_leave_cluster_below_2_members — call updateClusterHypothesis again with status_new=\'dissolved\' to end the cluster instead', { would_be_members: finalMembers, n: finalMembers.length });
-    }
-    if (dissolving && finalMembers.length === 0) {
-      return fail('would_leave_cluster_with_0_members', { cluster_id: clusterId, removed_members: removeMembers });
-    }
-
-    const changes = [];
-    if (addMembers.length) changes.push(`added_members:${addMembers.join(',')}`);
-    if (removeMembers.length) changes.push(`removed_members:${removeMembers.join(',')}`);
-    if (labelNew && labelNew !== currentLabel) changes.push(`label:${currentLabel}→${labelNew}`);
-    if (confidenceNew && confidenceNew !== cluster.confidence) changes.push(`confidence:${cluster.confidence}→${confidenceNew}`);
-    if (statusNew && statusNew !== cluster.status) changes.push(`status:${cluster.status}→${statusNew}`);
-    if (significanceNew && significanceNew !== cluster.clinicalSignificance) changes.push(`significance:${cluster.clinicalSignificance}→${significanceNew}`);
-    if (typeof relModelNew === 'string' && relModelNew.trim() !== (cluster.relationshipModel || '')) changes.push('relationship_model_updated');
-    if (Array.isArray(strengthensNew)) changes.push('strengthens_if_replaced');
-    if (Array.isArray(weakensNew)) changes.push('weakens_if_replaced');
-    if (!changes.length) return fail('noop — update produced no changes vs current state');
-
-    const now = new Date().toISOString();
-    const patch = {
-      ...cluster,
-      memberCaseIds: finalMembers,
-    };
-    if (labelNew && labelNew !== currentLabel) patch.label = labelNew;
-    if (confidenceNew && confidenceNew !== cluster.confidence) patch.confidence = confidenceNew;
-    if (significanceNew && significanceNew !== cluster.clinicalSignificance) patch.clinicalSignificance = significanceNew;
-    if (typeof relModelNew === 'string' && relModelNew.trim()) patch.relationshipModel = relModelNew.trim();
-    if (Array.isArray(strengthensNew)) patch.strengthensIf = strList(strengthensNew);
-    if (Array.isArray(weakensNew)) patch.weakensIf = strList(weakensNew);
-    if (dissolving) {
-      patch.status = 'dissolved';
-      patch.dissolvedAt = now;
-      patch.dissolveReason = transitionReason;
-    }
-
-    const patched = new ClusterImpression(patch);
-    const action = dissolving ? 'dissolved' : 'updated';
-    const history = [new ClusterHistoryRecord({
-      clusterId,
-      turnId: runtime.turnId,
-      action,
-      changes: { items: changes },
-      transitionReason,
-      recordedAt: now,
-    })];
-
-    await storeCluster({ patientId, cluster: patched, history });
-    return JSON.stringify({ success: true, data: { cluster_id: clusterId, what_changed: changes } });
-  } catch (err) {
-    return fail(err?.message || 'updateClusterHypothesis failed');
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/controllers/cohortController.js

@@ -1,16 +0,0 @@
-const { logger } = require('../utils/logger');
-
-const { clearCohortCache } = require('../clinical/config/cohortConfig');
-
-const clearCohortCacheController = async (req, res) => {
-  try {
-    clearCohortCache();
-    logger.info('[CohortController] Cohort cache cleared', { by: req.ip });
-    return res.status(200).json({ success: true, message: 'Cohort cache cleared' });
-  } catch (error) {
-    logger.error('[CohortController] Failed to clear cohort cache', { error: error.message });
-    return res.status(500).json({ success: false, error: 'Failed to clear cohort cache' });
-  }
-};
-
-module.exports = { clearCohortCacheController };

package/lib/controllers/traceController.js

@@ -1,26 +0,0 @@
-const mongoose = require('mongoose');
-
-const { logger } = require('../utils/logger');
-const { getTurnTraceModel } = require('../clinical/models/turnTraceModel');
-
-const getTraceController = async (req, res) => {
-  const { traceId } = req.params;
-  if (!traceId || !mongoose.Types.ObjectId.isValid(traceId)) {
-    return res.status(400).json({ success: false, error: 'Valid traceId is required' });
-  }
-  try {
-    const TurnTrace = getTurnTraceModel();
-    const trace = await TurnTrace.findById(traceId).lean();
-
-    if (!trace) {
-      return res.status(404).json({ success: false, error: 'Trace not found' });
-    }
-
-    return res.status(200).json({ success: true, trace });
-  } catch (error) {
-    logger.error('Error fetching trace:', { error: error.message, traceId });
-    return res.status(500).json({ success: false, error: 'Failed to fetch trace' });
-  }
-};
-
-module.exports = { getTraceController };

package/lib/core/workflowRunner.js

@@ -1,35 +0,0 @@
-function createWorkflowRunner({ queueAdapter } = {}) {
-  if (!queueAdapter) throw new Error('createWorkflowRunner requires a queueAdapter');
-  const workflows = new Map();
-
-  async function register(workflow = {}) {
-    if (!workflow.kind || typeof workflow.kind !== 'string') throw new Error('workflow requires a kind');
-    if (workflow.kind.includes('__')) throw new Error(`workflow '${workflow.kind}' must not contain '__' (reserved as the jobId delimiter)`);
-    if (typeof workflow.dedupeKey !== 'function') throw new Error(`workflow '${workflow.kind}' requires a dedupeKey function`);
-    if (typeof workflow.prepare !== 'function') throw new Error(`workflow '${workflow.kind}' requires a prepare function`);
-    if (workflows.has(workflow.kind)) throw new Error(`workflow '${workflow.kind}' is already registered`);
-    workflows.set(workflow.kind, workflow);
-    try {
-      await queueAdapter.process(workflow.kind, (trigger) => workflow.prepare(trigger));
-    } catch (error) {
-      workflows.delete(workflow.kind);
-      throw error;
-    }
-    return workflow;
-  }
-
-  function enqueue(kind, trigger, options = {}) {
-    const workflow = workflows.get(kind);
-    if (!workflow) throw new Error(`no workflow registered for '${kind}'`);
-    const dedupeKey = workflow.dedupeKey(trigger);
-    if (dedupeKey == null || (typeof dedupeKey === 'string' && !dedupeKey.trim())) {
-      throw new Error(`workflow '${kind}' produced an empty dedupe key`);
-    }
-    if (typeof dedupeKey !== 'string') throw new Error(`workflow '${kind}' produced a non-string dedupe key`);
-    return queueAdapter.enqueue(kind, trigger, { ...options, jobId: `${kind}__${dedupeKey}` });
-  }
-
-  return { register, enqueue };
-}
-
-module.exports = { createWorkflowRunner };

package/lib/fhir/config/fhirTablesConfig.js

@@ -1,9 +0,0 @@
-const runtimeConfig = require('../../config/runtimeConfig');
-
-const PROCTCAE_ITEMS_TABLE = runtimeConfig.get('AIRTABLE_PROCTCAE_ITEMS_TABLE') || 'all_items_proctcae';
-const PROCTCAE_COMPOSITE_TABLE = runtimeConfig.get('AIRTABLE_PROCTCAE_COMPOSITE_TABLE') || 'composite_calculations';
-
-module.exports = {
-  PROCTCAE_ITEMS_TABLE,
-  PROCTCAE_COMPOSITE_TABLE,
-};

package/lib/fhir/constants/severityPriority.js

@@ -1,8 +0,0 @@
-const SEVERITY_TO_PRIORITY = {
-  critical: 'stat',
-  high: 'urgent',
-  medium: 'routine',
-  low: 'routine',
-};
-
-module.exports = { SEVERITY_TO_PRIORITY };

package/lib/fhir/helpers/compositeHelper.js

@@ -1,88 +0,0 @@
-const { logger } = require('../../utils/logger');
-const {
-  itemForQuestionId,
-  canonicalAnswer,
-  affirmative,
-  standardOrdinal,
-  compositeGrade,
-  dimensionsFor,
-} = require('./terminologyHelper');
-
-const PAIN_TERM = 'general_pain';
-
-function gradeComposites(catalog, input) {
-  const answersByTerm = new Map();
-  for (const [questionId, label] of Object.entries(input.answers || {})) {
-    if (label == null || String(label).trim() === '') continue;
-    const item = itemForQuestionId(catalog, questionId);
-    if (!item) continue;
-    const [term, dimension] = item;
-    if (!answersByTerm.has(term)) answersByTerm.set(term, {});
-    answersByTerm.get(term)[dimension] = String(canonicalAnswer(catalog, questionId, label));
-  }
-
-  const pain = painDimensionAnswers(catalog, input.pain, input.triageId);
-  if (pain) answersByTerm.set(PAIN_TERM, pain);
-
-  const graded = [];
-  for (const [term, dimensionAnswers] of answersByTerm) {
-    const ordinals = {};
-    for (const [dimension, label] of Object.entries(dimensionAnswers)) {
-      const ordinal = dimension === 'presence' ? presenceOrdinal(catalog, label) : standardOrdinal(catalog, dimension, label);
-      if (ordinal !== null) ordinals[dimension] = ordinal;
-    }
-    const grade = resolveGrade(catalog, ordinals);
-    if (grade === null) {
-      logger.warn('[gradeComposites] no composite mapping for combination', {
-        term,
-        ordinals,
-        dimensionAnswers,
-        triageId: input.triageId,
-      });
-      continue;
-    }
-    graded.push({
-      symptomId: `${input.triageId}-${term}`,
-      patientId: input.patientId,
-      term,
-      grade,
-      effective: input.authored || null,
-      triageId: input.triageId,
-      dimensionAnswers: dimensionAnswers,
-      source: 'triage',
-    });
-  }
-  return graded;
-}
-
-function presenceOrdinal(catalog, label) {
-  const ordinal = standardOrdinal(catalog, 'presence', label);
-  if (ordinal !== null) return ordinal;
-  return affirmative(label) ? 1 : null;
-}
-
-function painDimensionAnswers(catalog, pain, triageId) {
-  if (!pain || pain.hasPain == null || String(pain.hasPain).trim() === '') return null;
-  const dimensions = dimensionsFor(catalog, PAIN_TERM);
-  if (!dimensions.length) {
-    logger.warn('[gradeComposites] pain term missing from catalog', { term: PAIN_TERM, triageId });
-    return null;
-  }
-  if (!affirmative(pain.hasPain)) return { presence: String(pain.hasPain) };
-  const answers = {};
-  for (const dimension of dimensions) {
-    const label = pain[dimension];
-    if (label != null && String(label).trim() !== '') answers[dimension] = String(label);
-  }
-  return Object.keys(answers).length ? answers : { presence: String(pain.hasPain) };
-}
-
-function resolveGrade(catalog, ordinals) {
-  const grade = compositeGrade(catalog, ordinals);
-  if (grade !== null) return grade;
-  const dimensions = Object.keys(ordinals);
-  if (dimensions.length !== 1 || dimensions[0] !== 'presence') return null;
-  return ordinals.presence > 0 ? 1 : 0;
-}
-
-module.exports = { gradeComposites, PAIN_TERM };