@peopl-health/nexus 6.0.0-dev.666 → 6.0.0-dev.691

package/lib/config/airtableConfig.js

@@ -13,6 +13,7 @@ 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';
@@ -32,6 +33,7 @@ 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,
@@ -49,6 +51,7 @@ module.exports = {
   Monitoreo_ID,
   Programa_Juntas_ID,
   Symptoms_ID,
+  Ctcae_ID,
   Follow_Up_ID,
   Webinars_Leads_ID,
   Product_ID,

package/lib/core/workflowRunner.js

@@ -0,0 +1,35 @@
+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/fhirConfig.js

@@ -2,12 +2,32 @@ const { Config_ID } = require('../../config/airtableConfig');
 
 const { getRecordByFilter } = require('../../services/airtableService');
 
-const { safeParse } = require('../../utils/jsonUtils');
+const { safeParse, safeParseArray } = require('../../utils/jsonUtils');
 
 const FHIR_CONFIG_TABLE = 'fhir';
-const REQUIRED_KEYS = ['IDENT_BASE', 'EXT_BASE', 'SYSTEMS', 'DEVICE_ID', 'ORGANIZATION_ID'];
+const REQUIRED_KEYS = [
+  'IDENT_BASE',
+  'EXT_BASE',
+  'CODESYSTEM_BASE',
+  'SYSTEMS',
+  'SUSPECTED_GRADE_DISPLAYS',
+  'QUESTIONNAIRE_CANONICAL_URL',
+  'PROCTCAE_VERSION',
+  'DEVICE_ID',
+  'ORGANIZATION_ID',
+];
 
-const state = { identBase: null, extBase: null, systems: null, deviceId: null, organizationId: null };
+const state = {
+  identBase: null,
+  extBase: null,
+  codesystemBase: null,
+  systems: null,
+  suspectedGradeDisplays: null,
+  questionnaireCanonicalUrl: null,
+  proctcaeVersion: null,
+  deviceId: null,
+  organizationId: null,
+};
 
 async function initialize() {
   const records = await getRecordByFilter(Config_ID, FHIR_CONFIG_TABLE, 'TRUE()');
@@ -20,9 +40,16 @@ 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;
 }
@@ -35,7 +62,11 @@ 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/config/fhirTablesConfig.js

@@ -0,0 +1,9 @@
+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/helpers/compositeHelper.js

@@ -0,0 +1,88 @@
+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 };

package/lib/fhir/helpers/elementHelper.js

@@ -24,10 +24,19 @@ function extension(name, value) {
   return { url: extensionUrl(name), ...value };
 }
 
+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,
   codeableConcept,
   extension,
+  toIso,
 };

package/lib/fhir/helpers/fhirHelper.js

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

package/lib/fhir/helpers/terminologyHelper.js

@@ -0,0 +1,260 @@
+const crypto = require('node:crypto');
+
+const { getSuspectedGradeDisplays, getSystems } = require('../config/fhirConfig');
+const { lookupValue, integerId, parseList, termKey } = require('../utils/normalizeUtils');
+const { codeSystemUrl } = require('./fhirHelper');
+
+const { safeParse } = require('../../utils/jsonUtils');
+
+const DIMENSION_SCALES = {
+  frequency: ['Nunca', 'Rara vez', 'A veces', 'A menudo', 'Casi siempre'],
+  intensity: ['Ninguna', 'Leve', 'Moderada', 'Intensa', 'Muy intensa'],
+  interference: ['Nada', 'Un poco', 'Algo', 'Mucho', 'Muchísimo'],
+  amount: ['Ninguna', 'Leve', 'Moderada', 'Intensa', 'Muy intensa'],
+  presence: ['No', 'Sí'],
+};
+
+const DIMENSION_ORDER = ['presence', 'frequency', 'intensity', 'interference', 'amount'];
+
+const CANONICAL_SOURCE = 'original';
+
+function buildCatalog(items, composites = [], source = null) {
+  const symptoms = {};
+  const questionIndex = {};
+  const answerMap = {};
+
+  for (const row of items) {
+    const questionId = integerId(row.question_id);
+    const map = answerMapOf(row);
+    if (questionId != null && map) answerMap[String(questionId)] = map;
+
+    const en = row.symptom_en;
+    if (!en) continue;
+    const term = termKey(en);
+    const dimension = row.dimension ?? null;
+
+    const record = (symptoms[term] = symptoms[term] || {
+      term,
+      en,
+      es: row.symptom_es ?? null,
+      ctcae_v5: lookupValue(row.ctcae_v5),
+      meddra: lookupValue(row.meddra_code),
+      ae_category: lookupValue(row.AEcategory),
+      dimensions: [],
+    });
+    record.dimensions.push({
+      dimension,
+      options: map ? [...(DIMENSION_SCALES[dimension] || [])] : parseList(row.options),
+      question_id: questionId != null ? String(questionId) : null,
+      source: row.source ?? null,
+    });
+
+    if (questionId != null && dimension) questionIndex[String(questionId)] = [term, dimension];
+  }
+
+  for (const record of Object.values(symptoms)) {
+    record.dimensions = pickCanonicalDimensions(record.dimensions);
+  }
+  const compositeGrades = buildCompositeGrades(composites);
+
+  return {
+    _meta: {
+      source,
+      n_symptoms: Object.keys(symptoms).length,
+      n_items: Object.keys(questionIndex).length,
+      n_mapped_items: Object.keys(answerMap).length,
+      n_composites: Object.keys(compositeGrades).length,
+      composite_table_hash: Object.keys(compositeGrades).length ? hashCompositeGrades(compositeGrades) : null,
+      dimension_scales: DIMENSION_SCALES,
+    },
+    symptoms,
+    question_index: questionIndex,
+    answer_map: answerMap,
+    composite_grades: compositeGrades,
+  };
+}
+
+function answerMapOf(row) {
+  const map = safeParse(row.proctcae_map, null);
+  return map && typeof map === 'object' && Object.keys(map).length ? map : null;
+}
+
+function canonicalAnswer(catalog, questionId, answer) {
+  const map = catalog.answer_map[String(questionId).trim()];
+  if (!map) return answer;
+  return map[String(answer).trim()] ?? answer;
+}
+
+function pickCanonicalDimensions(dimensions) {
+  const best = {};
+  for (const d of dimensions) {
+    if (d.dimension == null) continue;
+    const prev = best[d.dimension];
+    if (!prev || outranks(d, prev)) best[d.dimension] = d;
+  }
+  return Object.values(best).sort((a, b) => {
+    const rank = (d) => (DIMENSION_ORDER.includes(d.dimension) ? DIMENSION_ORDER.indexOf(d.dimension) : 99);
+    return rank(a) - rank(b);
+  });
+}
+
+function outranks(candidate, current) {
+  const canonical = (d) => d.source === CANONICAL_SOURCE;
+  if (canonical(candidate) !== canonical(current)) return canonical(candidate);
+  return (integerId(candidate.question_id) || 0) > (integerId(current.question_id) || 0);
+}
+
+function buildCompositeGrades(composites) {
+  const compositeGrades = {};
+  for (const row of composites) {
+    const code = row.combination_code;
+    const raw = String(row.composite_ctcae ?? '').trim();
+    const grade = raw === '' ? NaN : Number(raw);
+    if (code && Number.isInteger(grade)) compositeGrades[code] = grade;
+  }
+  return compositeGrades;
+}
+
+function hashCompositeGrades(compositeGrades) {
+  const lines = Object.entries(compositeGrades)
+    .sort(([a], [b]) => (a < b ? -1 : 1))
+    .map(([code, grade]) => `${code}=${grade}`)
+    .join('\n');
+  return crypto.createHash('sha256').update(lines, 'utf8').digest('hex').slice(0, 12);
+}
+
+function allTerms(catalog) {
+  return Object.keys(catalog.symptoms).sort();
+}
+
+function compositeTableHash(catalog) {
+  return catalog._meta.composite_table_hash;
+}
+
+function getSymptom(catalog, term) {
+  return catalog.symptoms[term] || null;
+}
+
+function itemForQuestionId(catalog, questionId) {
+  const entry = catalog.question_index[String(questionId).trim()];
+  return Array.isArray(entry) && entry.length >= 2 ? [entry[0], entry[1]] : null;
+}
+
+function standardScale(catalog, dimension) {
+  return [...(catalog._meta.dimension_scales[dimension] || [])];
+}
+
+function standardOrdinal(catalog, dimension, answer) {
+  return ordinalIn(standardScale(catalog, dimension), answer);
+}
+
+function compositeGrade(catalog, ordinals = {}) {
+  const code = COMPOSITE_DIMENSIONS.map((d) => (ordinals[d] == null ? 'x' : String(ordinals[d]))).join('');
+  const grade = catalog.composite_grades[code];
+  return grade === undefined ? null : grade;
+}
+
+function codeText(catalog, term) {
+  const rec = getSymptom(catalog, term);
+  return rec ? rec.es || rec.en : term;
+}
+
+function dimensionsFor(catalog, term) {
+  const rec = getSymptom(catalog, term);
+  return (rec ? rec.dimensions : []).map((d) => d.dimension).filter(Boolean);
+}
+
+function answerOptions(catalog, term, dimension) {
+  return optionsForRec(getSymptom(catalog, term), dimension);
+}
+
+function ordinalValue(catalog, term, dimension, answer) {
+  return ordinalIn(answerOptions(catalog, term, dimension), answer);
+}
+
+function codingsFor(catalog, term) {
+  const rec = getSymptom(catalog, term);
+  const codings = [
+    { system: codeSystemUrl('pro-ctcae'), code: term, ...(rec && rec.en ? { display: rec.en } : {}) },
+  ];
+  if (rec && rec.ctcae_v5) {
+    codings.push({
+      system: codeSystemUrl('ctcae-v5-term'),
+      code: ctcaeSlug(rec.ctcae_v5),
+      display: rec.ctcae_v5,
+    });
+  }
+  if (rec && rec.meddra) {
+    codings.push({
+      system: getSystems().meddra,
+      code: String(rec.meddra),
+      ...(rec.ctcae_v5 ? { display: rec.ctcae_v5 } : {}),
+    });
+  }
+  return codings;
+}
+
+function aeCategory(catalog, term) {
+  const rec = getSymptom(catalog, term);
+  if (!rec || !rec.ae_category) return null;
+  return { code: ctcaeSlug(rec.ae_category), display: rec.ae_category };
+}
+
+function gradeConcept(grade) {
+  const g = Number(grade);
+  if (!Number.isInteger(g)) throw new Error(`grade is not an integer: '${grade}'`);
+  const display = getSuspectedGradeDisplays()[g] || `Grado CTCAE ${g} sospechado`;
+  return {
+    coding: [
+      {
+        system: codeSystemUrl('suspected-ctcae-grade'),
+        code: String(g),
+        display,
+        extension: [{ url: getSystems().itemWeight, valueDecimal: g }],
+      },
+    ],
+    text: display,
+  };
+}
+
+function ordinalIn(options, answer) {
+  const norm = String(answer ?? '').trim().toLowerCase();
+  const i = options.findIndex((o) => o.trim().toLowerCase() === norm);
+  return i === -1 ? null : i;
+}
+
+const AFFIRMATIVE = ['sí', 'si', 'yes', 'true', '1'];
+function affirmative(value) {
+  return AFFIRMATIVE.includes(String(value).trim().toLowerCase());
+}
+
+function optionsForRec(rec, dimension) {
+  for (const d of rec ? rec.dimensions : []) {
+    if (d.dimension === dimension) return [...d.options];
+  }
+  return [];
+}
+
+const ctcaeSlug = (value) =>
+  String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+
+const COMPOSITE_DIMENSIONS = ['frequency', 'intensity', 'interference', 'amount'];
+
+module.exports = {
+  buildCatalog,
+  allTerms,
+  compositeTableHash,
+  itemForQuestionId,
+  canonicalAnswer,
+  affirmative,
+  standardScale,
+  standardOrdinal,
+  compositeGrade,
+  codeText,
+  aeCategory,
+  dimensionsFor,
+  answerOptions,
+  ordinalValue,
+  codingsFor,
+  gradeConcept,
+};

package/lib/fhir/index.js

@@ -1,5 +1,7 @@
 const { registerProjector, project, storeResources } = require('./services/fhirService');
 const { storeClinicalMentions } = require('./services/clinicalMentionService');
+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');
@@ -16,6 +18,8 @@ module.exports = {
   project,
   storeResources,
   storeClinicalMentions,
+  storeTriage,
+  patientSnapshot,
   getFhirStore,
   ensureFhirIndexes,
 };

package/lib/fhir/projections/proctcaeProjection.js

@@ -0,0 +1,179 @@
+const { logger } = require('../../utils/logger');
+const { getSystems } = require('../config/fhirConfig');
+const { codeSystemUrl } = require('../helpers/fhirHelper');
+const { codeableConcept } = require('../helpers/elementHelper');
+const terminology = require('../helpers/terminologyHelper');
+const { PAIN_TERM } = require('../helpers/compositeHelper');
+const { Condition } = require('../resources/Condition');
+const { Device } = require('../resources/Device');
+const { Observation } = require('../resources/Observation');
+const { Patient } = require('../resources/Patient');
+const { Questionnaire } = require('../resources/Questionnaire');
+const { QuestionnaireResponse } = require('../resources/QuestionnaireResponse');
+
+const GRADE_METHOD = 'PRO-CTCAE composite → CTCAE (unofficial approximation)';
+const INGEST_DEVICE_ID = 'lookup-table-grade-estimator';
+
+const PAIN_PRESENCE_LINK = 'pain.presence';
+const PAIN_LOCATION_LINK = 'pain.location';
+
+function painLocationText(pain) {
+  const locations = (pain.locations || []).filter(Boolean).map(String);
+  return locations.length ? locations.join(', ') : String(pain.mostImportant || '').trim();
+}
+
+const linkId = (term, dimension) => `${term}.${dimension}`;
+
+const answerOption = (catalog, dimension, options) =>
+  options.map((label, i) => {
+    const weight = terminology.standardOrdinal(catalog, dimension, label);
+    return {
+      valueCoding: {
+        system: codeSystemUrl('pro-ctcae-answer'),
+        code: String(i),
+        display: label,
+        ...(weight === null
+          ? {}
+          : { extension: [{ url: getSystems().itemWeight, valueDecimal: weight }] }),
+      },
+    };
+  });
+
+function painCanonicalItems(catalog) {
+  return [
+    {
+      linkId: PAIN_PRESENCE_LINK,
+      text: 'Dolor — presencia',
+      type: 'coding',
+      answerOption: answerOption(catalog, 'presence', terminology.standardScale(catalog, 'presence')),
+    },
+    { linkId: PAIN_LOCATION_LINK, text: 'Dolor más importante — ubicación', type: 'string' },
+  ];
+}
+
+function projectProctcaeCanonical(catalog) {
+  const items = painCanonicalItems(catalog);
+  for (const term of terminology.allTerms(catalog)) {
+    const textEs = terminology.codeText(catalog, term);
+    for (const dim of terminology.dimensionsFor(catalog, term)) {
+      if (!terminology.standardScale(catalog, dim).length) {
+        logger.warn('[projectProctcaeCanonical] unknown dimension, item skipped', { term, dimension: dim });
+        continue;
+      }
+      items.push({
+        linkId: linkId(term, dim),
+        text: `${textEs} — ${dim}`,
+        type: 'coding',
+        code: terminology.codingsFor(catalog, term),
+        answerOption: answerOption(catalog, dim, terminology.answerOptions(catalog, term, dim)),
+      });
+    }
+  }
+  return Questionnaire.fromProctcaeCatalog({ items });
+}
+
+function projectTriagePatient(patientId) {
+  return Patient.fromTriageProjection({ patientId });
+}
+
+function projectTriageIngestDevice(catalog) {
+  return Device.fromTriageProjection({
+    deviceId: INGEST_DEVICE_ID,
+    compositeTableHash: terminology.compositeTableHash(catalog),
+  });
+}
+
+function projectProctcaeSymptomObservation(catalog, sym) {
+  const term = sym.term;
+  const components = [];
+  for (const dim of terminology.dimensionsFor(catalog, term)) {
+    const answer = (sym.dimensionAnswers || {})[dim];
+    if (answer == null) continue;
+    const code = codeableConcept(dim, { code: dim, system: codeSystemUrl('pro-ctcae-dimension') });
+    if (dim === 'presence') {
+      components.push({ code, valueBoolean: terminology.affirmative(answer) });
+    } else {
+      const ordinal = terminology.standardOrdinal(catalog, dim, answer);
+      components.push({
+        code,
+        ...(ordinal !== null ? { valueInteger: ordinal } : { valueString: String(answer) }),
+      });
+    }
+  }
+  const aeCategory = terminology.aeCategory(catalog, term);
+  return Observation.fromTriageProjection({
+    sym,
+    code: { coding: terminology.codingsFor(catalog, term), text: terminology.codeText(catalog, term) },
+    aeCategoryConcept: aeCategory
+      ? codeableConcept(aeCategory.display, { code: aeCategory.code, system: codeSystemUrl('pro-ctcae-ae-category') })
+      : null,
+    components,
+    gradeConcept: terminology.gradeConcept(sym.grade),
+    method: codeableConcept(GRADE_METHOD),
+    deviceId: INGEST_DEVICE_ID,
+  });
+}
+
+function projectTriageQuestionnaireResponse(catalog, qr) {
+  const byLink = new Map();
+  const bestQid = new Map();
+  for (const [rawQid, label] of Object.entries(qr.answers || {})) {
+    if (label == null || String(label).trim() === '') continue;
+    const mapped = terminology.itemForQuestionId(catalog, rawQid);
+    if (!mapped) continue;
+    const [term, dim] = mapped;
+    const link = linkId(term, dim);
+    const qidInt = /^-?\d+$/.test(String(rawQid).trim()) ? Number(rawQid) : -1;
+    if (byLink.has(link) && qidInt <= (bestQid.get(link) ?? -1)) continue;
+    const canonical = terminology.canonicalAnswer(catalog, rawQid, label);
+    const ordinal = terminology.ordinalValue(catalog, term, dim, String(canonical));
+    const answer =
+      ordinal !== null
+        ? { valueCoding: { system: codeSystemUrl('pro-ctcae-answer'), code: String(ordinal), display: String(label) } }
+        : { valueString: String(label) };
+    byLink.set(link, { linkId: link, answer: [answer] });
+    bestQid.set(link, qidInt);
+  }
+  const pain = qr.pain || {};
+  if (pain.hasPain != null && pain.hasPain !== '') {
+    const has = terminology.affirmative(pain.hasPain);
+    byLink.set(PAIN_PRESENCE_LINK, {
+      linkId: PAIN_PRESENCE_LINK,
+      answer: [{ valueCoding: { system: codeSystemUrl('pro-ctcae-answer'), code: String(has ? 1 : 0), display: String(pain.hasPain) } }],
+    });
+    if (has) {
+      for (const dim of terminology.dimensionsFor(catalog, PAIN_TERM)) {
+        const label = pain[dim];
+        if (!label) continue;
+        const link = linkId(PAIN_TERM, dim);
+        const ordinal = terminology.ordinalValue(catalog, PAIN_TERM, dim, String(label));
+        const answer =
+          ordinal !== null
+            ? { valueCoding: { system: codeSystemUrl('pro-ctcae-answer'), code: String(ordinal), display: String(label) } }
+            : { valueString: String(label) };
+        byLink.set(link, { linkId: link, answer: [answer] });
+      }
+      const location = painLocationText(pain);
+      if (location) {
+        byLink.set(PAIN_LOCATION_LINK, { linkId: PAIN_LOCATION_LINK, answer: [{ valueString: location }] });
+      }
+    }
+  }
+  return QuestionnaireResponse.fromTriageProjection({ qr, items: [...byLink.values()] });
+}
+
+function projectTriageSymptomCondition(catalog, sym) {
+  return Condition.fromTriageProjection({
+    sym,
+    code: { coding: terminology.codingsFor(catalog, sym.term), text: terminology.codeText(catalog, sym.term) },
+  });
+}
+
+module.exports = {
+  projectProctcaeCanonical,
+  projectTriagePatient,
+  projectProctcaeSymptomObservation,
+  projectTriageIngestDevice,
+  projectTriageQuestionnaireResponse,
+  projectTriageSymptomCondition,
+};

package/lib/fhir/resources/Condition.js

@@ -1,6 +1,6 @@
 const { getSystems } = require('../config/fhirConfig');
-const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
+const { fhirId, codeSystemUrl } = require('../helpers/fhirHelper');
+const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 
 class Condition {
   constructor(payload) {
@@ -29,6 +29,28 @@ 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 };

package/lib/fhir/resources/Device.js

@@ -0,0 +1,24 @@
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, codeableConcept } = require('../helpers/elementHelper');
+
+class Device {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromTriageProjection({ deviceId, compositeTableHash }) {
+    const version = [{ value: 'pro-ctcae-composite' }];
+    if (compositeTableHash) version.push({ type: { text: 'composite-table' }, value: `sha256:${compositeTableHash}` });
+    return new Device({
+      resourceType: 'Device',
+      id: fhirId(deviceId),
+      identifier: [identifier('device', deviceId)],
+      status: 'active',
+      name: [{ value: 'PRO-CTCAE composite → CTCAE grade estimator', type: 'user-friendly-name' }],
+      type: [codeableConcept('Software / clinical algorithm')],
+      version,
+    });
+  }
+}
+
+module.exports = { Device };

package/lib/fhir/resources/Observation.js

@@ -1,6 +1,6 @@
 const { getSystems } = require('../config/fhirConfig');
 const { fhirId } = require('../helpers/fhirHelper');
-const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
+const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
 
 const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
 
@@ -45,6 +45,32 @@ 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);
+  }
 }
 
 function observationCategory(code) {

package/lib/fhir/resources/Patient.js

@@ -0,0 +1,18 @@
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier } = require('../helpers/elementHelper');
+
+class Patient {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromTriageProjection({ patientId }) {
+    return new Patient({
+      resourceType: 'Patient',
+      id: fhirId(String(patientId)),
+      identifier: [identifier('patient', String(patientId))],
+    });
+  }
+}
+
+module.exports = { Patient };

package/lib/fhir/resources/Questionnaire.js

@@ -0,0 +1,23 @@
+const { getQuestionnaireCanonicalUrl, getProctcaeVersion } = require('../config/fhirConfig');
+const { fhirId } = require('../helpers/fhirHelper');
+
+class Questionnaire {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromProctcaeCatalog({ items }) {
+    return new Questionnaire({
+      resourceType: 'Questionnaire',
+      id: fhirId(`pro-ctcae-${getProctcaeVersion()}`),
+      url: getQuestionnaireCanonicalUrl(),
+      version: getProctcaeVersion(),
+      status: 'active',
+      name: 'PROCTCAE',
+      subjectType: ['Patient'],
+      item: items,
+    });
+  }
+}
+
+module.exports = { Questionnaire };

package/lib/fhir/resources/QuestionnaireResponse.js

@@ -0,0 +1,29 @@
+const { getQuestionnaireCanonicalUrl, getProctcaeVersion } = require('../config/fhirConfig');
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference, toIso } = require('../helpers/elementHelper');
+
+class QuestionnaireResponse {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromTriageProjection({ qr, items }) {
+    const tid = String(qr.triageId);
+    const identifiers = [identifier('triage', tid)];
+    if (qr.questionnaireId) identifiers.push(identifier('questionnaire-week', String(qr.questionnaireId)));
+    const payload = {
+      resourceType: 'QuestionnaireResponse',
+      id: fhirId(`triage-${tid}`),
+      identifier: identifiers,
+      questionnaire: `${getQuestionnaireCanonicalUrl()}|${getProctcaeVersion()}`,
+      status: (qr.completed ?? true) ? 'completed' : 'in-progress',
+      subject: patientReference(qr.patientId),
+      source: patientReference(qr.patientId),
+    };
+    if (qr.authored) payload.authored = toIso(qr.authored);
+    if (items.length) payload.item = items;
+    return new QuestionnaireResponse(payload);
+  }
+}
+
+module.exports = { QuestionnaireResponse };

package/lib/fhir/services/fhirService.js

@@ -15,11 +15,11 @@ function project(items) {
   return registry.project(items);
 }
 
-async function storeResources(resources, { store = null } = {}) {
+async function storeResources(resources, { store = null, merge = 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));
+    stored.push(await resourceStore.upsert(resource, { merge }));
   }
   return { stored };
 }

package/lib/fhir/services/snapshotService.js

@@ -0,0 +1,28 @@
+const { fhirId } = require('../helpers/fhirHelper');
+const { getFhirStore } = require('../stores/fhirStore');
+
+async function patientSnapshot(patientId, { resourceTypes = null } = {}) {
+  if (!String(patientId ?? '').trim()) throw new Error('patientId is required');
+  if (resourceTypes != null) {
+    if (!Array.isArray(resourceTypes)) throw new Error('resourceTypes must be an array');
+    if (resourceTypes.some((t) => typeof t !== 'string' || !t.trim())) throw new Error('resourceTypes must contain only non-empty strings');
+  }
+  const requestedTypes = resourceTypes ? [...new Set(resourceTypes.map((resourceType) => resourceType.trim()))] : null;
+  const store = getFhirStore();
+  const patient = `Patient/${fhirId(patientId)}`;
+  const linkedTypes = requestedTypes ? requestedTypes.filter((resourceType) => resourceType !== 'Patient') : null;
+  const resources = linkedTypes
+    ? (await Promise.all(linkedTypes.map((resourceType) => store.find({ patient, resourceType })))).flat()
+    : await store.find({ patient });
+  if (!requestedTypes || requestedTypes.includes('Patient')) {
+    const patientResource = await store.getByReference(patient);
+    if (patientResource) resources.push(patientResource);
+  }
+  const byType = Object.create(null);
+  for (const resource of resources) {
+    (byType[resource.resourceType] = byType[resource.resourceType] || []).push(resource);
+  }
+  return byType;
+}
+
+module.exports = { patientSnapshot };

package/lib/fhir/services/terminologyService.js

@@ -0,0 +1,58 @@
+const { PROCTCAE_ITEMS_TABLE, PROCTCAE_COMPOSITE_TABLE } = require('../config/fhirTablesConfig');
+const { buildCatalog } = require('../helpers/terminologyHelper');
+
+const { Ctcae_ID } = require('../../config/airtableConfig');
+const { getRecordByFilter } = require('../../services/airtableService');
+const { logger } = require('../../utils/logger');
+
+let catalogPromise = null;
+let loadedCompositeTableHash = null;
+
+async function getCatalog() {
+  if (!catalogPromise) {
+    catalogPromise = loadCatalog().catch((error) => {
+      catalogPromise = null;
+      throw error;
+    });
+  }
+  return catalogPromise;
+}
+
+function clearCache() {
+  catalogPromise = null;
+}
+
+async function loadCatalog() {
+  const [items, composites] = await Promise.all([
+    getRecordByFilter(Ctcae_ID, PROCTCAE_ITEMS_TABLE, 'TRUE()', null),
+    getRecordByFilter(Ctcae_ID, PROCTCAE_COMPOSITE_TABLE, 'TRUE()', null),
+  ]);
+  if (!items) throw new Error('proctcae terminology tables not readable from Airtable');
+  if (!composites) logger.warn('[terminologyService] composite table not readable; composite grading disabled');
+
+  const source = `Airtable ${Ctcae_ID} (${PROCTCAE_ITEMS_TABLE})`;
+  const catalog = buildCatalog(items, composites || [], source);
+  if (!catalog._meta.n_symptoms) throw new Error('proctcae terminology catalog is empty');
+
+  const compositeTableHash = catalog._meta.composite_table_hash ?? null;
+  if (loadedCompositeTableHash && compositeTableHash && loadedCompositeTableHash !== compositeTableHash) {
+    logger.warn('[terminologyService] composite grading table changed — grades derived after this differ from grades before it', {
+      from: loadedCompositeTableHash,
+      to: compositeTableHash,
+    });
+  }
+  loadedCompositeTableHash = compositeTableHash;
+
+  logger.info('[terminologyService] catalog loaded', {
+    source,
+    symptoms: catalog._meta.n_symptoms,
+    items: catalog._meta.n_items,
+    mappedItems: catalog._meta.n_mapped_items,
+    composites: catalog._meta.n_composites,
+    compositeTableHash,
+  });
+
+  return catalog;
+}
+
+module.exports = { getCatalog, clearCache };

package/lib/fhir/services/triageService.js

@@ -0,0 +1,57 @@
+const { gradeComposites } = require('../helpers/compositeHelper');
+const { GradedSymptom } = require('../../shared/dtos/GradedSymptom');
+const { TriageResponse } = require('../../shared/dtos/TriageResponse');
+const {
+  projectProctcaeCanonical,
+  projectTriagePatient,
+  projectProctcaeSymptomObservation,
+  projectTriageIngestDevice,
+  projectTriageQuestionnaireResponse,
+  projectTriageSymptomCondition,
+} = require('../projections/proctcaeProjection');
+const { storeResources } = require('./fhirService');
+const { getCatalog: loadTerminology } = require('./terminologyService');
+
+const FOLLOW_UP_GRADE = 1;
+
+async function storeTriage(payload) {
+  const input = new TriageResponse(payload);
+  const catalog = await loadTerminology();
+  const graded = gradeComposites(catalog, input).map((symptom) => new GradedSymptom(symptom));
+  const resources = [
+    projectProctcaeCanonical(catalog),
+    projectTriagePatient(input.patientId),
+    projectTriageIngestDevice(catalog),
+    projectTriageQuestionnaireResponse(catalog, input),
+    ...graded.map((sym) => projectProctcaeSymptomObservation(catalog, sym)),
+  ];
+  const conditions = graded
+    .filter((sym) => sym.grade >= FOLLOW_UP_GRADE)
+    .map((sym) => projectTriageSymptomCondition(catalog, sym));
+  const { stored } = await storeResources(resources);
+  const { stored: storedConditions } = await storeResources(conditions, { merge: mergeTriageSymptomCondition });
+  return { stored: [...stored, ...storedConditions] };
+}
+
+function mergeTriageSymptomCondition(existing, next) {
+  if (!existing) return next;
+  const merged = { ...next };
+  const onset = earlierOnset(existing.onsetDateTime, next.onsetDateTime);
+  if (onset) merged.onsetDateTime = onset;
+  const seen = new Set();
+  merged.evidence = [...(existing.evidence || []), ...(next.evidence || [])].filter((entry) => {
+    const ref = entry.reference && entry.reference.reference;
+    if (!ref || seen.has(ref)) return false;
+    seen.add(ref);
+    return true;
+  });
+  return merged;
+}
+
+function earlierOnset(existing, next) {
+  if (!existing) return next;
+  if (!next) return existing;
+  return Date.parse(next) < Date.parse(existing) ? next : existing;
+}
+
+module.exports = { storeTriage };

package/lib/fhir/utils/normalizeUtils.js

@@ -0,0 +1,33 @@
+const lookupValue = (value) => {
+  const first = Array.isArray(value) ? value[0] : value;
+  return first === undefined || first === '' ? null : first;
+};
+
+const integerId = (value) => {
+  if (value == null || String(value).trim() === '') return null;
+  const id = Number(value);
+  return Number.isFinite(id) ? Math.trunc(id) : null;
+};
+
+const parseList = (value) =>
+  String(value || '')
+    .split(/[;|]/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+function termKey(name) {
+  return String(name || '')
+    .trim()
+    .toLowerCase()
+    .replace(/&/g, 'and')
+    .replace(/[/-]/g, ' ')
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+}
+
+module.exports = {
+  lookupValue,
+  integerId,
+  parseList,
+  termKey,
+};

package/lib/index.d.ts

@@ -416,6 +416,20 @@ 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;

package/lib/index.js

@@ -27,6 +27,7 @@ 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');
@@ -214,6 +215,7 @@ class Nexus {
 }
 
 module.exports = {
+  createWorkflowRunner,
   Nexus,
   TwilioProvider,
   BaileysProvider,

package/lib/services/airtableService.js

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

package/lib/shared/dtos/GradedSymptom.js

@@ -0,0 +1,23 @@
+const { z } = require('zod');
+
+const { BaseDto } = require('./BaseDto');
+
+const dateTime = z.iso.datetime({ offset: true });
+
+const schema = z.strictObject({
+  schemaVersion: z.string().default('1'),
+  symptomId: z.string(),
+  patientId: z.string(),
+  term: z.string(),
+  grade: z.number().int().min(0).max(4),
+  effective: dateTime.nullable().default(null),
+  triageId: z.string(),
+  dimensionAnswers: z.record(z.string(), z.string()).default({}),
+  source: z.string().default('triage'),
+});
+
+class GradedSymptom extends BaseDto {}
+
+GradedSymptom.schema = schema;
+
+module.exports = { GradedSymptom };

package/lib/shared/dtos/TriageResponse.js

@@ -0,0 +1,35 @@
+const { z } = require('zod');
+
+const { BaseDto } = require('./BaseDto');
+
+const dateTime = z.iso.datetime({ offset: true });
+
+const painSchema = z.strictObject({
+  hasPain: z.string().nullable().default(null),
+  frequency: z.string().nullable().default(null),
+  intensity: z.string().nullable().default(null),
+  interference: z.string().nullable().default(null),
+  locations: z.array(z.string()).default([]),
+  mostImportant: z.string().nullable().default(null),
+  otherText: z.string().nullable().default(null),
+});
+
+const schema = z.strictObject({
+  schemaVersion: z.string().default('1'),
+  triageId: z.string(),
+  patientId: z.string(),
+  authored: dateTime.nullable().default(null),
+  completed: z.boolean().default(true),
+  answers: z.record(z.string(), z.string().nullable()).default({}),
+  questionnaireId: z.string().nullable().default(null),
+  cadence: z.string().nullable().default(null),
+  satisfactionLabel: z.string().nullable().default(null),
+  satisfactionValue: z.number().int().default(-1),
+  pain: painSchema.default(() => painSchema.parse({})),
+});
+
+class TriageResponse extends BaseDto {}
+
+TriageResponse.schema = schema;
+
+module.exports = { TriageResponse };

package/package.json

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