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

package/lib/clinical/services/shadowService.js

@@ -15,28 +15,22 @@ async function runShadowTurn({
   resolveAssistant,
   executeLLM,
 }) {
-  if (!shouldContinue()) {
-    logger.debug('[shadow] superseded pre-run', { code: thread?.code, runId });
-    return null;
-  }
+  if (!shouldContinue()) return null;
   if (!runId) throw new Error('runShadowTurn requires a runId');
 
   const code = thread.code;
-  logger.debug('[shadow] start', { code, runId, sessionId });
   const shadowThread = cloneShadowThread(thread);
   const shadowAssistant = resolveAssistant(shadowThread);
 
-  const context = new ToolRuntimeContext({ patientCode: code, turnId: runId, sessionId });
+  const context = new ToolRuntimeContext({ patientCode: code, turnId: runId, sessionId, thread: shadowThread });
 
   const runOptions = {
     toolRuntimeContext: context, shadow: true, shouldContinue, additionalInstructions,
   };
 
-  const startedAt = Date.now();
   const result = await runInShadowScope(() =>
     executeLLM(shadowThread, shadowAssistant, runOptions, message),
   );
-  logger.debug('[shadow] done', { code, runId, completed: !!result?.completed, steps: context.trace?.steps?.length || 0, durationMs: Date.now() - startedAt });
 
   return { turnId: runId, context, result };
 }
@@ -46,10 +40,7 @@ function forkShadowTurn({
 }) {
   Promise.resolve()
     .then(() => {
-      if (!isShadowEnabled()) {
-        logger.debug('[shadow] disabled', { code: thread?.code });
-        return null;
-      }
+      if (!isShadowEnabled()) return null;
       return runShadowTurn({
         thread,
         message,

package/lib/clinical/stores/CtcaeCatalog.js

@@ -32,26 +32,6 @@ class CtcaeCatalog {
     return grades && Object.keys(grades).length ? grades : null;
   }
 
-  lookupEntry(ctcaeTerm) {
-    this._assertLoaded();
-    const key = (ctcaeTerm || '').trim().toLowerCase();
-    const symptom = key ? this.symptomsByTerm.get(key) : null;
-    if (symptom) {
-      return {
-        entry: {
-          ctcae_term: symptom.ctcaeTerm,
-          spanish_label: symptom.spanishLabel,
-          patient_phrases_validated: symptom.patientPhrasesValidated,
-          grades: symptom.grades,
-        },
-        found: true,
-      };
-    }
-    const nearestTerms = [...this.symptomsByTerm.keys()]
-      .filter((k) => key && (key.includes(k) || k.includes(key) || k.split('_')[0] === key.split('_')[0]));
-    return { entry: {}, found: false, nearest_terms: nearestTerms };
-  }
-
   _assertLoaded() {
     if (this.symptomsByTerm === null) throw new Error('ctcae catalog not loaded: call initialize() at startup');
   }

package/lib/config/airtableConfig.js

@@ -13,7 +13,6 @@ const Logging_ID = runtimeConfig.get('AIRTABLE_LOGGING_ID') || 'appQ7YhzfebRDbSP
 const Monitoreo_ID = runtimeConfig.get('AIRTABLE_MONITOREO_ID') || 'appdvraKSdp0XVn5n';
 const Programa_Juntas_ID = runtimeConfig.get('AIRTABLE_PROGRAMA_JUNTAS_ID') || 'appKFWzkcDEWlrXBE';
 const Symptoms_ID = runtimeConfig.get('AIRTABLE_SYMPTOMS_ID') || 'appQRhZlQ9tMfYZWJ';
-const Ctcae_ID = runtimeConfig.get('AIRTABLE_CTCAE_ID') || 'appEr4ATOs0Xc8ymP';
 const Follow_Up_ID = runtimeConfig.get('AIRTABLE_FOLLOW_UP_ID') || 'appBjKw1Ub0KkbZf0';
 const Webinars_Leads_ID = runtimeConfig.get('AIRTABLE_WEBINARS_LEADS_ID') || 'appzjpVXTI0TgqGPq';
 const Product_ID = runtimeConfig.get('AIRTABLE_PRODUCT_ID') || 'appu2YDW2pKDYLL5H';
@@ -33,7 +32,6 @@ const BASE_MAP = {
   monitoreo: Monitoreo_ID,
   programa: Programa_Juntas_ID,
   symptoms: Symptoms_ID,
-  ctcae: Ctcae_ID,
   followup: Follow_Up_ID,
   webinars: Webinars_Leads_ID,
   product: Product_ID,
@@ -51,7 +49,6 @@ module.exports = {
   Monitoreo_ID,
   Programa_Juntas_ID,
   Symptoms_ID,
-  Ctcae_ID,
   Follow_Up_ID,
   Webinars_Leads_ID,
   Product_ID,

package/lib/core/BatchingManager.js

@@ -53,10 +53,10 @@ class BatchingManager {
   }
 
   async enqueueProcessing(chatId, processingFn, sendResponseFn) {
-    await this._runWithLock(chatId, processingFn, sendResponseFn, { rethrow: true });
+    await this._runWithLock(chatId, processingFn, sendResponseFn);
   }
 
-  async _runWithLock(chatId, processingFn, sendResponseFn, { rethrow = false } = {}) {
+  async _runWithLock(chatId, processingFn, sendResponseFn) {
     const prev = this.chatQueues.get(chatId) || Promise.resolve();
     let resolveGate;
     const gate = new Promise(r => { resolveGate = r; });
@@ -74,16 +74,9 @@ class BatchingManager {
       const result = await processingFn(runId);
       if (this._checkAbandoned(runId)) return;
 
-      if (sendResponseFn && result) {
-        try {
-          await sendResponseFn(result);
-        } catch (error) {
-          logger.error('[BatchingManager] Error sending response', { chatId, error: error.message });
-        }
-      }
+      if (sendResponseFn && result) await sendResponseFn(result);
     } catch (error) {
       logger.error('[BatchingManager] Error processing messages', { chatId, error: error.message });
-      if (rethrow) throw error;
     } finally {
       if (this.activeRequests.get(chatId) === runId) {
         this._clearProcessingState(chatId);

package/lib/core/NexusMessaging.js

@@ -525,7 +525,7 @@ class NexusMessaging {
       body: instruction,
       messageId: `instruction_${Date.now()}_${Math.random().toString(36).substring(7)}`,
       fromMe: true,
-      processed: false,
+      processed: true,
       origin: 'instruction',
       raw: { role },
       triggeredBy: triggeredBy || null,
@@ -535,27 +535,17 @@ class NexusMessaging {
     const result = await this.phiProcessor.inData(
       messageData,
       this._saveMessageFn,
-      async ({ body, _id }) => {
-        const runResult = await this._executeWithPipeline(code, 'instruction', 'queue',
-          async (preProcessResult, _shouldContinue, runId) => this.assistantProcessor.process({
-            code,
-            runOptions: {
-              prePromptResult: preProcessResult,
-              additionalInstructions: body,
-              toolChoice: 'none',
-              runId,
-            }
-          }),
-        );
-        if (_id) {
-          try {
-            await updateMessage({ _id }, { $set: { processed: true } });
-          } catch (err) {
-            logger.error('[processInstruction] Could not mark instruction processed', { error: err.message, code });
+      ({ body }) => this._executeWithPipeline(code, 'instruction', 'queue',
+        async (preProcessResult, _shouldContinue, runId) => this.assistantProcessor.process({
+          code,
+          runOptions: {
+            prePromptResult: preProcessResult,
+            additionalInstructions: body,
+            toolChoice: 'none',
+            runId,
           }
-        }
-        return runResult;
-      },
+        }),
+      ),
     );
 
     return result?.output || null;
@@ -565,15 +555,7 @@ class NexusMessaging {
     const thread = await Thread.findOne({ code }).lean();
     if (!thread) return null;
 
-    // Dropped rather than stored: these now emit message:new and would render as an empty bubble.
-    const requestedMessages = Array.isArray(messages) ? messages : [messages];
-    const normalizedMessages = requestedMessages.filter(body => typeof body === 'string' && body.trim());
-    if (normalizedMessages.length !== requestedMessages.length) {
-      logger.warn('[processSystemMessage] Ignoring blank message entries', {
-        code,
-        ignored: requestedMessages.length - normalizedMessages.length,
-      });
-    }
+    const normalizedMessages = Array.isArray(messages) ? messages : [messages];
 
     for (let i = 0; i < normalizedMessages.length; i++) {
       try {
@@ -587,7 +569,7 @@ class NexusMessaging {
           origin: 'system',
           raw: { role },
           triggeredBy: triggeredBy || null,
-          // No `silent`: it suppresses the message:new event an interface renders from. Instructions keep it.
+          silent: true,
         };
         await this.phiProcessor.inData(messageData, this._saveMessageFn, () => {});
       } catch (err) {

package/lib/eval/EvalProvider.js

@@ -163,9 +163,8 @@ class EvalProvider {
             devContent += `\n\nYou only have access to these tools: ${activeToolSchemas.map(s => s.function?.name).join(', ')}. Do not call or reference any tools not listed here.`;
           }
         }
-      } catch (error) {
-        toolSchemas = [];
-        logger.error('[NexusEvalProvider] Failed to resolve assistant — running with no tools', { assistantId, error: error.message });
+      } catch {
+        logger.warn('[NexusEvalProvider] Failed to resolve assistant', { assistantId });
       }
     }
 

package/lib/fhir/config/fhirConfig.js

@@ -2,32 +2,12 @@ const { Config_ID } = require('../../config/airtableConfig');
 
 const { getRecordByFilter } = require('../../services/airtableService');
 
-const { safeParse, safeParseArray } = require('../../utils/jsonUtils');
+const { safeParse } = require('../../utils/jsonUtils');
 
 const FHIR_CONFIG_TABLE = 'fhir';
-const REQUIRED_KEYS = [
-  'IDENT_BASE',
-  'EXT_BASE',
-  'CODESYSTEM_BASE',
-  'SYSTEMS',
-  'SUSPECTED_GRADE_DISPLAYS',
-  'QUESTIONNAIRE_CANONICAL_URL',
-  'PROCTCAE_VERSION',
-  'DEVICE_ID',
-  'ORGANIZATION_ID',
-];
+const REQUIRED_KEYS = ['IDENT_BASE', 'EXT_BASE', 'SYSTEMS', 'DEVICE_ID', 'ORGANIZATION_ID'];
 
-const state = {
-  identBase: null,
-  extBase: null,
-  codesystemBase: null,
-  systems: null,
-  suspectedGradeDisplays: null,
-  questionnaireCanonicalUrl: null,
-  proctcaeVersion: null,
-  deviceId: null,
-  organizationId: null,
-};
+const state = { identBase: null, extBase: null, systems: null, deviceId: null, organizationId: null };
 
 async function initialize() {
   const records = await getRecordByFilter(Config_ID, FHIR_CONFIG_TABLE, 'TRUE()');
@@ -40,16 +20,9 @@ async function initialize() {
   const systems = safeParse(byKey.SYSTEMS, null);
   if (!systems) throw new Error('fhir config SYSTEMS is not valid JSON');
 
-  const suspectedGradeDisplays = safeParseArray(byKey.SUSPECTED_GRADE_DISPLAYS, null);
-  if (!suspectedGradeDisplays) throw new Error('fhir config SUSPECTED_GRADE_DISPLAYS is not a JSON array');
-
   state.identBase = byKey.IDENT_BASE;
   state.extBase = byKey.EXT_BASE;
-  state.codesystemBase = byKey.CODESYSTEM_BASE;
   state.systems = systems;
-  state.suspectedGradeDisplays = suspectedGradeDisplays;
-  state.questionnaireCanonicalUrl = byKey.QUESTIONNAIRE_CANONICAL_URL;
-  state.proctcaeVersion = byKey.PROCTCAE_VERSION;
   state.deviceId = byKey.DEVICE_ID;
   state.organizationId = byKey.ORGANIZATION_ID;
 }
@@ -62,11 +35,7 @@ module.exports = {
   initialize,
   getIdentBase: () => { assertLoaded(); return state.identBase; },
   getExtBase: () => { assertLoaded(); return state.extBase; },
-  getCodesystemBase: () => { assertLoaded(); return state.codesystemBase; },
   getSystems: () => { assertLoaded(); return state.systems; },
-  getSuspectedGradeDisplays: () => { assertLoaded(); return state.suspectedGradeDisplays; },
-  getQuestionnaireCanonicalUrl: () => { assertLoaded(); return state.questionnaireCanonicalUrl; },
-  getProctcaeVersion: () => { assertLoaded(); return state.proctcaeVersion; },
   getDeviceId: () => { assertLoaded(); return state.deviceId; },
   getOrganizationId: () => { assertLoaded(); return state.organizationId; },
 };

package/lib/fhir/constants/projectionSlugs.js

@@ -1,43 +1,3 @@
 const MENTION_SLUG = 'clinical-mention';
-const RESULT_SLUG = 'patient-reported-result';
-const ESCALATION_SLUG = 'dispatched-escalation';
-const ESCALATION_KIND_SLUG = 'escalation-kind';
-const REMINDER_SLUG = 'reminder';
-const REMINDER_KIND_SLUG = 'reminder-kind';
-const COMMUNICATION_CHANNEL_SLUG = 'communication-channel';
-const SYMPTOM_CASE_SLUG = 'symptom-condition';
-const SYMPTOM_ASSESSMENT_SLUG = 'symptom-assessment';
-const SYMPTOM_GRADE_SLUG = 'symptom-grade';
-const PATIENT_RISK_SLUG = 'patient-risk-assessment';
-const CONTINGENCY_PLAN_SLUG = 'contingency-plan';
-const CONTINGENCY_STEP_SLUG = 'contingency-step';
-const INTERVENTION_SLUG = 'intervention';
-const INTERVENTION_OUTCOME_SLUG = 'intervention-outcome';
-const INTERVENTION_KIND_SLUG = 'intervention-kind';
-const CLUSTER_IMPRESSION_SLUG = 'cluster-impression';
-const CLUSTER_LABEL_SLUG = 'cluster-label';
-const ROUTING_ASSESSMENT_SLUG = 'routing-assessment';
-const ROUTING_DISPOSITION_SLUG = 'routing-disposition';
 
-module.exports = {
-  MENTION_SLUG,
-  RESULT_SLUG,
-  ESCALATION_SLUG,
-  ESCALATION_KIND_SLUG,
-  REMINDER_SLUG,
-  REMINDER_KIND_SLUG,
-  COMMUNICATION_CHANNEL_SLUG,
-  SYMPTOM_CASE_SLUG,
-  SYMPTOM_ASSESSMENT_SLUG,
-  SYMPTOM_GRADE_SLUG,
-  PATIENT_RISK_SLUG,
-  CONTINGENCY_PLAN_SLUG,
-  CONTINGENCY_STEP_SLUG,
-  INTERVENTION_SLUG,
-  INTERVENTION_OUTCOME_SLUG,
-  INTERVENTION_KIND_SLUG,
-  CLUSTER_IMPRESSION_SLUG,
-  CLUSTER_LABEL_SLUG,
-  ROUTING_ASSESSMENT_SLUG,
-  ROUTING_DISPOSITION_SLUG,
-};
+module.exports = { MENTION_SLUG };

package/lib/fhir/helpers/elementHelper.js

@@ -12,11 +12,6 @@ function patientReference(patientId) {
   return reference('Patient', patientId);
 }
 
-function recipientReference({ patientId, recipientKind = 'patient', recipientRefId = null }) {
-  if (recipientKind === 'related_person' && recipientRefId) return reference('RelatedPerson', recipientRefId);
-  return reference('Patient', patientId);
-}
-
 function codeableConcept(text, { code = null, system = null, display = null } = {}) {
   const out = { text };
   if (code !== null && system !== null) {
@@ -29,26 +24,10 @@ function extension(name, value) {
   return { url: extensionUrl(name), ...value };
 }
 
-function notes(...texts) {
-  const present = texts.filter(Boolean).map((text) => ({ text }));
-  return present.length ? present : null;
-}
-
-function toIso(value) {
-  if (value instanceof Date) return value.toISOString().replace(/\.000Z$/, 'Z');
-  const s = String(value);
-  if (/\+00:00$/.test(s)) return s.replace(/\+00:00$/, 'Z');
-  if (/(Z|[+-]\d{2}:\d{2})$/.test(s)) return s;
-  return `${s}Z`;
-}
-
 module.exports = {
   identifier,
   reference,
   patientReference,
-  recipientReference,
   codeableConcept,
   extension,
-  notes,
-  toIso,
 };

package/lib/fhir/helpers/fhirHelper.js

@@ -1,17 +1,14 @@
-const { getIdentBase, getExtBase, getCodesystemBase } = require('../config/fhirConfig');
+const { getIdentBase, getExtBase } = require('../config/fhirConfig');
 
 function fhirId(businessId) {
-  const id = String(businessId).replace(/[^A-Za-z0-9.-]/g, '-').slice(0, 64);
-  return id || 'x';
+  return String(businessId).replace(/_/g, '-').replace(/[^A-Za-z0-9.-]/g, '').slice(0, 64);
 }
 
 const identifierSystem = (slug) => `${getIdentBase()}/${slug}`;
 const extensionUrl = (name) => `${getExtBase()}/${name}`;
-const codeSystemUrl = (name) => `${getCodesystemBase()}/${name}`;
 
 module.exports = {
   fhirId,
   identifierSystem,
   extensionUrl,
-  codeSystemUrl,
 };

package/lib/fhir/index.js

@@ -1,14 +1,5 @@
 const { registerProjector, project, storeResources } = require('./services/fhirService');
 const { storeClinicalMentions } = require('./services/clinicalMentionService');
-const { storeResultObservations } = require('./services/resultObservationService');
-const { storeSymptomCase, readSymptomCases } = require('./services/symptomCaseService');
-const { storePatientRisk, readPatientRisk } = require('./services/riskService');
-const { storeContingency, readContingencies } = require('./services/contingencyService');
-const { storeIntervention, readInterventions } = require('./services/interventionService');
-const { storeCluster, readClusters } = require('./services/clusterService');
-const { storeRoutingDecision, readRoutingByTurn } = require('./services/routingService');
-const { storeTriage } = require('./services/triageService');
-const { patientSnapshot } = require('./services/snapshotService');
 const { registerAllProjectors } = require('./projections/registerProjectors');
 const { getFhirStore, ensureFhirIndexes } = require('./stores/fhirStore');
 const fhirConfig = require('./config/fhirConfig');
@@ -25,21 +16,6 @@ module.exports = {
   project,
   storeResources,
   storeClinicalMentions,
-  storeResultObservations,
-  storeSymptomCase,
-  readSymptomCases,
-  storePatientRisk,
-  readPatientRisk,
-  storeContingency,
-  readContingencies,
-  storeIntervention,
-  readInterventions,
-  storeCluster,
-  readClusters,
-  storeRoutingDecision,
-  readRoutingByTurn,
-  storeTriage,
-  patientSnapshot,
   getFhirStore,
   ensureFhirIndexes,
 };

package/lib/fhir/models/envelopeModel.js

@@ -48,14 +48,10 @@ envelopeSchema.statics.deriveIndex = function deriveIndex(resource) {
     resource.date ||
     resource.recorded ||
     resource.recordedDate ||
-    resource.onsetDateTime ||
-    resource.occurrenceDateTime ||
-    resource.sent ||
     resource.start ||
     (resource.effectivePeriod || {}).start ||
     (resource.period || {}).start ||
     (resource.actualPeriod || {}).start ||
-    ((resource.requestedPeriod || [])[0] || {}).start ||
     null;
   return {
     resourceType: resource.resourceType || null,
@@ -123,7 +119,6 @@ function patientReferenceOf(resource) {
   return (
     patientRef(resource.subject) ||
     patientRef(resource.patient) ||
-    patientRef(resource.for) ||
     patientRef(resource.performer) ||
     participantRef()
   );

package/lib/fhir/projections/registerProjectors.js

@@ -1,24 +1,8 @@
 const { registerProjector } = require('../services/fhirService');
 const { projectClinicalMention, PROJECTOR_NAME: MENTION_PROJECTOR_NAME } = require('./clinicalMentionProjection');
-const { projectDispatchedEscalation, PROJECTOR_NAME: ESCALATION_PROJECTOR_NAME } = require('./dispatchedEscalationProjection');
-const { projectReminder, PROJECTOR_NAME: REMINDER_PROJECTOR_NAME } = require('./reminderProjection');
-const { projectSymptomCase, PROJECTOR_NAME: SYMPTOM_CASE_PROJECTOR_NAME } = require('./symptomCaseProjection');
-const { projectPatientRisk, PROJECTOR_NAME: RISK_PROJECTOR_NAME } = require('./riskProjection');
-const { projectContingency, PROJECTOR_NAME: CONTINGENCY_PROJECTOR_NAME } = require('./contingencyProjection');
-const { projectIntervention, PROJECTOR_NAME: INTERVENTION_PROJECTOR_NAME } = require('./interventionProjection');
-const { projectCluster, PROJECTOR_NAME: CLUSTER_PROJECTOR_NAME } = require('./clusterProjection');
-const { projectRoutingDecision, PROJECTOR_NAME: ROUTING_PROJECTOR_NAME } = require('./routingProjection');
 
 const PROJECTORS = [
   { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
-  { name: ESCALATION_PROJECTOR_NAME, project: projectDispatchedEscalation },
-  { name: REMINDER_PROJECTOR_NAME, project: projectReminder },
-  { name: SYMPTOM_CASE_PROJECTOR_NAME, project: projectSymptomCase },
-  { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },
-  { name: CONTINGENCY_PROJECTOR_NAME, project: projectContingency },
-  { name: INTERVENTION_PROJECTOR_NAME, project: projectIntervention },
-  { name: CLUSTER_PROJECTOR_NAME, project: projectCluster },
-  { name: ROUTING_PROJECTOR_NAME, project: projectRoutingDecision },
 ];
 
 function registerAllProjectors() {

package/lib/fhir/resources/Condition.js

@@ -1,95 +1,12 @@
 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 CLINICAL_STATUS_TO_FHIR = {
-  resolved: 'resolved',
-  inactive: 'inactive',
-};
-
-const RESOLUTION_CLOSE_REASONS = new Set([
-  'resolved', 'team_resolved', 'resolved_spontaneously', 'resolved_by_intervention',
-]);
-
-const VALID_VERIFICATION = new Set(['confirmed', 'provisional', 'unconfirmed']);
-
-const PROVENANCE_PARTICIPANT_TYPE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/provenance-participant-type';
-
-function fhirClinicalStatusFor(condition) {
-  const status = condition.clinicalStatus;
-  if (status === 'characterizing' || status === 'monitoring') {
-    return condition.recurrenceCount > 0 ? 'recurrence' : 'active';
-  }
-  if (status === 'closed') {
-    return RESOLUTION_CLOSE_REASONS.has((condition.closeReason || '').trim().toLowerCase()) ? 'resolved' : 'inactive';
-  }
-  return CLINICAL_STATUS_TO_FHIR[status];
-}
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
 
 class Condition {
   constructor(payload) {
     Object.assign(this, payload);
   }
 
-  static fromSymptomCase({ condition, verification, headAssessmentId = null }) {
-    const systems = getSystems();
-    const clinicalStatusCode = fhirClinicalStatusFor(condition);
-    const verificationCode = VALID_VERIFICATION.has(verification) ? verification : 'provisional';
-    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 payload = {
-      resourceType: 'Condition',
-      id: fhirId(condition.conditionId),
-      identifier: [identifier(SYMPTOM_CASE_SLUG, condition.conditionId)],
-      clinicalStatus: codeableConcept(clinicalStatusCode, { code: clinicalStatusCode, system: systems.conditionClinical }),
-      verificationStatus: codeableConcept(verificationCode, { code: verificationCode, system: systems.conditionVerStatus }),
-      category: [
-        codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
-        codeableConcept('PRO-CTCAE patient-reported symptom (agent-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
-      ],
-      code,
-      subject: patientReference(condition.patientId),
-      participant: [{
-        function: codeableConcept('Informant', { code: 'informant', system: PROVENANCE_PARTICIPANT_TYPE_SYSTEM }),
-        actor: patientReference(condition.patientId),
-      }],
-      onsetDateTime: toIso(condition.onsetAt),
-      extension: extensions,
-    };
-    if (condition.abatementAt) {
-      if (clinicalStatusCode === 'resolved') {
-        payload.abatementDateTime = toIso(condition.abatementAt);
-      } else {
-        extensions.push(extension('legacy-abatement', { valueDateTime: toIso(condition.abatementAt) }));
-      }
-    }
-    if (condition.closeReason) {
-      extensions.push(extension('symptom-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.lastTransitionReason) payload.note = [{ text: condition.lastTransitionReason }];
-    const evidence = [
-      ...condition.evidenceEpisodeIds.map((id) => ({ reference: reference('Observation', id) })),
-      ...condition.evidenceMentionIds.map((id) => ({ reference: reference('Observation', id) })),
-    ];
-    if (evidence.length) payload.evidence = evidence;
-    if (headAssessmentId) {
-      payload.stage = [{ assessment: [reference('ClinicalImpression', headAssessmentId)] }];
-    }
-    return new Condition(payload);
-  }
-
   static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
     const assertion = fact.assertion;
     const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
@@ -112,28 +29,6 @@ class Condition {
     if (notes) payload.note = notes;
     return new Condition(payload);
   }
-
-  static fromTriageProjection({ sym, code }) {
-    const caseId = `${sym.patientId}-${sym.term}`;
-    const systems = getSystems();
-    const payload = {
-      resourceType: 'Condition',
-      id: fhirId(`symptom-${caseId}`),
-      identifier: [identifier('symptom-condition', caseId)],
-      clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
-      verificationStatus: codeableConcept('provisional', { code: 'provisional', system: systems.conditionVerStatus }),
-      category: [
-        codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory }),
-        codeableConcept('PRO-CTCAE patient-reported symptom (triage-tracked case)', { code: 'proctcae-symptom', system: codeSystemUrl('condition-category') }),
-      ],
-      code,
-      subject: patientReference(sym.patientId),
-      evidence: [{ reference: reference('Observation', String(sym.symptomId)) }],
-      extension: [extension('symptom-source', { valueString: String(sym.source || 'triage') })],
-    };
-    if (sym.effective) payload.onsetDateTime = toIso(sym.effective);
-    return new Condition(payload);
-  }
 }
 
 module.exports = { Condition };