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

package/lib/fhir/resources/Observation.js

@@ -1,7 +1,6 @@
 const { getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { SYMPTOM_GRADE_SLUG } = require('../constants/projectionSlugs');
+const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
 
 const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
 
@@ -46,77 +45,6 @@ class Observation {
     if (components.length) payload.component = components;
     return new Observation(payload);
   }
-
-  static fromTriageProjection({ sym, code, aeCategoryConcept, components, gradeConcept, method, deviceId }) {
-    const sid = String(sym.symptomId);
-    const payload = {
-      resourceType: 'Observation',
-      id: fhirId(sid),
-      identifier: [identifier('pro-ctcae-symptom', sid)],
-      status: 'preliminary',
-      category: [observationCategory('survey'), ...(aeCategoryConcept ? [aeCategoryConcept] : [])],
-      code,
-      subject: patientReference(sym.patientId),
-      performer: [patientReference(sym.patientId)],
-      valueCodeableConcept: gradeConcept,
-      method,
-      extension: [
-        extension('grade-verification', { valueCode: 'provisional' }),
-        extension('grade-derivation', { valueCode: 'pro-ctcae-composite' }),
-        extension('symptom-source', { valueString: String(sym.source || 'triage') }),
-      ],
-      derivedFrom: [reference('QuestionnaireResponse', `triage-${sym.triageId}`)],
-      device: reference('Device', deviceId),
-    };
-    if (sym.effective) payload.effectiveDateTime = toIso(sym.effective);
-    if (components.length) payload.component = components;
-    return new Observation(payload);
-  }
-
-  static fromSymptomGrade({ assessment }) {
-    const grade = assessment.grade;
-    const gradeId = `${assessment.assessmentId}-grade`;
-    const extensions = [];
-    if (grade.confidence !== null) extensions.push(extension('grade-confidence', { valueString: grade.confidence }));
-    if (grade.possibleRange !== null) extensions.push(extension('grade-range', { valueString: `${grade.possibleRange[0]}-${grade.possibleRange[1]}` }));
-    if (grade.reasoning) extensions.push(extension('grade-reasoning', { valueString: grade.reasoning }));
-    if (assessment.gradeVerification) extensions.push(extension('grade-verification', { valueString: assessment.gradeVerification }));
-    if (assessment.gradeThresholdClause) extensions.push(extension('grade-threshold-clause', { valueString: assessment.gradeThresholdClause }));
-    const payload = {
-      resourceType: 'Observation',
-      id: fhirId(gradeId),
-      identifier: [identifier(SYMPTOM_GRADE_SLUG, gradeId)],
-      status: 'final',
-      category: [observationCategory('survey')],
-      code: codeableConcept('CTCAE severity grade'),
-      subject: patientReference(assessment.patientId),
-      performer: [patientReference(assessment.patientId)],
-      effectiveDateTime: toIso(assessment.performedAt),
-    };
-    if (grade.bestEstimate !== null) payload.valueInteger = grade.bestEstimate;
-    if (extensions.length) payload.extension = extensions;
-    return new Observation(payload);
-  }
-
-  static fromResultObservation({ patientId, obsId, code, value, unit, category, effective, now, slug }) {
-    const payload = {
-      resourceType: 'Observation',
-      id: fhirId(obsId),
-      identifier: [identifier(slug, obsId)],
-      status: 'final',
-      category: [observationCategory(category || 'laboratory')],
-      code: codeableConcept(code),
-      subject: patientReference(patientId),
-      effectiveDateTime: effective || now,
-      issued: now,
-    };
-    if (typeof value === 'number') {
-      if (Number.isFinite(value)) payload.valueQuantity = unit ? { value, unit } : { value };
-    } else if (value !== null && value !== undefined && value !== '') {
-      payload.valueString = String(value);
-    }
-    return new Observation(payload);
-  }
 }
 
 function observationCategory(code) {

package/lib/fhir/resources/Procedure.js

@@ -1,43 +1,11 @@
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const {
-  identifier,
-  patientReference,
-  reference,
-  codeableConcept,
-  notes,
-  toIso,
-} = require('../helpers/elementHelper');
-const {
-  INTERVENTION_SLUG,
-  INTERVENTION_KIND_SLUG,
-  INTERVENTION_OUTCOME_SLUG,
-} = require('../constants/projectionSlugs');
-const { interventionExtensions } = require('./interventionExtensions');
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference } = require('../helpers/elementHelper');
 
 class Procedure {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromIntervention({ intervention }) {
-    const payload = {
-      resourceType: 'Procedure',
-      id: fhirId(intervention.interventionId),
-      identifier: [identifier(INTERVENTION_SLUG, intervention.interventionId)],
-      status: intervention.outcome === 'pending' ? 'in-progress' : 'completed',
-      code: codeableConcept(intervention.interventionLabel),
-      subject: patientReference(intervention.patientId),
-      reason: [{ reference: reference('Condition', intervention.caseId) }],
-      occurrenceDateTime: toIso(intervention.deliveredAt),
-      outcome: codeableConcept(intervention.outcome, { code: intervention.outcome, system: codeSystemUrl(INTERVENTION_OUTCOME_SLUG) }),
-      category: [codeableConcept(intervention.kind, { code: intervention.kind, system: codeSystemUrl(INTERVENTION_KIND_SLUG) })],
-      extension: interventionExtensions(intervention, { withRecipient: true }),
-    };
-    const note = notes(intervention.rationale, intervention.outcomeNotes);
-    if (note) payload.note = note;
-    return new Procedure(payload);
-  }
-
   static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
     const assertion = fact.assertion;
     const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length

package/lib/fhir/resources/Provenance.js

@@ -1,33 +1,12 @@
 const { getDeviceId, getOrganizationId } = require('../config/fhirConfig');
-const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
-const { extension, reference, codeableConcept, toIso } = require('../helpers/elementHelper');
-
-const CLUSTER_ACTIVITY_CODESYSTEM = 'clinical-activity';
-const CLUSTER_ACTIVITY_CODES = {
-  opened: 'cluster-hypothesis-opened',
-  updated: 'cluster-hypothesis-updated',
-  dissolved: 'cluster-hypothesis-dissolved',
-};
+const { fhirId } = require('../helpers/fhirHelper');
+const { extension, reference, codeableConcept } = require('../helpers/elementHelper');
 
 class Provenance {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromClusterImpression({ clusterId, turnId, action, recordedAt, transitionReason }) {
-    const activityCode = CLUSTER_ACTIVITY_CODES[action] || 'cluster-hypothesis';
-    const payload = {
-      resourceType: 'Provenance',
-      id: fhirId(`${clusterId}-prov-${turnId}-${action}`),
-      target: [{ reference: `ClinicalImpression/${fhirId(clusterId)}` }],
-      recorded: toIso(recordedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityCode, { code: activityCode, system: codeSystemUrl(CLUSTER_ACTIVITY_CODESYSTEM) }),
-    };
-    if (transitionReason) payload.extension = [extension('transition-reason', { valueString: transitionReason })];
-    return new Provenance(payload);
-  }
-
   static fromMentionProjection({ target, provenance, activityText }) {
     const payload = {
       resourceType: 'Provenance',
@@ -44,76 +23,6 @@ class Provenance {
     };
     return new Provenance(payload);
   }
-
-  static fromDispatchedEscalation({ target, recordedAt, activityText }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(`${target.id}-prov`),
-      target: [{ reference: `${target.resourceType}/${target.id}` }],
-      recorded: toIso(recordedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-    });
-  }
-
-  static fromRoutingDecision({ provenanceId, targetRefs, provenance, activityText }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(provenanceId),
-      target: targetRefs,
-      recorded: toIso(provenance.recordedAt),
-      agent: [{ who: reference('Device', provenance.agentDevice), onBehalfOf: reference('Organization', provenance.onBehalfOf) }],
-      activity: codeableConcept(activityText),
-    });
-  }
-
-  static fromSymptomCase({ provenanceId, targetRefs, recordedAt, activityText }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(provenanceId),
-      target: targetRefs,
-      recorded: toIso(recordedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-    });
-  }
-
-  static fromPatientRisk({ assessment }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(`${assessment.assessmentId}-prov`),
-      target: [{ reference: `RiskAssessment/${fhirId(assessment.assessmentId)}` }],
-      recorded: toIso(assessment.assessedAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept('patient-risk-assessment'),
-    });
-  }
-
-  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',
-      id: fhirId(provenanceId),
-      target: targetIds.map((id) => ({ reference: `Observation/${fhirId(id)}` })),
-      recorded: now,
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept(activityText),
-    });
-  }
 }
 
 module.exports = { Provenance };

package/lib/fhir/services/fhirService.js

@@ -15,11 +15,11 @@ function project(items) {
   return registry.project(items);
 }
 
-async function storeResources(resources, { store = null, merge = null } = {}) {
+async function storeResources(resources, { store = null } = {}) {
   const resourceStore = store || getFhirStore();
   const stored = [];
   for (const resource of [resources].flat(Infinity).filter((entry) => entry && entry.resourceType)) {
-    stored.push(await resourceStore.upsert(resource, { merge }));
+    stored.push(await resourceStore.upsert(resource));
   }
   return { stored };
 }

package/lib/helpers/twilioHelper.js

@@ -121,18 +121,10 @@ const ensureWhatsAppFormat = (code) => {
   return trimmed;
 };
 
-const stripWhatsAppFormat = (code) => {
-  const raw = String(code).trim();
-  const unprefixed = raw.startsWith('whatsapp:') ? raw.slice('whatsapp:'.length) : raw;
-  const beforeAt = unprefixed.includes('@') ? unprefixed.slice(0, unprefixed.indexOf('@')) : unprefixed;
-  return beforeAt.replace(/^\+/, '');
-};
-
 module.exports = {
   convertTwilioToInternalFormat,
   downloadMediaFromTwilio,
   getMediaTypeFromContentType,
   extractTitle,
-  ensureWhatsAppFormat,
-  stripWhatsAppFormat
+  ensureWhatsAppFormat
 };

package/lib/index.d.ts

@@ -416,20 +416,6 @@ declare module '@peopl-health/nexus' {
   export function createQueueAdapter(type: 'local' | 'redis' | string, config?: any): QueueAdapter;
   export function registerQueueAdapter(name: string, AdapterClass: typeof QueueAdapter): void;
 
-  // Workflows
-  export interface Workflow {
-    kind: string;
-    dedupeKey: (trigger: any) => string;
-    prepare: (trigger: any) => Promise<any>;
-  }
-
-  export interface WorkflowRunner {
-    register(workflow: Workflow): Promise<Workflow>;
-    enqueue(kind: string, trigger: any, options?: QueueJobOptions): Promise<string>;
-  }
-
-  export function createWorkflowRunner(options: { queueAdapter: QueueAdapter }): WorkflowRunner;
-
   // Memory System
   export interface PatientMemoryDocument {
     _id: any;
@@ -631,8 +617,6 @@ declare module '@peopl-health/nexus' {
     prompt?: string | null;
     preset?: string | null;
     response_id?: string | null;
-    turnId?: string | null;
-    traceId?: string | null;
     run?: any;
     predictionTimeMs?: number;
     retries?: number;

package/lib/index.js

@@ -16,7 +16,6 @@ const {
   DefaultMemoryManager,
   EnhancedMemoryManager,
   initialize: initializeClinical,
-  registerClinicalTools,
 } = require('./clinical');
 const { initialize: initializeFhir } = require('./fhir');
 const { logger } = require('./utils/logger');
@@ -27,7 +26,6 @@ const { BaileysProvider } = require('./adapters/BaileysProvider');
 const { setPreprocessingHandler, hasPreprocessingHandler, invokePreprocessingHandler } = require('./services/preprocessingService');
 const { requestIdMiddleware, getRequestId } = require('./middleware/requestId');
 const { QueueAdapter, LocalQueueAdapter, RedisQueueAdapter, createQueueAdapter, registerQueueAdapter } = require('./queue');
-const { createWorkflowRunner } = require('./core/workflowRunner');
 const routes = require('./routes');
 const { resetAll } = require('./config/lifecycle');
 const { EvalProvider } = require('./eval/EvalProvider');
@@ -159,12 +157,6 @@ class Nexus {
       logger.warn('[Nexus] clinical init skipped', { error: e?.message || e });
     }
 
-    try {
-      registerClinicalTools();
-    } catch (e) {
-      logger.warn('Warning: failed to register clinical tools:', e?.message || e);
-    }
-
     this.isInitialized = true;
   }
 
@@ -215,7 +207,6 @@ class Nexus {
 }
 
 module.exports = {
-  createWorkflowRunner,
   Nexus,
   TwilioProvider,
   BaileysProvider,

package/lib/models/messageModel.js

@@ -78,8 +78,6 @@ const messageSchema = new mongoose.Schema({
   prompt: { type: Object, default: null },
   preset: { type: Object, default: null },
   response_id: { type: String, default: null },
-  turnId: { type: String },
-  traceId: { type: String },
   triggeredBy: { type: String, default: null }
 }, { timestamps: true });
 
@@ -97,10 +95,6 @@ messageSchema.index({ createdAt: -1 }, { name: 'global_sort_idx' });
 
 messageSchema.index({ message_id: 1 }, { name: 'message_id_idx', sparse: true });
 
-messageSchema.index({ turnId: 1 }, { name: 'turn_id_idx', sparse: true });
-
-messageSchema.index({ traceId: 1 }, { name: 'trace_id_idx', sparse: true });
-
 messageSchema.index({ triggeredBy: 1, createdAt: -1 }, { name: 'triggered_by_idx', sparse: true });
 
 const Message = mongoose.model('Message', messageSchema);

package/lib/routes/index.js

@@ -90,14 +90,6 @@ const presetRouteDefinitions = {
   'POST /cache/clear': 'clearPresetCacheController'
 };
 
-const cohortRouteDefinitions = {
-  'POST /cache/clear': 'clearCohortCacheController'
-};
-
-const traceRouteDefinitions = {
-  'GET /:traceId': 'getTraceController'
-};
-
 const createRouter = (routeDefinitions, controllers) => {
   const router = express.Router();
   
@@ -123,7 +115,6 @@ const messageController = require('../controllers/messageController');
 const messageStatusController = require('../controllers/messageStatusController');
 const patientController = require('../controllers/patientController');
 const presetController = require('../controllers/presetController');
-const cohortController = require('../controllers/cohortController');
 const qualityMessageController = require('../controllers/qualityMessageController');
 const templateController = require('../controllers/templateController');
 const templateFlowController = require('../controllers/templateFlowController');
@@ -131,7 +122,6 @@ const flowDataExchangeController = require('../controllers/flowDataExchangeContr
 const uploadController = require('../controllers/uploadController');
 const dashboardController = require('../controllers/dashboardController');
 const prescriptionController = require('../controllers/prescriptionController');
-const traceController = require('../controllers/traceController');
 
 const builtInControllers = {
   // Assistant controllers
@@ -191,9 +181,6 @@ const builtInControllers = {
   // Preset controllers
   clearPresetCacheController: presetController.clearPresetCacheController,
 
-  // Cohort controllers
-  clearCohortCacheController: cohortController.clearCohortCacheController,
-
   // Template controllers
   createTemplate: templateController.createTemplate,
   listTemplates: templateController.listTemplates,
@@ -221,10 +208,7 @@ const builtInControllers = {
   getDashboardController: dashboardController.getDashboardController,
   getDashboardStatsControllerById: dashboardController.getDashboardStatsControllerById,
   getDashboardTrendController: dashboardController.getDashboardTrendController,
-  updateDashboardControllerById: dashboardController.updateDashboardControllerById,
-
-  // Trace controllers
-  getTraceController: traceController.getTraceController
+  updateDashboardControllerById: dashboardController.updateDashboardControllerById
 };
 
 const setupDefaultRoutes = (app) => {
@@ -239,11 +223,9 @@ const setupDefaultRoutes = (app) => {
   app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
   app.use('/api/patient', createRouter(patientRouteDefinitions, builtInControllers));
   app.use('/api/preset', createRouter(presetRouteDefinitions, builtInControllers));
-  app.use('/api/cohort', createRouter(cohortRouteDefinitions, builtInControllers));
   app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
   app.use('/api/prescription', createRouter(prescriptionRouteDefinitions, builtInControllers));
   app.use('/api/dashboard', createRouter(dashboardRouteDefinitions, builtInControllers));
-  app.use('/api/trace', createRouter(traceRouteDefinitions, builtInControllers));
 };
 
 module.exports = {
@@ -253,11 +235,9 @@ module.exports = {
   messageRoutes: messageRouteDefinitions,
   patientRoutes: patientRouteDefinitions,
   presetRoutes: presetRouteDefinitions,
-  cohortRoutes: cohortRouteDefinitions,
   templateRoutes: templateRouteDefinitions,
   prescriptionRoutes: prescriptionRouteDefinitions,
   dashboardRoutes: dashboardRouteDefinitions,
-  traceRoutes: traceRouteDefinitions,
 
   createRouter,
   setupDefaultRoutes

package/lib/services/airtableService.js

@@ -78,8 +78,7 @@ async function getRecords(baseID, tableName) {
 
 async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view', fields) {
   try {
-    const selectOptions = { filterByFormula: filter };
-    if (view) selectOptions.view = view;
+    const selectOptions = { filterByFormula: filter, view };
     if (fields && fields.length) selectOptions.fields = fields;
     return await withAirtableRetry(
       () => collectRecords(getBase(baseID)(tableName).select(selectOptions)),

package/lib/shared/dtos/ContingencySafetyNet.js

@@ -4,13 +4,10 @@ const { BaseDto } = require('./BaseDto');
 
 const dateTime = z.iso.datetime({ offset: true });
 
-const ESCALATION_PRIORITIES = ['critical', 'high', 'medium', 'low', 'routine', 'urgent', 'asap', 'stat'];
-const ACTIVE_CARE_PLAN_STATUSES = ['armed', 'fired_reminder', 'fired_team'];
-
 const escalationStepSchema = z.strictObject({
   recipient: z.enum(['patient', 'care_team']),
   message: z.string(),
-  priority: z.enum(ESCALATION_PRIORITIES).nullable().default(null),
+  priority: z.enum(['critical', 'high', 'medium', 'low', 'routine', 'urgent', 'asap', 'stat']).nullable().default(null),
   actionRequested: z.string().nullable().default(null),
   firesAfterSilenceMinutes: z.number().int().nonnegative().nullable().default(null),
 });
@@ -24,7 +21,7 @@ const carePlanSchema = z.strictObject({
   awaitingCharacterization: z.string(),
   whyThisMatters: z.string(),
   creationReasoning: z.string(),
-  status: z.enum([...ACTIVE_CARE_PLAN_STATUSES, 'auto_resolved', 'cancelled']).default('armed'),
+  status: z.enum(['armed', 'fired_reminder', 'fired_team', 'auto_resolved', 'cancelled']).default('armed'),
   createdAt: dateTime,
   resolvedAt: dateTime.nullable().default(null),
   resolvedReason: z.string().nullable().default(null),
@@ -47,8 +44,4 @@ class ContingencySafetyNet extends BaseDto {}
 
 ContingencySafetyNet.schema = schema;
 
-module.exports = {
-  ContingencySafetyNet,
-  ESCALATION_PRIORITIES,
-  ACTIVE_CARE_PLAN_STATUSES,
-};
+module.exports = { ContingencySafetyNet };

package/lib/shared/dtos/DispatchedEscalation.js

@@ -16,10 +16,15 @@ const baseFields = {
 
 const notifyEscalation = z.strictObject({
   ...baseFields,
-  kind: z.enum(['page_navigator', 'page_oncologist', 'notify_911_guidance', 'schedule_followup']),
+  kind: z.enum(['page_navigator', 'page_oncologist', 'notify_911_guidance']),
   recipient: z.string().nullable().default(null),
   requiresAck: z.boolean().default(false),
-  fireAt: dateTime.nullable().default(null),
+});
+
+const followupEscalation = z.strictObject({
+  ...baseFields,
+  kind: z.literal('schedule_followup'),
+  fireAt: dateTime,
   followupPurpose: z.string().nullable().default(null),
 });
 
@@ -30,7 +35,7 @@ const ticketEscalation = z.strictObject({
   slaMinutes: z.number().int().nullable().default(null),
 });
 
-const schema = z.discriminatedUnion('kind', [notifyEscalation, ticketEscalation]);
+const schema = z.discriminatedUnion('kind', [notifyEscalation, followupEscalation, ticketEscalation]);
 
 class DispatchedEscalation extends BaseDto {}
 

package/lib/shared/dtos/Reminder.js

@@ -21,8 +21,8 @@ const schema = z.strictObject({
   .refine((d) => (d.status === 'cancelled') === (d.cancelReason !== null), {
     message: 'cancelReason is set iff status is cancelled',
   })
-  .refine((d) => d.recipientKind !== 'related_person' || (typeof d.recipientRefId === 'string' && d.recipientRefId.length > 0), {
-    message: 'a related_person recipient requires a non-empty recipientRefId',
+  .refine((d) => d.recipientKind !== 'related_person' || d.recipientRefId !== null, {
+    message: 'a related_person recipient requires recipientRefId',
   });
 
 class Reminder extends BaseDto {}

package/lib/storage/MongoStorage.js

@@ -123,8 +123,6 @@ class MongoStorage {
       prompt: messageData.prompt || null,
       preset: messageData.preset || null,
       response_id: messageData.response_id || null,
-      turnId: messageData.turnId || undefined,
-      traceId: messageData.traceId || undefined,
       statusInfo: messageData.statusInfo,
       clinical_context: messageData.clinicalContext || null,
       triggeredBy: messageData.triggeredBy || null

package/package.json

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

package/lib/clinical/config/cohortConfig.js

@@ -1,68 +0,0 @@
-const { Config_ID } = require('../../config/airtableConfig');
-const runtimeConfig = require('../../config/runtimeConfig');
-
-const { stripWhatsAppFormat } = require('../../helpers/twilioHelper');
-const { getRecordByFilter } = require('../../services/airtableService');
-
-const { logger } = require('../../utils/logger');
-const MapCache = require('../../utils/MapCache');
-
-const COHORT_TABLE = 'clinical_cohort';
-const CACHE_TTL = 5 * 60 * 1000;
-const CACHE_KEY = 'cohort';
-const LANES = ['preset', 'bridge', 'fhir_write', 'fhir_read'];
-
-const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
-let inFlightRead = null;
-let generation = 0;
-
-function isCohortEnabled() {
-  return runtimeConfig.get('COHORT_ENABLED', 'false') === 'true';
-}
-
-async function readRegistry() {
-  const records = await getRecordByFilter(Config_ID, COHORT_TABLE, 'TRUE()');
-  if (!records) throw new Error('cohort registry could not be read from the Config base');
-
-  const lanesByCode = new Map();
-  for (const row of records) {
-    if (!row.whatsapp_id || row.status !== 'active') continue;
-    lanesByCode.set(stripWhatsAppFormat(row.whatsapp_id), new Set(row.lanes || []));
-  }
-  return lanesByCode;
-}
-
-async function load() {
-  const cached = cache.get(CACHE_KEY);
-  if (cached) return cached;
-  if (!inFlightRead) {
-    const readGeneration = generation;
-    inFlightRead = readRegistry()
-      .then((lanesByCode) => {
-        if (readGeneration === generation) cache.set(CACHE_KEY, lanesByCode);
-        return lanesByCode;
-      })
-      .finally(() => { inFlightRead = null; });
-  }
-  return inFlightRead;
-}
-
-async function isInCohort(code, lane) {
-  if (!LANES.includes(lane)) throw new Error(`unknown cohort lane: ${lane}`);
-  if (!code || !isCohortEnabled()) return false;
-  try {
-    const lanes = (await load()).get(stripWhatsAppFormat(code));
-    return Boolean(lanes && lanes.has(lane));
-  } catch (error) {
-    logger.error('[cohortConfig] registry read failed; gate fails closed', { code, lane, error: error.message });
-    return false;
-  }
-}
-
-function clearCohortCache() {
-  generation += 1;
-  cache.clear();
-  inFlightRead = null;
-}
-
-module.exports = { isInCohort, clearCohortCache };

package/lib/clinical/config/composerConfig.js

@@ -1,42 +0,0 @@
-const { Config_ID } = require('../../config/airtableConfig');
-
-const { getRecordByFilter } = require('../../services/airtableService');
-
-const { logger } = require('../../utils/logger');
-const MapCache = require('../../utils/MapCache');
-
-const CONFIG_TABLE = 'registry';
-const CACHE_TTL = 5 * 60 * 1000;
-const CACHE_KEY = 'composerConfig';
-
-const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
-
-async function load() {
-  const cached = cache.get(CACHE_KEY);
-  if (cached) return cached;
-
-  const records = await getRecordByFilter(Config_ID, CONFIG_TABLE, 'TRUE()');
-  if (!records) {
-    logger.warn('[composerConfig] could not read composer prompt blocks; composer will fall back to legacy render');
-    const fallback = { skillPrompt: '', constitution: '' };
-    cache.set(CACHE_KEY, fallback);
-    return fallback;
-  }
-  const byKey = Object.fromEntries(records.map((r) => [r.config, r.value]));
-  const config = {
-    skillPrompt: byKey.COMPOSER_SKILL_PROMPT || '',
-    constitution: byKey.COMPOSER_CONSTITUTION || '',
-  };
-  cache.set(CACHE_KEY, config);
-  return config;
-}
-
-async function getPromptBlocks() {
-  const { skillPrompt, constitution } = await load();
-  if (!skillPrompt || !constitution) return null;
-  return { skillPrompt, constitution };
-}
-
-module.exports = {
-  getPromptBlocks,
-};