@peopl-health/nexus 5.9.2 → 5.10.0-dev.1020

package/lib/clinical/config/subAgentsConfig.js

@@ -10,7 +10,6 @@ const CACHE_TTL = 5 * 60 * 1000;
 const CACHE_KEY = 'subAgentsConfig';
 const EXTRACTOR_DEFAULTS = { presetId: '' };
 const COMPOSER_DEFAULTS = { presetId: '' };
-const PATTERN_CONSULT_DEFAULTS = { presetId: '' };
 
 const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
 
@@ -30,11 +29,7 @@ async function load() {
   if (byKey.COMPOSER && !isPlainObject(parsedComposer)) throw new Error('subAgents config COMPOSER is not a JSON object');
   const composer = { ...COMPOSER_DEFAULTS, ...(parsedComposer || {}) };
 
-  const parsedPatternConsult = safeParse(byKey.PATTERN_CONSULT, null);
-  if (byKey.PATTERN_CONSULT && !isPlainObject(parsedPatternConsult)) throw new Error('subAgents config PATTERN_CONSULT is not a JSON object');
-  const patternConsult = { ...PATTERN_CONSULT_DEFAULTS, ...(parsedPatternConsult || {}) };
-
-  const config = { EXTRACTOR: extractor, COMPOSER: composer, PATTERN_CONSULT: patternConsult };
+  const config = { EXTRACTOR: extractor, COMPOSER: composer };
   cache.set(CACHE_KEY, config);
   return config;
 }
@@ -46,5 +41,4 @@ async function get(key) {
 module.exports = {
   getExtractor: () => get('EXTRACTOR'),
   getComposer: () => get('COMPOSER'),
-  getPatternConsult: () => get('PATTERN_CONSULT'),
 };

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -207,4 +207,4 @@ class DefaultMemoryManager extends MemoryManager {
   }
 }
 
-module.exports = { DefaultMemoryManager, OPERATOR_TURN_PREFIX };
+module.exports = { DefaultMemoryManager };

package/lib/clinical/providers/AnthropicProvider.js

@@ -1,6 +1,5 @@
 const { Anthropic } = require('@anthropic-ai/sdk');
 
-const { OPERATOR_TURN_PREFIX } = require('../memory/DefaultMemoryManager');
 const { appendCall } = require('../services/llmAuditService');
 const { composePrompt } = require('../services/promptComposerService');
 const { retryWithBackoff } = require('../../utils/retryUtils');
@@ -385,15 +384,6 @@ class AnthropicProvider extends BaseLLMProvider {
     return typeof output === 'string' ? output : JSON.stringify(output ?? '');
   }
 
-  // Split placement: the inline copy carries recency on single-round turns, the hoisted developer
-  // turn persists once tool results are appended after it on multi-round turns.
-  _buildInput({ additionalInstructions, ...rest }) {
-    const input = super._buildInput({ additionalInstructions, ...rest });
-    if (!additionalInstructions) return input;
-    const { content } = this._operatorInstructionTurn(additionalInstructions);
-    return [...input, { role: 'user', content: `${OPERATOR_TURN_PREFIX} ${content}`, type: 'message' }];
-  }
-
   _mapModelConfig(modelConfig) {
     const mapped = { ...(modelConfig || {}) };
     if (mapped.max_tokens == null && mapped.max_output_tokens != null) mapped.max_tokens = mapped.max_output_tokens;

package/lib/clinical/tools/{getPatientRiskAssessmentTool.js → getPatientRiskProfileTool.js}

@@ -1,8 +1,8 @@
 const { readPatientRisk } = require('../../fhir');
 
 const definition = {
-  name: 'getPatientRiskAssessment',
-  description: '**Does:** Returns the patient\'s persistent risk assessment — predicted adverse events, disease risks, and comorbidity amplifiers derived from their regimen. Read-only.\n\n**Required inputs:** none.\n\n**When to call:** before routing, to anticipate which adverse events or complications the current regimen makes plausible.\n\n**Returns:** `status` (`final` when an assessment exists, `not_generated` otherwise) and `profile` (`assessment_id`, `source_regimen`, `source_diagnosis`, `source_phase`, `predicted_aes[]`, `disease_risks[]`, `comorbidity_amplifiers[]`, `assessed_at`, `assessed_by_model`) — `null` when not yet generated.',
+  name: 'getPatientRiskProfile',
+  description: '**Does:** Returns the patient\'s persistent risk profile — predicted adverse events, disease risks, and comorbidity amplifiers derived from their regimen. Read-only.\n\n**Required inputs:** none.\n\n**When to call:** before routing, to anticipate which adverse events or complications the current regimen makes plausible.\n\n**Returns:** `status` (`final` when a profile exists, `not_generated` otherwise) and `profile` (`assessment_id`, `source_regimen`, `source_diagnosis`, `source_phase`, `predicted_aes[]`, `disease_risks[]`, `comorbidity_amplifiers[]`, `assessed_at`, `assessed_by_model`) — `null` when not yet generated.',
   strict: false,
   parameters: {
     type: 'object',
@@ -55,12 +55,12 @@ async function handler(_args = {}, context = {}) {
   try {
     const runtime = context?.toolRuntimeContext || null;
     if (!runtime?.turnId || !runtime?.patientCode) {
-      return JSON.stringify({ success: false, error: 'getPatientRiskAssessment requires an active turn context (turnId, patientCode).', data: {} });
+      return JSON.stringify({ success: false, error: 'getPatientRiskProfile requires an active turn context (turnId, patientCode).', data: {} });
     }
     const data = await assembleRiskProfile(runtime.patientCode);
     return JSON.stringify({ success: true, data });
   } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'getPatientRiskAssessment failed', data: {} });
+    return JSON.stringify({ success: false, error: err?.message || 'getPatientRiskProfile failed', data: {} });
   }
 }
 

package/lib/clinical/tools/getRouterContextBundleTool.js

@@ -1,6 +1,6 @@
 const { assembleLandscape } = require('./getActiveSymptomLandscapeTool');
 const { assembleHistory, SUPPORTED_SCOPES, TIMEFRAME_DAYS } = require('./getPatientHistoryTool');
-const { assembleRiskProfile } = require('./getPatientRiskAssessmentTool');
+const { assembleRiskProfile } = require('./getPatientRiskProfileTool');
 
 const ALLOWED_SECTIONS = ['landscape', 'history', 'risk'];
 

package/lib/clinical/tools/registerClinicalTools.js

@@ -17,7 +17,7 @@ const TOOLS = [
   require('./getActiveSymptomLandscapeTool'),
   require('./recordInterventionTool'),
   require('./setContingencyPlanTool'),
-  require('./getPatientRiskAssessmentTool'),
+  require('./getPatientRiskProfileTool'),
   require('./getPatientHistoryTool'),
   require('./getRouterContextBundleTool'),
   require('./deliverPatientMessageTool'),

package/lib/fhir/constants/projectionSlugs.js

@@ -9,10 +9,6 @@ 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 SAFETY_GATE_SLUG = 'recommendation-safety';
-const RECOMMENDATION_PLAN_SLUG = 'recommendation-careplan';
-const RECOMMENDATION_ELEMENTS_SLUG = 'recommendation-palliative';
-const RECOMMENDATION_REC_SLUG = 'recommendation-rec';
 const CONTINGENCY_PLAN_SLUG = 'contingency-plan';
 const CONTINGENCY_STEP_SLUG = 'contingency-step';
 const INTERVENTION_SLUG = 'intervention';
@@ -22,8 +18,6 @@ const CLUSTER_IMPRESSION_SLUG = 'cluster-impression';
 const CLUSTER_LABEL_SLUG = 'cluster-label';
 const ROUTING_ASSESSMENT_SLUG = 'routing-assessment';
 const ROUTING_DISPOSITION_SLUG = 'routing-disposition';
-const PALLIATIVE_ASSESSMENT_SLUG = 'palliative-assessment';
-const PALLIATIVE_ESCALATION_SLUG = 'palliative-escalation';
 
 module.exports = {
   MENTION_SLUG,
@@ -37,10 +31,6 @@ module.exports = {
   SYMPTOM_ASSESSMENT_SLUG,
   SYMPTOM_GRADE_SLUG,
   PATIENT_RISK_SLUG,
-  SAFETY_GATE_SLUG,
-  RECOMMENDATION_PLAN_SLUG,
-  RECOMMENDATION_ELEMENTS_SLUG,
-  RECOMMENDATION_REC_SLUG,
   CONTINGENCY_PLAN_SLUG,
   CONTINGENCY_STEP_SLUG,
   INTERVENTION_SLUG,
@@ -50,6 +40,4 @@ module.exports = {
   CLUSTER_LABEL_SLUG,
   ROUTING_ASSESSMENT_SLUG,
   ROUTING_DISPOSITION_SLUG,
-  PALLIATIVE_ASSESSMENT_SLUG,
-  PALLIATIVE_ESCALATION_SLUG,
 };

package/lib/fhir/index.js

@@ -2,13 +2,11 @@ const { registerProjector, project, storeResources } = require('./services/fhirS
 const { storeClinicalMentions } = require('./services/clinicalMentionService');
 const { storeResultObservations } = require('./services/resultObservationService');
 const { storeSymptomCase, readSymptomCases } = require('./services/symptomCaseService');
-const { storePatientRisk, readPatientRisk, storeSafetyGate, safetyGateExists } = require('./services/riskService');
-const { storeRecommendationPlan, recommendationPlanExists } = require('./services/recommendationService');
+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 { storePalliativeAssessment, readPalliativeByTurn } = require('./services/palliativeService');
 const { storeTriage } = require('./services/triageService');
 const { patientSnapshot } = require('./services/snapshotService');
 const { registerAllProjectors } = require('./projections/registerProjectors');
@@ -32,10 +30,6 @@ module.exports = {
   readSymptomCases,
   storePatientRisk,
   readPatientRisk,
-  storeSafetyGate,
-  safetyGateExists,
-  storeRecommendationPlan,
-  recommendationPlanExists,
   storeContingency,
   readContingencies,
   storeIntervention,
@@ -44,8 +38,6 @@ module.exports = {
   readClusters,
   storeRoutingDecision,
   readRoutingByTurn,
-  storePalliativeAssessment,
-  readPalliativeByTurn,
   storeTriage,
   patientSnapshot,
   getFhirStore,

package/lib/fhir/projections/registerProjectors.js

@@ -4,13 +4,10 @@ const { projectDispatchedEscalation, PROJECTOR_NAME: ESCALATION_PROJECTOR_NAME }
 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 { projectSafetyGate, PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('./safetyGateProjection');
-const { projectRecommendationPlan, PROJECTOR_NAME: RECOMMENDATION_PLAN_PROJECTOR_NAME } = require('./recommendationPlanProjection');
 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 { projectPalliativeAssessment, PROJECTOR_NAME: PALLIATIVE_PROJECTOR_NAME } = require('./palliativeProjection');
 
 const PROJECTORS = [
   { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
@@ -18,13 +15,10 @@ const PROJECTORS = [
   { name: REMINDER_PROJECTOR_NAME, project: projectReminder },
   { name: SYMPTOM_CASE_PROJECTOR_NAME, project: projectSymptomCase },
   { name: RISK_PROJECTOR_NAME, project: projectPatientRisk },
-  { name: SAFETY_GATE_PROJECTOR_NAME, project: projectSafetyGate },
-  { name: RECOMMENDATION_PLAN_PROJECTOR_NAME, project: projectRecommendationPlan },
   { name: CONTINGENCY_PROJECTOR_NAME, project: projectContingency },
   { name: INTERVENTION_PROJECTOR_NAME, project: projectIntervention },
   { name: CLUSTER_PROJECTOR_NAME, project: projectCluster },
   { name: ROUTING_PROJECTOR_NAME, project: projectRoutingDecision },
-  { name: PALLIATIVE_PROJECTOR_NAME, project: projectPalliativeAssessment },
 ];
 
 function registerAllProjectors() {

package/lib/fhir/resources/CarePlan.js

@@ -7,7 +7,7 @@ const {
   extension,
   toIso,
 } = require('../helpers/elementHelper');
-const { CONTINGENCY_PLAN_SLUG, ROUTING_DISPOSITION_SLUG, RECOMMENDATION_PLAN_SLUG } = require('../constants/projectionSlugs');
+const { CONTINGENCY_PLAN_SLUG, ROUTING_DISPOSITION_SLUG } = require('../constants/projectionSlugs');
 
 const CONTINGENCY_STATUS_TO_FHIR = {
   armed: 'active',
@@ -45,28 +45,6 @@ class CarePlan {
     return new CarePlan(payload);
   }
 
-  static fromRecommendationPlan({ plan, taskIds, hasSafetyGate }) {
-    const payload = {
-      resourceType: 'CarePlan',
-      id: fhirId(`${plan.runId}-careplan`),
-      identifier: [identifier(RECOMMENDATION_PLAN_SLUG, `${plan.runId}-careplan`)],
-      status: 'active',
-      intent: 'plan',
-      category: [codeableConcept('symptom_management')],
-      subject: patientReference(plan.patientId),
-      created: toIso(plan.createdAt),
-      activity: taskIds.map((taskId) => ({
-        plannedActivityReference: reference('Task', taskId),
-      })),
-    };
-    if (hasSafetyGate) {
-      payload.supportingInfo = [reference('RiskAssessment', `${plan.runId}-safety`)];
-    }
-    if (plan.takeaways.summaryInternal) payload.description = plan.takeaways.summaryInternal;
-    if (plan.takeaways.summaryPatientFacing) payload.note = [{ text: plan.takeaways.summaryPatientFacing }];
-    return new CarePlan(payload);
-  }
-
   static fromRoutingDisposition({ disposition }) {
     const payload = {
       resourceType: 'CarePlan',

package/lib/fhir/resources/ClinicalImpression.js

@@ -1,6 +1,6 @@
 const { fhirId } = require('../helpers/fhirHelper');
 const { identifier, reference, patientReference, codeableConcept, extension, toIso } = require('../helpers/elementHelper');
-const { SYMPTOM_ASSESSMENT_SLUG, CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG, RECOMMENDATION_ELEMENTS_SLUG, PALLIATIVE_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
+const { SYMPTOM_ASSESSMENT_SLUG, CLUSTER_IMPRESSION_SLUG, CLUSTER_LABEL_SLUG, ROUTING_ASSESSMENT_SLUG } = require('../constants/projectionSlugs');
 
 const CLUSTER_STATUS_TO_FHIR = { active: 'in-progress', dissolved: 'completed' };
 const CLUSTER_LIST_SEPARATOR = '; ';
@@ -76,30 +76,6 @@ class ClinicalImpression {
     return new ClinicalImpression(payload);
   }
 
-  static fromRecommendationPlan({ plan }) {
-    const finding = [...plan.elements]
-      .sort((a, b) => a.rank - b.rank)
-      .map((element) => {
-        const basis = [`rank: ${element.rank}`, `tipo: ${element.type}`];
-        if (element.qolImpact) basis.push(`QoL: ${element.qolImpact}`);
-        if (element.whyRelevant) basis.push(`relevancia: ${element.whyRelevant}`);
-        const grounding = element.groundedIn.filter(Boolean).join('; ');
-        if (grounding) basis.push(`sustento: ${grounding}`);
-        return { item: { concept: codeableConcept(element.nameShort) }, basis: basis.join('; ') };
-      });
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(`${plan.runId}-palliative`),
-      identifier: [identifier(RECOMMENDATION_ELEMENTS_SLUG, `${plan.runId}-palliative`)],
-      status: 'completed',
-      subject: patientReference(plan.patientId),
-      effectiveDateTime: toIso(plan.createdAt),
-      finding,
-    };
-    if (plan.takeaways.summaryInternal) payload.summary = plan.takeaways.summaryInternal;
-    return new ClinicalImpression(payload);
-  }
-
   static fromRoutingAssessment({ assessment, decisionId, committedAt, deferredItems = [], primaryCaseId = null }) {
     const extensions = [
       extension('routing-turn-id', { valueString: assessment.turnId }),
@@ -133,45 +109,6 @@ class ClinicalImpression {
     if (assessment.notes.length) payload.note = assessment.notes.map((text) => ({ text }));
     return new ClinicalImpression(payload);
   }
-
-  static fromPalliativeAssessment({ assessment }) {
-    const payload = {
-      resourceType: 'ClinicalImpression',
-      id: fhirId(assessment.assessmentId),
-      identifier: [identifier(PALLIATIVE_ASSESSMENT_SLUG, assessment.assessmentId)],
-      status: 'completed',
-      subject: patientReference(assessment.patientId),
-      effectiveDateTime: toIso(assessment.committedAt),
-      finding: assessment.findings.map(palliativeFinding),
-      extension: [extension('palliative-turn-id', { valueString: assessment.turnId })],
-    };
-    if (assessment.evaluationSummary) payload.summary = assessment.evaluationSummary;
-    if (assessment.rankingRationale) payload.description = assessment.rankingRationale;
-    if (assessment.escalationReason) payload.note = [{ text: assessment.escalationReason }];
-    return new ClinicalImpression(payload);
-  }
-}
-
-function palliativeFinding(finding) {
-  const extensions = [
-    extension('palliative-finding-rank', { valueInteger: finding.rank }),
-    extension('palliative-finding-element-type', { valueString: finding.elementType }),
-    extension('palliative-finding-time-window', { valueString: finding.timeWindow }),
-    extension('palliative-finding-clinical-description', { valueString: finding.clinicalDescription }),
-    extension('palliative-finding-why-relevant', { valueString: finding.whyRelevant }),
-    extension('palliative-finding-qol-criteria', { valueString: finding.qolCriteria }),
-    extension('palliative-finding-improvement-criteria', { valueString: finding.improvementCriteria }),
-    extension('palliative-finding-characterization-criteria', { valueString: finding.characterizationCriteria }),
-    extension('palliative-finding-audit-notes', { valueString: finding.auditNotes }),
-  ];
-  for (const term of finding.symptomTerms) extensions.push(extension('palliative-finding-symptom-term', { valueString: term }));
-  for (const question of finding.probeQuestions) extensions.push(extension('palliative-finding-probe-question', { valueString: question }));
-  if (finding.qolImpact !== null) extensions.push(extension('palliative-finding-qol-impact', { valueString: finding.qolImpact }));
-  if (finding.improvementCapacity !== null) extensions.push(extension('palliative-finding-improvement-capacity', { valueString: finding.improvementCapacity }));
-  if (finding.areMedsNeeded !== null) extensions.push(extension('palliative-finding-are-meds-needed', { valueBoolean: finding.areMedsNeeded }));
-  if (finding.needsCharacterization !== null) extensions.push(extension('palliative-finding-needs-characterization', { valueBoolean: finding.needsCharacterization }));
-  if (finding.clusterNote !== null) extensions.push(extension('palliative-finding-cluster-note', { valueString: finding.clusterNote }));
-  return { item: { concept: codeableConcept(finding.nameShort) }, extension: extensions };
 }
 
 module.exports = {

package/lib/fhir/resources/Provenance.js

@@ -89,26 +89,6 @@ class Provenance {
     });
   }
 
-  static fromSafetyGate({ gate }) {
-    return Provenance.fromSymptomCase({
-      provenanceId: `${gate.runId}-safety-prov`,
-      targetRefs: [{ reference: `RiskAssessment/${fhirId(`${gate.runId}-safety`)}` }],
-      recordedAt: gate.createdAt,
-      activityText: 'recommendation-safety-gate',
-    });
-  }
-
-  static fromRecommendationPlan({ plan, targetRefs }) {
-    return new Provenance({
-      resourceType: 'Provenance',
-      id: fhirId(`${plan.runId}-careplan-prov`),
-      target: targetRefs,
-      recorded: toIso(plan.createdAt),
-      agent: [{ who: reference('Device', getDeviceId()), onBehalfOf: reference('Organization', getOrganizationId()) }],
-      activity: codeableConcept('recommendations-process'),
-    });
-  }
-
   static fromContingency({ planId, recipients, recordedAt, activityText }) {
     const targets = [{ reference: `CarePlan/${fhirId(planId)}` }];
     for (const recipient of recipients) {

package/lib/fhir/resources/RiskAssessment.js

@@ -8,30 +8,13 @@ const {
   extension,
   toIso,
 } = require('../helpers/elementHelper');
-const { PATIENT_RISK_SLUG, SAFETY_GATE_SLUG } = require('../constants/projectionSlugs');
+const { PATIENT_RISK_SLUG } = require('../constants/projectionSlugs');
 
 const RISK_SEVERITY_CODESYSTEM = 'risk-severity';
 const PREDICTION_KIND_AE = 'ae';
 const PREDICTION_KIND_DISEASE = 'disease';
 const PREDICTION_KIND_COMORBIDITY = 'comorbidity';
 
-const PROBABILITY_TO_RISK = { high: 'high', medium: 'moderate', low: 'low' };
-const PREDICTION_BASIS_STATUSES = ['confirmed', 'partially_confirmed'];
-
-function safetyGatePrediction(ae) {
-  const risk = PROBABILITY_TO_RISK[ae.probabilityGivenPatient] || ae.probabilityGivenPatient;
-  const prediction = {
-    outcome: codeableConcept(ae.ctcaeTerm),
-    qualitativeRisk: codeableConcept(risk, { code: risk, system: codeSystemUrl(RISK_SEVERITY_CODESYSTEM) }),
-  };
-  const rationaleBits = [];
-  if (ae.whyIsRelevant) rationaleBits.push(ae.whyIsRelevant);
-  const grounding = ae.groundedIn.filter(Boolean).join('; ');
-  if (grounding) rationaleBits.push(`sustento: ${grounding}`);
-  if (rationaleBits.length) prediction.rationale = rationaleBits.join(' | ');
-  return prediction;
-}
-
 function aePrediction(ae) {
   const prediction = {
     outcome: codeableConcept(ae.aeName),
@@ -106,28 +89,6 @@ class RiskAssessment {
     if (extensions.length) payload.extension = extensions;
     return new RiskAssessment(payload);
   }
-
-  static fromSafetyGate({ gate }) {
-    const payload = {
-      resourceType: 'RiskAssessment',
-      id: fhirId(`${gate.runId}-safety`),
-      identifier: [identifier(SAFETY_GATE_SLUG, `${gate.runId}-safety`)],
-      status: 'final',
-      subject: patientReference(gate.patientId),
-      performer: reference('Device', getDeviceId()),
-      occurrenceDateTime: toIso(gate.createdAt),
-    };
-    const prediction = gate.redFlags
-      .filter((redFlag) => PREDICTION_BASIS_STATUSES.includes(redFlag.verificationStatus))
-      .flatMap((redFlag) => redFlag.relatedAes.map(safetyGatePrediction));
-    if (prediction.length) payload.prediction = prediction;
-    if (gate.summary) payload.note = [{ text: gate.summary }];
-    if (gate.urgentUnder24h && gate.escalationRoute) {
-      payload.mitigation = `ruta de escalamiento: ${gate.escalationRoute}`
-        + (gate.maxActionTimeHours ? `; actuar en ≤${gate.maxActionTimeHours}h` : '');
-    }
-    return new RiskAssessment(payload);
-  }
 }
 
 module.exports = {

package/lib/fhir/resources/Task.js

@@ -16,8 +16,6 @@ const {
   INTERVENTION_KIND_SLUG,
   INTERVENTION_OUTCOME_SLUG,
   ROUTING_DISPOSITION_SLUG,
-  RECOMMENDATION_REC_SLUG,
-  PALLIATIVE_ESCALATION_SLUG,
 } = require('../constants/projectionSlugs');
 const { SEVERITY_TO_PRIORITY } = require('../constants/severityPriority');
 const { interventionExtensions } = require('./interventionExtensions');
@@ -85,61 +83,6 @@ class Task {
     return new Task(payload);
   }
 
-  static fromRecommendationPlan({ plan, element, taskId }) {
-    const { recommendation } = element;
-    const { patient } = recommendation;
-    const code = {
-      text: element.nameShort,
-      coding: element.targetedCtcaeTerms.map((term) => ({
-        system: codeSystemUrl('pro-ctcae'), code: term, display: term,
-      })),
-    };
-    const noteTexts = [];
-    if (patient.whenToEscalate) noteTexts.push(`cuándo escalar: ${patient.whenToEscalate}`);
-    if (patient.expectedEffectiveness) noteTexts.push(`efectividad esperada: ${patient.expectedEffectiveness}`);
-    if (patient.contraindications) noteTexts.push(`contraindicaciones: ${patient.contraindications}`);
-    noteTexts.push(`requiere coordinación farmacológica: ${recommendation.isPharmacologicalMedNeeded}`);
-    const payload = {
-      resourceType: 'Task',
-      id: fhirId(taskId),
-      identifier: [identifier(RECOMMENDATION_REC_SLUG, taskId)],
-      status: 'requested',
-      intent: 'plan',
-      code,
-      description: patient.mainRecommendation,
-      for: patientReference(plan.patientId),
-      authoredOn: toIso(plan.createdAt),
-      requester: reference('Device', getDeviceId()),
-      note: noteTexts.map((text) => ({ text })),
-    };
-    return new Task(payload);
-  }
-
-  static fromPalliativeEscalation({ assessmentId, committedAt, finding, deviceId }) {
-    const { escalation } = finding;
-    const start = new Date(committedAt);
-    const end = new Date(start.getTime() + escalation.maxActionTimeHours * 3600000);
-    const payload = {
-      resourceType: 'Task',
-      id: fhirId(`${assessmentId}-${finding.rank}`),
-      identifier: [identifier(PALLIATIVE_ESCALATION_SLUG, `${assessmentId}-${finding.rank}`)],
-      status: 'requested',
-      intent: 'order',
-      priority: 'urgent',
-      code: codeableConcept(finding.nameShort),
-      description: escalation.escalationReason,
-      for: patientReference(escalation.patientId),
-      authoredOn: toIso(committedAt),
-      requester: reference('Device', deviceId),
-      restriction: { period: { end: toIso(end) } },
-      extension: [extension('palliative-escalation-rank', { valueInteger: finding.rank })],
-    };
-    if (escalation.escalationRoutes.length) {
-      payload.requestedPerformer = escalation.escalationRoutes.map((route) => ({ concept: codeableConcept(route) }));
-    }
-    return new Task(payload);
-  }
-
   static fromRoutingDisposition({ disposition }) {
     const payload = {
       resourceType: 'Task',

package/lib/fhir/services/riskService.js

@@ -4,7 +4,6 @@ const { fhirId } = require('../helpers/fhirHelper');
 const { identifierValue, extValues } = require('../helpers/fhirReadHelper');
 const { PATIENT_RISK_SLUG } = require('../constants/projectionSlugs');
 const { PROJECTOR_NAME } = require('../projections/riskProjection');
-const { PROJECTOR_NAME: SAFETY_GATE_PROJECTOR_NAME } = require('../projections/safetyGateProjection');
 const {
   PREDICTION_KIND_AE,
   PREDICTION_KIND_DISEASE,
@@ -44,22 +43,6 @@ async function readPatientRisk({ patientId }) {
   return null;
 }
 
-async function storeSafetyGate({ patientId, safetyGate }) {
-  if (safetyGate.patientId !== patientId) {
-    throw new Error(`storeSafetyGate patientId mismatch: expected ${patientId}`);
-  }
-  const bundle = project([{ name: SAFETY_GATE_PROJECTOR_NAME, aggregate: safetyGate }]);
-  const resources = bundle.entry.map((entry) => entry.resource);
-  const { stored } = await storeResources(resources);
-  return { count: stored.length, ids: stored };
-}
-
-async function safetyGateExists({ runId }) {
-  const store = getFhirStore();
-  const resource = await store.getByKey(`Provenance|${fhirId(`${runId}-safety-prov`)}`);
-  return Boolean(resource);
-}
-
 function reconstructRisk(resource, patientId) {
   const predictions = resource.prediction || [];
   return {
@@ -115,6 +98,4 @@ const outcomeText = (prediction) => (prediction.outcome && prediction.outcome.te
 module.exports = {
   storePatientRisk,
   readPatientRisk,
-  storeSafetyGate,
-  safetyGateExists,
 };

package/package.json

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

package/lib/clinical/helpers/palliativeAssessmentHelper.js

@@ -1,62 +0,0 @@
-const crypto = require('node:crypto');
-
-const { PalliativeAssessment } = require('../../shared/dtos/PalliativeAssessment');
-
-const uid = (prefix) => `${prefix}_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
-
-function assessmentUid() {
-  return uid('pa');
-}
-
-function mapEscalation(raw, patientId) {
-  if (!raw || typeof raw !== 'object') return null;
-  return {
-    patientId,
-    maxActionTimeHours: raw.max_action_time_hours,
-    escalationRoutes: raw.escalation_routes || [],
-    escalationReason: raw.escalation_reason || '',
-  };
-}
-
-function mapFinding(raw, patientId) {
-  if (!raw || typeof raw !== 'object') return {};
-  return {
-    rank: raw.rank,
-    elementType: raw.element_type,
-    nameShort: raw.name_short,
-    timeWindow: raw.time_window || '',
-    symptomTerms: raw.symptom_terms || [],
-    clinicalDescription: raw.clinical_description || '',
-    whyRelevant: raw.why_relevant || '',
-    qolImpact: raw.qol_impact ?? null,
-    qolCriteria: raw.qol_criteria || '',
-    improvementCapacity: raw.improvement_capacity ?? null,
-    improvementCriteria: raw.improvement_criteria || '',
-    areMedsNeeded: raw.are_meds_needed ?? null,
-    needsCharacterization: raw.needs_characterization ?? null,
-    characterizationCriteria: raw.characterization_criteria || '',
-    probeQuestions: raw.probe_questions || [],
-    auditNotes: raw.audit_notes || '',
-    clusterNote: raw.cluster_note ?? null,
-    escalation: mapEscalation(raw.escalation, patientId),
-  };
-}
-
-function buildAssessment({ raw, assessmentId, patientId, turnId, committedAt }) {
-  const findings = Array.isArray(raw.findings) ? raw.findings : [];
-  return new PalliativeAssessment({
-    assessmentId,
-    patientId,
-    turnId,
-    committedAt,
-    evaluationSummary: raw.evaluation_summary || '',
-    rankingRationale: raw.ranking_rationale || '',
-    escalationReason: raw.escalation_reason ?? null,
-    findings: findings.map((finding) => mapFinding(finding, patientId)),
-  });
-}
-
-module.exports = {
-  assessmentUid,
-  buildAssessment,
-};

package/lib/clinical/models/patternConsultModel.js

@@ -1,37 +0,0 @@
-const mongoose = require('mongoose');
-
-const { clinicalConnection } = require('../config/connection');
-
-const patternConsultSchema = new mongoose.Schema({
-  consultationId: { type: String, required: true },
-  patientCode: { type: String, required: true },
-  turnId: { type: String, default: null },
-  concern: { type: String, default: null },
-  impressions: { type: Array, default: [] },
-  recommendedProbes: { type: [String], default: [] },
-  watchFor: { type: [String], default: [] },
-  escalationAdvice: { type: Object, default: null },
-  degraded: { type: Boolean, default: false },
-  degradedReasons: { type: [String], default: [] },
-}, { timestamps: true });
-
-patternConsultSchema.index({ consultationId: 1 }, { unique: true });
-patternConsultSchema.index({ patientCode: 1, createdAt: -1 });
-
-function patternConsultStore() {
-  const conn = clinicalConnection();
-  const model = conn.models.PatternConsult || conn.model('PatternConsult', patternConsultSchema, 'patternConsult');
-
-  return {
-    get(consultationId) {
-      return model.findOne({ consultationId }).lean();
-    },
-    put(doc) {
-      return model.create(doc);
-    },
-  };
-}
-
-module.exports = {
-  patternConsultStore,
-};