@peopl-health/nexus 5.69.0-dev.12295 → 5.69.0-dev.12578

package/lib/clinical/config/cohortConfig.js

@@ -65,4 +65,4 @@ function clearCohortCache() {
   inFlightRead = null;
 }
 
-module.exports = { isInCohort, clearCohortCache };
+module.exports = { isInCohort, isCohortEnabled, clearCohortCache };

package/lib/clinical/context/ToolRuntimeContext.js

@@ -56,6 +56,7 @@ class ToolRuntimeContext {
     this.skillActivationIteration = new Map();
     this.currentIteration = null;
     this.toolHistory = [];
+    this.toolRejections = [];
     this.safetyArtifact = null;
     this.palliativeAssessment = null;
     this.careplan = null;
@@ -93,9 +94,11 @@ class ToolRuntimeContext {
     this.trace.addStep({ iteration, ...toolData });
     if (toolData.success) this.toolHistory.push(toolData);
     if (!toolData.success || isToolFailure(toolData.tool_output)) {
+      const code = refusalCode(toolData.tool_output);
+      this.toolRejections.push({ tool: toolData.tool_name, code, iteration: iteration ?? null });
       logger.warn('[toolRuntime] tool call rejected', {
         tool: toolData.tool_name,
-        reason: refusalCode(toolData.tool_output),
+        reason: code,
         iteration: iteration ?? null,
         turnId: this.turnId || null,
       });
@@ -108,7 +111,7 @@ class ToolRuntimeContext {
   }
 
   async store({ outbound = null, completed = false, predictionTimeMs = null, error = null } = {}) {
-    this.trace.setSignals({ activatedSkills: [...this.activatedSkills].sort() });
+    this.trace.setSignals({ activatedSkills: [...this.activatedSkills].sort(), toolRejections: [...this.toolRejections] });
     this.trace.setOutbound(outbound || this.trace.outbound || null);
     const hasError = error !== null && error !== undefined;
     const isSuperseded = hasError ? false : !this.isLive();

package/lib/clinical/flags/emergencyConsultFlags.js

@@ -0,0 +1,16 @@
+const runtimeConfig = require('../../config/runtimeConfig');
+
+const MODES = ['off', 'shadow'];
+const DEFAULT_SAMPLE_RATE = 0.1;
+
+function emergencyConsultMode() {
+  const value = String(runtimeConfig.get('EMERGENCY_CONSULT_MODE', 'off')).trim().toLowerCase();
+  return MODES.includes(value) ? value : 'off';
+}
+
+function emergencyConsultSampleRate() {
+  const value = Number(runtimeConfig.get('EMERGENCY_CONSULT_SAMPLE_RATE', DEFAULT_SAMPLE_RATE));
+  return Number.isFinite(value) && value >= 0 && value <= 1 ? value : DEFAULT_SAMPLE_RATE;
+}
+
+module.exports = { emergencyConsultMode, emergencyConsultSampleRate };

package/lib/clinical/flags/flagSnapshot.js

@@ -0,0 +1,59 @@
+const { isCohortEnabled } = require('../config/cohortConfig');
+const { isBridgeEnabled } = require('./bridgeConfig');
+const { contextReadLive, contextMirrorLive, contextVerifierLive } = require('./clinicalContextFlags');
+const { clinicalPatternFloorLive } = require('./clinicalPatternFloorFlags');
+const { isComposerEnabled, isAgentSelfRenderEnabled } = require('./composerFlags');
+const { isContingencyCancelOnReplyLive, isArmOnOpenCeilingLive, isContingencyRuleBlockLive } = require('./contingencyFlags');
+const { escalationAssessmentLive, escalationUpdateModeLive } = require('./escalationFlags');
+const { inboundRecoveryLive, coldInboundMode } = require('./inboundRecoveryFlags');
+const { isLlmAuditEnabled } = require('./llmAuditConfig');
+const { isLlmMonitorEnabled } = require('./llmMonitorConfig');
+const { patternConsultLive } = require('./patternConsultFlags');
+const { recommendationRetryLive } = require('./recommendationRecoveryFlags');
+const { isShadowEnabled } = require('./shadowConfig');
+const { supportLightFromChatLive } = require('./supportLightFlags');
+const { triageGateFloorLive } = require('./triageGateFloorFlags');
+const { triageRecommendationLive, rankComparatorLive } = require('./triageRecommendationFlags');
+const { isConversationalDeclarationLive, isConversationalDraftReuseLive, isDeclarationModelCheckLive } = require('./turnEfficiencyFlags');
+
+const FLAG_READERS = {
+  cohort: isCohortEnabled,
+  bridge: isBridgeEnabled,
+  contextRead: contextReadLive,
+  contextMirror: contextMirrorLive,
+  contextVerifier: contextVerifierLive,
+  clinicalPatternFloor: clinicalPatternFloorLive,
+  composer: isComposerEnabled,
+  agentSelfRender: isAgentSelfRenderEnabled,
+  contingencyCancelOnReply: isContingencyCancelOnReplyLive,
+  armOnOpenCeiling: isArmOnOpenCeilingLive,
+  contingencyRuleBlock: isContingencyRuleBlockLive,
+  escalationAssessment: escalationAssessmentLive,
+  escalationUpdateMode: escalationUpdateModeLive,
+  inboundRecovery: inboundRecoveryLive,
+  coldInboundMode,
+  llmAudit: isLlmAuditEnabled,
+  llmMonitor: isLlmMonitorEnabled,
+  patternConsult: patternConsultLive,
+  recommendationRetry: recommendationRetryLive,
+  shadow: isShadowEnabled,
+  supportLightFromChat: supportLightFromChatLive,
+  triageGateFloor: triageGateFloorLive,
+  triageRecommendation: triageRecommendationLive,
+  rankComparator: rankComparatorLive,
+  conversationalDeclaration: isConversationalDeclarationLive,
+  conversationalDraftReuse: isConversationalDraftReuseLive,
+  declarationModelCheck: isDeclarationModelCheckLive,
+};
+
+function snapshotClinicalFlags() {
+  return Object.fromEntries(Object.entries(FLAG_READERS).map(([name, read]) => {
+    try {
+      return [name, read()];
+    } catch (error) {
+      return [name, null];
+    }
+  }));
+}
+
+module.exports = { snapshotClinicalFlags };

package/lib/clinical/helpers/clinicalWorkflowGuard.js

@@ -60,7 +60,7 @@ function routingSkillStep(trace, { enabledSkills = [], skillActivationIteration
 
   return {
     instruction: activatedAt != null
-      ? `read the ${ROUTING_SKILL} body returned to you (it was requested in this same response, so its content did not reach you)`
+      ? `read the ${ROUTING_SKILL} body returned to you (it was returned in this same response, so its content did not reach you yet)`
       : `call Skill with skill="${ROUTING_SKILL}" and read what it returns`,
     toolIds: [SKILL_TOOL],
   };
@@ -154,7 +154,7 @@ function validateClinicalDelivery(trace, { enabledSkills = [], skillActivationIt
   return {
     error: REFUSAL.skillBeforeDelivery,
     recovery: activatedAt != null
-      ? `The ${downstream} body was requested in this same response, so its content did not reach you. Read it, then compose the patient message from the rules it defines.`
+      ? `The ${downstream} body was returned in this same response, so its content did not reach you yet. Read it, then compose the patient message from the rules it defines.`
       : `The plan you committed routes to ${downstream}. Call Skill with skill="${downstream}", read the body it returns, then compose the patient message from the rules it defines.`,
     requiredToolIds: [SKILL_TOOL],
   };
@@ -166,6 +166,7 @@ module.exports = {
   ROUTING_SKILL,
   SKILL_TOOL,
   clinicalIntakeRequiresRisk,
+  hasAlternateTerminalCommit,
   hasUsableRiskContext,
   isPurelyConversational,
   validateClinicalDelivery,

package/lib/clinical/helpers/skillActivationHelper.js

@@ -0,0 +1,53 @@
+const { loadSkillBody } = require('../services/skillService');
+const { logger } = require('../../utils/logger');
+
+const { SKILL_TOOL } = require('./clinicalWorkflowGuard');
+
+function markSkillActivated(runtime, name) {
+  runtime?.activatedSkills?.add(name);
+  if (runtime?.skillActivationIteration && !runtime.skillActivationIteration.has(name)) {
+    runtime.skillActivationIteration.set(name, runtime.currentIteration ?? null);
+  }
+}
+
+// Hands the model a skill the workflow guard is about to require, inside the result of the tool that made it
+// required, so the turn does not spend an iteration being refused and then asking for it. The guard stays the net.
+async function attachRequiredSkill(runtime, name) {
+  if (!runtime || !name) return null;
+  if (!(runtime.enabledSkills || []).includes(name)) return null;
+  if (!(runtime.trace?.signals?.offeredToolIds || []).includes(SKILL_TOOL)) return null;
+  if (runtime.activatedSkills?.has(name)) return null;
+
+  try {
+    const { skill } = await loadSkillBody(name);
+    if (!skill) return null;
+    markSkillActivated(runtime, skill.name);
+    runtime.trace?.setSignals?.({ attachedSkills: [...(runtime.trace.signals?.attachedSkills || []), skill.name] });
+    return { name: skill.name, version: skill.version, body: skill.body };
+  } catch (error) {
+    logger.warn('[skillActivation] required skill could not be attached; the guard will ask for it', {
+      skill: name, turnId: runtime.turnId || null, error: error?.message,
+    });
+    return null;
+  }
+}
+
+// A skill body governs only the turn it was handed over in. Outside that turn (history replay, monitor evidence)
+// the attachment is dropped, as for a Skill call, whose output is never replayed.
+function withoutAttachedSkillBodies(output) {
+  let parsed = output;
+  if (typeof output === 'string') {
+    try { parsed = JSON.parse(output); } catch (error) { return output; }
+  }
+  const skills = parsed?.data?.activated_skills;
+  if (!Array.isArray(skills)) return output;
+  const { activated_skills: _attached, ...data } = parsed.data;
+  const stripped = { ...parsed, data };
+  return typeof output === 'string' ? JSON.stringify(stripped) : stripped;
+}
+
+module.exports = {
+  attachRequiredSkill,
+  markSkillActivated,
+  withoutAttachedSkillBodies,
+};

package/lib/clinical/monitoring/LlmMonitorService.js

@@ -230,7 +230,7 @@ class LlmMonitorService {
     if (!evaluation) return Evaluations.findOne(key);
 
     try {
-      const evidence = spec.buildEvidence(trace);
+      const evidence = await spec.buildEvidence(trace);
       let judge = null;
       let result = null;
       let judgePrompt = null;
@@ -248,12 +248,19 @@ class LlmMonitorService {
           text: { format: { type: 'json_schema', name: `${spec.id}_verdict`, schema: spec.schema, strict: true } },
           metadata: { source: 'llm_monitor', turn_id: trace.turnId, monitor_id: spec.id, monitor_version: String(spec.version) },
         });
-        judge = parseJudge(result);
-        spec.validateJudge?.(judge);
+        // A refusal repeats on retry, so a spec that can record it does not pay for it again.
+        const isFinalRefusal = result?.status === 'refused' && spec.refusalIsFinal === true;
+        if (result?.status && result.status !== 'completed' && !isFinalRefusal) {
+          throw new Error(`monitor judge did not complete: ${result.stop_reason || result.status}`);
+        }
+        if (!isFinalRefusal) {
+          judge = parseJudge(result);
+          spec.validateJudge?.(judge);
+        }
       }
       let findings = spec.interpret({ trace, evidence, judge });
       const evalKey = `${spec.id}:${spec.version}:${trace.turnId}`;
-      const passSampled = findings.length === 0 && stableFraction(evalKey) < this.passSampleRate;
+      const passSampled = findings.length === 0 && judge !== null && stableFraction(evalKey) < this.passSampleRate;
       if (passSampled) findings = [passFinding(judge)];
       findings = findings.map((finding, index) => ({
         ...finding,
@@ -552,6 +559,7 @@ class LlmMonitorService {
 
 module.exports = {
   LlmMonitorService,
+  stableFraction,
   EVALUATE_QUEUE,
   RECONCILE_QUEUE,
   _test: { stableFraction, findingId, needsSync, syncBacklogFilter, RECONCILE_BATCH_SIZE, MAX_EVALUATION_ATTEMPTS },

package/lib/clinical/monitoring/contingencyMonitorSpec.js

@@ -1,5 +1,6 @@
 const { patientMessageFromTrace } = require('../helpers/evidenceAnchorHelper');
 const { parseGradeEstimate, projectGradeEstimate } = require('../helpers/gradeEstimateHelper');
+const { withoutAttachedSkillBodies } = require('../helpers/skillActivationHelper');
 const { redactDirectIdentifiers } = require('../../utils/sanitizerUtils');
 const { logger } = require('../../utils/logger');
 
@@ -256,7 +257,7 @@ function compactStep(step) {
   return {
     tool_name: step.tool_name,
     arguments: minimized(step.tool_arguments || null),
-    output: minimized(step.tool_output || null),
+    output: minimized(withoutAttachedSkillBodies(step.tool_output) || null),
     success: step.success !== false,
     iteration: step.iteration ?? null,
   };

package/lib/clinical/monitoring/emergencyConsultMonitorSpec.js

@@ -0,0 +1,215 @@
+const { patientMessageFromTrace } = require('../helpers/evidenceAnchorHelper');
+const { buildConsultContext } = require('../services/emergencyConsultService');
+const { emergencyConsultSampleRate } = require('../flags/emergencyConsultFlags');
+const { URGENCY_RANK } = require('../../models/escalationReviewModel');
+const { isPlainObject } = require('../../utils/jsonUtils');
+
+const { stableFraction } = require('./LlmMonitorService');
+
+const MONITOR_ID = 'emergency_consult';
+const MONITOR_VERSION = '1';
+const PRESET_ID = 'sa_emergency_consult';
+const LEVELS = ['stat', 'asap', 'urgent', 'routine'];
+const IMMEDIATE_LEVELS = ['stat', 'asap'];
+const DISPOSITIONS = ['escalate_now', 'ask_first', 'no_escalation'];
+const STALE_AFTER_MS = 15 * 60 * 1000;
+const UNREADABLE_PATIENT = [400, 404];
+
+const strings = { type: 'array', items: { type: 'string' } };
+const nullableLevel = { anyOf: [{ type: 'string', enum: LEVELS }, { type: 'null' }] };
+
+const CONSULT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['disposition', 'urgency_level', 'confidence', 'clinical_reasoning', 'serious_differential', 'red_flags_present',
+    'red_flags_ruled_out', 'missing_information', 'level_if_unanswered', 'context_gaps', 'recommended_action', 'what_to_tell_patient'],
+  properties: {
+    disposition: { type: 'string', enum: DISPOSITIONS },
+    urgency_level: nullableLevel,
+    confidence: { type: 'string', enum: ['low', 'moderate', 'high'] },
+    clinical_reasoning: { type: 'string' },
+    serious_differential: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['condition', 'status', 'features'],
+        properties: {
+          condition: { type: 'string' },
+          status: { type: 'string', enum: ['supported', 'not_excluded', 'unlikely'] },
+          features: strings,
+        },
+      },
+    },
+    red_flags_present: strings,
+    red_flags_ruled_out: strings,
+    missing_information: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['question_for_patient', 'why', 'level_if_positive'],
+        properties: {
+          question_for_patient: { type: 'string' },
+          why: { type: 'string' },
+          level_if_positive: { type: 'string', enum: LEVELS },
+        },
+      },
+    },
+    level_if_unanswered: nullableLevel,
+    context_gaps: strings,
+    recommended_action: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['now', 'notify'],
+      properties: {
+        now: { type: 'string' },
+        notify: { type: 'string', enum: ['none', 'team_review', 'treating_team_today', 'oncologist_now', 'emergency_services'] },
+      },
+    },
+    what_to_tell_patient: { type: 'string' },
+  },
+};
+
+const asArray = (value) => (Array.isArray(value) ? value : []);
+
+function triggers(trace) {
+  const signals = trace?.signals || {};
+  const found = [];
+  if (signals.medicalEscalation) found.push('medical_escalation');
+  if (asArray(signals.safetyFlags).length) found.push('safety_flags');
+  if (asArray(signals.activatedSkills).includes('emergency')) found.push('emergency_skill');
+  if (!found.length && asArray(signals.clinicalMentions).length
+    && stableFraction(`${MONITOR_ID}:${trace.turnId}`) < emergencyConsultSampleRate()) found.push('mention_sample');
+  return found;
+}
+
+function isEligible(trace) {
+  return trace?.status === 'completed'
+    && trace?.shadow !== true
+    && triggers(trace).length > 0;
+}
+
+function agentDecision(trace) {
+  const escalation = trace.signals?.medicalEscalation;
+  if (!escalation) return { escalated: false, level: null, requestedLevel: null, patternFloor: null };
+  return {
+    escalated: true,
+    level: escalation.urgencyLevel || null,
+    requestedLevel: escalation.requestedUrgencyLevel || null,
+    patternFloor: escalation.clinicalPatternFloor || null,
+  };
+}
+
+const mentionFacts = (trace) => asArray(trace.signals?.clinicalMentions)
+  .map(({ fact }) => {
+    if (!isPlainObject(fact)) return null;
+    const { patientId: _patientId, mentionId: _mentionId, ...rest } = fact;
+    return rest;
+  })
+  .filter(Boolean);
+
+async function buildEvidence(trace, now = Date.now()) {
+  // The trace is saved once the turn ends, so the turn started predictionTimeMs before createdAt.
+  const turnStart = new Date(trace.createdAt).getTime() - (trace.timings?.predictionTimeMs || 0);
+  const base = { triggers: triggers(trace), agent: agentDecision(trace), lag_ms: now - turnStart };
+  if (base.lag_ms > STALE_AFTER_MS) return { ...base, extraction_succeeded: false, degraded: 'stale' };
+  try {
+    const { input, degradedSections, hasCoreContext } = await buildConsultContext({
+      code: trace.patientCode,
+      turnStart,
+      patientMessage: patientMessageFromTrace(trace),
+      mentions: mentionFacts(trace),
+    });
+    if (!hasCoreContext) return { ...base, extraction_succeeded: false, degraded: 'core_context_missing', degraded_sections: degradedSections };
+    return { ...base, extraction_succeeded: true, input, degraded_sections: degradedSections };
+  } catch (error) {
+    if (!UNREADABLE_PATIENT.includes(error?.statusCode)) throw error;
+    return { ...base, extraction_succeeded: false, degraded: 'patient_unreadable', error: error.message };
+  }
+}
+
+function buildJudgeInput(evidence) {
+  return [{ role: 'user', content: evidence.input }];
+}
+
+function validateJudge(judge) {
+  if (!isPlainObject(judge) || !DISPOSITIONS.includes(judge.disposition)) {
+    throw new Error('emergency consult returned no valid disposition');
+  }
+}
+
+function invariantViolations(judge) {
+  const violations = [];
+  const askFirst = judge.disposition === 'ask_first';
+  if (judge.disposition === 'escalate_now' && !judge.urgency_level) violations.push('escalate_now_without_level');
+  if (askFirst && !asArray(judge.missing_information).length) violations.push('ask_first_without_questions');
+  if (askFirst && !judge.level_if_unanswered) violations.push('ask_first_without_level_if_unanswered');
+  if (askFirst && [judge.urgency_level, judge.level_if_unanswered].some((level) => IMMEDIATE_LEVELS.includes(level))) {
+    violations.push('ask_first_on_immediate_level');
+  }
+  if (judge.disposition !== 'escalate_now' && asArray(judge.red_flags_present).length) violations.push('red_flags_without_escalation');
+  return violations;
+}
+
+const rank = (level) => URGENCY_RANK[level] || 0;
+
+function consultFinding(fields) {
+  return {
+    type: 'emergency_consult',
+    severity: 'normal',
+    confidence: 'high',
+    opsReviewRequired: false,
+    targetId: null,
+    observedCallIndex: null,
+    ...fields,
+  };
+}
+
+function interpret({ evidence, judge }) {
+  if (!evidence.extraction_succeeded || !judge) {
+    return [consultFinding({
+      expectedAction: null,
+      observedAction: evidence.agent?.level || null,
+      criteria: { degraded: evidence.extraction_succeeded ? 'judge_refused' : evidence.degraded },
+      summary: 'El especialista no evaluó el turno.',
+      evidence: evidence.error || 'Sin detalle.',
+    })];
+  }
+  const specialistLevel = judge.disposition === 'ask_first' ? judge.level_if_unanswered : judge.urgency_level;
+  const agentLevel = evidence.agent?.level || null;
+  return [consultFinding({
+    expectedAction: specialistLevel || null,
+    observedAction: agentLevel,
+    criteria: {
+      disposition: judge.disposition,
+      agent_below_specialist: rank(agentLevel) < rank(specialistLevel),
+      invariant_violations: invariantViolations(judge),
+    },
+    summary: `Especialista: ${judge.disposition} ${specialistLevel || 'sin nivel'}; agente: ${agentLevel || 'sin escalamiento'}.`,
+    evidence: judge.clinical_reasoning || 'Sin razonamiento.',
+  })];
+}
+
+const emergencyConsultMonitorSpec = {
+  id: MONITOR_ID,
+  version: MONITOR_VERSION,
+  presetId: PRESET_ID,
+  schema: CONSULT_SCHEMA,
+  refusalIsFinal: true,
+  reconcileQuery: {
+    $or: [
+      { 'signals.medicalEscalation': { $exists: true } },
+      { 'signals.safetyFlags.0': { $exists: true } },
+      { 'signals.activatedSkills': 'emergency' },
+      { 'signals.clinicalMentions.0': { $exists: true } },
+    ],
+  },
+  isEligible,
+  buildEvidence,
+  buildJudgeInput,
+  validateJudge,
+  interpret,
+};
+
+module.exports = { emergencyConsultMonitorSpec };

package/lib/clinical/providers/AnthropicProvider.js

@@ -240,7 +240,7 @@ class AnthropicProvider extends BaseLLMProvider {
           if (lastUserTurn?.role === 'user') {
             deliveryNudges++;
             previousRoundTools = [];
-            trace?.setSignals?.({ deliveryNudges });
+            trace?.setSignals?.({ deliveryNudges, nudgeKind: canDecide ? 'outreach' : 'delivery' });
             logger.warn('[AnthropicProvider] Turn will not close — nudging', { tool: canDecide ? OUTREACH_DECISION_TOOL : 'DeliverPatientMessage', deliveryNudges, hasEnded, isBudgetSpent });
             const turnContent = Array.isArray(lastUserTurn.content)
               ? lastUserTurn.content
@@ -348,15 +348,27 @@ class AnthropicProvider extends BaseLLMProvider {
     };
     if (system) apiConfig.system = system;
 
+    // Always-thinking models (Opus/Sonnet 5.5) reject a forced tool_choice; presets opt into output_config.format instead.
+    const nativeFormat = modelConfig.structured_mode === 'output_format';
+    if (nativeFormat) {
+      const effort = modelConfig.reasoning?.effort;
+      if (effort) apiConfig.output_config = { effort: effort === 'minimal' ? 'low' : effort };
+      if (modelConfig.thinking) apiConfig.thinking = modelConfig.thinking;
+    }
+
     const spec = text || modelConfig.text;
     let tool = null;
     if (spec) {
       const format = spec.format ? spec.format : spec;
       if (!format.schema) throw new Error('runStructured: format spec has no schema');
-      tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
-      if (format.strict !== undefined) tool.strict = format.strict;
-      apiConfig.tools = [tool];
-      apiConfig.tool_choice = { type: 'tool', name: tool.name };
+      if (nativeFormat) {
+        apiConfig.output_config = { ...apiConfig.output_config, format: { type: 'json_schema', schema: format.schema } };
+      } else {
+        tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
+        if (format.strict !== undefined) tool.strict = format.strict;
+        apiConfig.tools = [tool];
+        apiConfig.tool_choice = { type: 'tool', name: tool.name };
+      }
     }
 
     const { result: { result }, durationMs } = await withTiming(() =>

package/lib/clinical/providers/BaseLLMProvider.js

@@ -10,6 +10,7 @@ const { resolveSkillCatalog } = require('../services/skillService');
 const { RISK_HEADLINE_MARKER } = require('../services/riskHeadlineService');
 const { resolveClinicalContext } = require('../services/clinicalContextReadService');
 const { isContingencyRuleBlockLive } = require('../flags/contingencyFlags');
+const { snapshotClinicalFlags } = require('../flags/flagSnapshot');
 const { TURN_KIND } = require('../context/turnContext');
 const { extractPatientMessage } = require('../../helpers/patientMessageHelper');
 const runtimeConfig = require('../../config/runtimeConfig');
@@ -102,7 +103,7 @@ class BaseLLMProvider {
       presetId: resolvedPresetId, presetVersion: resolvedPresetVersion, modelConfig,
     } = await composePrompt({ presetId, presetVersion, promptId: assistantId, variables: promptVariables });
 
-    const { toolIds, filtered, descriptions: toolDescriptions } = await resolveTools({
+    const { toolIds, filtered, descriptions: toolDescriptions, unregisteredToolIds = [] } = await resolveTools({
       promptId: resolvedPromptId || assistantId, assistant, presetToolIds,
     });
     const requestedAdditionalToolIds = Array.isArray(prePromptResult?.additionalToolIds)
@@ -200,7 +201,12 @@ class BaseLLMProvider {
     }
 
     trace?.setPrompt({ resolvedPresetId, resolvedPresetVersion });
-    trace?.setSignals?.({ offeredToolIds: effectiveToolIds, enabledSkills });
+    trace?.setSignals?.({
+      offeredToolIds: effectiveToolIds,
+      enabledSkills,
+      flags: snapshotClinicalFlags(),
+      ...(unregisteredToolIds.length > 0 && { unregisteredToolIds }),
+    });
 
     const { response, toolsExecuted, retries, usage } = await this._invokeModel({
       instructions: instructions || devContent || '',
@@ -619,6 +625,11 @@ class BaseLLMProvider {
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
         logger.info('[runConversation] Attempt', { attempt, maxRetries, threadId, assistantId });
+        // A retry starts from the original input, so a skill body handed over in an earlier attempt is not in context.
+        if (attempt > 1) {
+          config?.assistant?.toolRuntimeContext?.activatedSkills?.clear();
+          config?.assistant?.toolRuntimeContext?.skillActivationIteration?.clear();
+        }
 
         const result = await this._executeConversation(config);
         // DeliverPatientMessage is the curated patient reply; prefer it over any model narration in the final response.

package/lib/clinical/services/clinicalExtractionService.js

@@ -19,6 +19,7 @@ const { logger } = require('../../utils/logger');
 const CONFIG_TABLE = 'registry';
 const CACHE_TTL = 5 * 60 * 1000;
 const CONFIG_CACHE_KEY = 'clinicalExtractorConfig';
+const ENDING_STATUSES = new Set(['paused', 'completed']);
 
 const extractorConfigCache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
 
@@ -37,6 +38,12 @@ function namesNothingSpecific(canonicalTerm, vagueWords) {
   return tokens.length > 0 && tokens.every((token) => vagueWords.has(token));
 }
 
+function endsNamedLine(raw, fact) {
+  return fact.category === 'treatment'
+    && Boolean(raw.treatment_line)
+    && ENDING_STATUSES.has(fact.observedFields?.status);
+}
+
 async function loadPatientContext(code) {
   try {
     const { clinicalContext, contextAsk } = await getClinicalContext(code);
@@ -115,7 +122,8 @@ async function extractClinicalMentions({ text, turnId, code, provider, detectedT
         unanchored += 1;
         return;
       }
-      if (!mention.provenance.needsConfirmation && namesNothingSpecific(mention.fact.canonicalTerm, vagueWords)) {
+      if (!mention.provenance.needsConfirmation && !endsNamedLine(raw, mention.fact)
+        && namesNothingSpecific(mention.fact.canonicalTerm, vagueWords)) {
         forcedPending += 1;
         mention = toClinicalMention(
           { ...raw, needs_confirmation: true, missing: raw.missing?.length ? raw.missing : ['name'] },

package/lib/clinical/services/clinicalPatternFloorService.js

@@ -1,3 +1,5 @@
+const crypto = require('crypto');
+
 const { getEscalationPatternFloor } = require('../config/subAgentsConfig');
 const { requireGatewayProvider } = require('../config/llmConfig');
 const { readClinicalProfile } = require('../helpers/clinicalProfileHelper');
@@ -9,13 +11,17 @@ const { isPlainObject, safeParse } = require('../../utils/jsonUtils');
 const { logger } = require('../../utils/logger');
 const { redactDirectIdentifiers } = require('../../utils/sanitizerUtils');
 const { withTimeout } = require('../../utils/timeoutUtils');
+const { composePrompt } = require('./promptComposerService');
 
 const FLOOR_LEVELS = ['asap', 'stat'];
 const PATTERN_NAME = /^[a-z0-9_]{1,64}$/;
 const UNLABELLED_PATTERN = 'sin_etiqueta';
 const MAX_TEXT_LENGTH = 500;
+const MAX_LEVEL_LENGTH = 32;
+const MAX_PATTERN_LENGTH = 64;
+const PROVENANCE_GRACE_MS = 500;
 
-const degraded = (reason) => ({ floor: null, degraded: reason });
+const degraded = (reason, check = null) => ({ floor: null, degraded: reason, check });
 
 function normalizePattern(raw) {
   const name = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
@@ -24,6 +30,32 @@ function normalizePattern(raw) {
 
 const clippedText = (value) => cleanText(value)?.slice(0, MAX_TEXT_LENGTH) || null;
 
+// Which prompt judged this escalation. Prompt text is edited in Airtable without bumping the preset
+// version, so the version alone cannot tell two prompts apart; the hash of the composed prompt can.
+async function promptProvenance(presetId, turnId) {
+  try {
+    // Composed alongside runStructured's own compose, with the same inputs and caches: it names the prompt
+    // the model ran with, though an Airtable edit landing between the two reads could make them differ.
+    const composed = await composePrompt({ presetId });
+    // A missing preset composes to an empty prompt; a hash of nothing would read as real provenance.
+    const promptHash = composed.resolvedPrompt
+      ? crypto.createHash('sha256').update(`${composed.resolvedPrompt}\n${JSON.stringify(composed.modelConfig || null)}`).digest('hex').slice(0, 12)
+      : null;
+    return { presetId, presetVersion: composed.presetVersion || null, promptHash };
+  } catch (error) {
+    logger.warn('[clinicalPatternFloor] The prompt provenance could not be read', { turnId, error: error.message });
+    return { presetId, presetVersion: null, promptHash: null };
+  }
+}
+
+// What the model answered, before validation, so a rejected or empty answer can be audited too.
+const rawOutput = (parsed) => ({
+  minLevel: typeof parsed.min_level === 'string' ? parsed.min_level.slice(0, MAX_LEVEL_LENGTH) : null,
+  pattern: typeof parsed.pattern === 'string' ? parsed.pattern.slice(0, MAX_PATTERN_LENGTH) : null,
+  evidence: clippedText(parsed.evidence),
+  reason: clippedText(parsed.reason),
+});
+
 function buildPatternInput({ profile, details, justification, today }) {
   const indicators = Array.isArray(details.indicators) ? details.indicators.filter((item) => typeof item === 'string' && item.trim()) : [];
   const exposure = buildExposureBlock(profile);
@@ -55,32 +87,42 @@ async function evaluatePatternFloor({ code, turnId, details, justification, prov
     logger.warn('[clinicalPatternFloor] The clinical profile is missing or unreadable; the check is skipped', { turnId, profile: reason });
     return degraded(reason);
   }
+  // Read alongside the model call so the audit never spends the floor's deadline.
+  const pendingProvenance = promptProvenance(presetId, turnId);
   const result = await (provider || requireGatewayProvider()).runStructured({
     presetId,
     input: [{ role: 'user', content: buildPatternInput({ profile, details, justification, today: now.toISOString().slice(0, 10) }) }],
     metadata: { subAgent: 'escalation-pattern-floor', turnId },
   });
+  // Once the model has answered, provenance gets a short grace and is otherwise dropped: a slow
+  // Airtable read must never turn an answer the floor already has into a timeout.
+  const provenance = await withTimeout(pendingProvenance, PROVENANCE_GRACE_MS, 'pattern floor provenance').catch((error) => {
+    logger.warn('[clinicalPatternFloor] The prompt provenance was not ready; the answer is kept without it', { turnId, error: error.message });
+    return { presetId, presetVersion: null, promptHash: null };
+  });
   if (result?.status && result.status !== 'completed') {
     logger.warn('[clinicalPatternFloor] The pattern check did not complete', { turnId, status: result.status });
-    return degraded('incomplete');
+    return degraded('incomplete', { ...provenance, output: null });
   }
   const parsed = safeParse(readStructuredText(result), null);
   if (!isPlainObject(parsed)) {
     logger.warn('[clinicalPatternFloor] The pattern check did not return a JSON object', { turnId });
-    return degraded('malformed_output');
+    return degraded('malformed_output', { ...provenance, output: null });
   }
+  const check = { ...provenance, output: rawOutput(parsed) };
   if (parsed.min_level == null) {
-    if (parsed.pattern == null) return { floor: null, degraded: null };
+    if (parsed.pattern == null) return { floor: null, degraded: null, check };
     logger.warn('[clinicalPatternFloor] The pattern check named a pattern without a level', { turnId, pattern: parsed.pattern });
-    return degraded('missing_level');
+    return degraded('missing_level', check);
   }
   if (!FLOOR_LEVELS.includes(parsed.min_level)) {
     logger.warn('[clinicalPatternFloor] The pattern check returned an unsupported level', { turnId, minLevel: parsed.min_level, pattern: parsed.pattern });
-    return degraded('unsupported_level');
+    return degraded('unsupported_level', check);
   }
   return {
     floor: { level: parsed.min_level, pattern: normalizePattern(parsed.pattern), evidence: clippedText(parsed.evidence), reason: clippedText(parsed.reason) },
     degraded: null,
+    check,
   };
 }
 

package/lib/clinical/services/emergencyConsultService.js

@@ -0,0 +1,76 @@
+const { readClinicalProfile } = require('../helpers/clinicalProfileHelper');
+const { buildExposureBlock } = require('../helpers/triageCaseBaseHelper');
+const { readDispatchedEscalations } = require('../../fhir');
+const { getEscalationContext } = require('../../services/escalationContextService');
+const { redactDirectIdentifiers } = require('../../utils/sanitizerUtils');
+const { assembleRiskProfile } = require('./riskAssessmentService');
+const { escalationLookbackSince } = require('./turnRiskBriefService');
+
+const CONTEXT_SECTIONS = ['agentContext', 'conversation', 'history'];
+const MAX_INPUT_CHARS = 120000;
+
+const optional = (promise) => promise.catch(() => undefined);
+
+// The conversation ends with this turn's own reply; the consult must not read the decision it is judging.
+function conversationBeforeReply(conversation) {
+  const messages = Array.isArray(conversation) ? [...conversation] : [];
+  while (messages.length && messages[messages.length - 1].role === 'assistant') messages.pop();
+  return messages;
+}
+
+function clinicalProfile(profile) {
+  if (!profile) return undefined;
+  const { edad = null, sexo = null } = profile.demografia || {};
+  return { demografia: { edad, sexo }, datos_clinicos: profile.datos_clinicos ?? null };
+}
+
+const section = (title, value) => [`## ${title}`, value === undefined ? 'no disponible' : JSON.stringify(value), ''];
+
+function fitConversation(head, conversation) {
+  const messages = [...conversation];
+  let text = section('Conversación', messages).join('\n');
+  while (messages.length && head.length + text.length > MAX_INPUT_CHARS) {
+    messages.shift();
+    text = section('Conversación', messages).join('\n');
+  }
+  return { text, truncated: messages.length < conversation.length };
+}
+
+async function buildConsultContext({ code, turnStart, patientMessage = null, mentions = [] }) {
+  const asOf = new Date(turnStart);
+  const [context, profile, risk, escalations] = await Promise.all([
+    getEscalationContext({ code, sections: CONTEXT_SECTIONS }),
+    readClinicalProfile(code),
+    optional(assembleRiskProfile(code)),
+    optional(readDispatchedEscalations({ patientId: code, since: escalationLookbackSince(asOf.getTime()) })),
+  ]);
+  const exposure = buildExposureBlock(profile);
+  const degradedSections = [...context.degradedSections];
+  if (!profile) degradedSections.push('clinicalProfile');
+  if (risk === undefined) degradedSections.push('risk');
+  if (escalations === undefined) degradedSections.push('escalations');
+
+  const head = [
+    `Fecha de hoy: ${asOf.toISOString().slice(0, 10)}`,
+    '',
+    '## Mensaje del paciente en este turno',
+    patientMessage || 'no capturado',
+    '',
+    ...section('Menciones clínicas extraídas en este turno', mentions),
+    ...section('Contexto clínico que ve la enfermera', context.agentContext ?? undefined),
+    '## Exposición antineoplásica y medicación documentadas',
+    exposure || 'no documentada',
+    '',
+    ...section('Perfil clínico', clinicalProfile(profile)),
+    ...section('Perfil de riesgo', risk?.profile ?? undefined),
+    ...section('Escalamientos de los últimos 14 días', escalations?.filter((event) => Date.parse(event.escalatedAt) < asOf.getTime())),
+    ...section('Historia clínica reciente', context.history ?? undefined),
+  ].join('\n');
+  const conversation = fitConversation(head, conversationBeforeReply(context.conversation));
+  if (conversation.truncated) degradedSections.push('conversation_truncated');
+  const input = `${head}\n${conversation.text}`;
+
+  return { input: redactDirectIdentifiers(input), degradedSections, hasCoreContext: Boolean(context.agentContext || profile) };
+}
+
+module.exports = { buildConsultContext };

package/lib/clinical/services/outreachSweepService.js

@@ -62,7 +62,6 @@ const CONTACT_SENT = {
 const RECENT_OUTBOUND_HOURS = 24;
 const COLLIDING_REMINDER_MINUTES = 24 * 60;
 const INACTIVITY_DAYS = 7;
-const MAX_SILENCE_DAYS = 30;
 const TRIAGE_PROTECTION_START_MINUTE = (7 * 60) + 30;
 const TRIAGE_PROTECTION_END_MINUTE = 11 * 60;
 
@@ -270,13 +269,11 @@ async function rejectionReason(candidate, {
       if (!await mondayTriageStillPending(candidate)) return 'triage_no_longer_pending';
     } else if (cadence === 'daily') {
       const inactiveSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(INACTIVITY_DAYS, 'days').toDate();
-      const silentSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(MAX_SILENCE_DAYS, 'days').toDate();
-      const [lastInbound] = await getMessages(
-        { numero: candidate.code, from_me: false, createdAt: { $gte: silentSince } },
-        { select: { createdAt: 1 }, sort: { createdAt: -1 }, limit: 1 },
+      const recentInbound = await getMessages(
+        { numero: candidate.code, from_me: false, createdAt: { $gte: inactiveSince } },
+        { sort: { createdAt: -1 }, limit: 1 },
       );
-      if (!lastInbound) return 'patient_silent_beyond_max_window';
-      if (new Date(lastInbound.createdAt) >= inactiveSince) return 'patient_active_within_inactivity_window';
+      if (recentInbound?.length) return 'patient_active_within_inactivity_window';
 
       const lastTriageAt = candidate?.brief?.lastTriageAt;
       if (lastTriageAt && moment.tz(lastTriageAt, DEFAULT_TIMEZONE).isSameOrAfter(inactiveSince)) {

package/lib/clinical/services/promptComposerService.js

@@ -191,6 +191,7 @@ async function fetchToolsByRecordIds(recordIds) {
   return tools;
 }
 
+const BLANK_TOOL_ID = '(blank tool_id)';
 const warnedUnlinked = new Set();
 
 function warnUnlinkedRegisteredTools(linkedToolIds, promptId) {
@@ -228,6 +229,7 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
   const activeTools = mappedTools.filter(t => !t.status || t.status === 'prod' || (!isProd && t.status === 'dev'));
 
   const validToolIds = [];
+  const unregisteredToolIds = [];
   const descriptions = {};
 
   for (const tool of activeTools) {
@@ -237,6 +239,7 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
       // An Airtable column retyped away from long text would otherwise reach the model as [object Object].
       if (typeof tool.description === 'string' && tool.description) descriptions[id] = tool.description;
     } else {
+      unregisteredToolIds.push(id || BLANK_TOOL_ID);
       logger.error('[promptComposer] Tool mapped in Airtable but not registered in code', { toolId: id, promptId });
     }
   }
@@ -252,7 +255,7 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
 
   logger.debug('[promptComposer] Tools resolved', { promptId, mapped: activeTools.length, valid: validToolIds.length, filtered: true });
 
-  return { toolIds: validToolIds, filtered: true, descriptions };
+  return { toolIds: validToolIds, filtered: true, descriptions, unregisteredToolIds };
 }
 
 function clearCache() {

package/lib/clinical/tools/extractClinicalInfoTool.js

@@ -1,8 +1,9 @@
 const { requireGatewayProvider } = require('../config/llmConfig');
 const { getSafetyFlagPatterns } = require('../config/divergenceConfig');
-const { isPurelyConversational } = require('../helpers/clinicalWorkflowGuard');
+const { ROUTING_SKILL, isPurelyConversational } = require('../helpers/clinicalWorkflowGuard');
 const { detectSafetyFlags } = require('../helpers/safetyFlagsHelper');
 const { projectClinicalFacts, renderClinicalIntakeSummary } = require('../helpers/clinicalFactsHelper');
+const { attachRequiredSkill } = require('../helpers/skillActivationHelper');
 const { extractClinicalMentions, getConversationalTokens } = require('../services/clinicalExtractionService');
 const { recordClinicalIntake } = require('../services/clinicalAirtableService');
 const { getCtcaeCatalog } = require('../stores/CtcaeCatalog');
@@ -40,7 +41,7 @@ const MAX_CONTEXT_TURNS = 6;
 
 const definition = {
   name: 'extractClinicalInfo',
-  description: '**Does:** Extracts ALL structured clinical facts from the current patient message — symptoms, labs, medications, diagnoses, appointments, treatments — and returns them as a discriminated-union `clinical_facts[]` list keyed by `kind`. Call ONCE per turn with ALL detected tags in a single call — one call covers every category.\n\n**Required inputs:** `raw_message` (the patient\'s current turn text, VERBATIM — the full contents of `<patient_message>`, every line of it when the turn carries more than one), `detected_tags` (list, at least one of: `symptom`, `indication`, `treatment`, `adherence`, `medication`, `appointment`, `emotion`, `lab_value`, `diagnosis`, `allergy`, `comorbidity`, `performance_status`; empty only for a purely conversational message or when declaring `non_clinical_request`), `intake_source` (`self` | `caregiver` | `team_relay`).\n\n**When to call:** at the start of any turn where the patient message mentions, explicitly or implicitly, any of the 12 supported categories. The result drives every downstream router-side read (landscape / history / risk / patterns).\n\n**When NOT to call:**\n- When the patient SHARED raw numeric results / lab values / files — use `reportResultsReceived` instead (it both logs the share AND emits FHIR Observations directly).\n- More than once per turn — a single call covers every category.\n\n**Returns:** `data.clinical_facts[]` — a discriminated-union list where each record has `kind` (observation | medication | condition | procedure | appointment | allergy) plus common fields `{id, code, effective, notes}` (null/default fields are OMITTED — e.g. `interpretation` appears only when non-default) and kind-specific fields:\n- `kind=observation`: `code_ctcae`, `value`, `grade_scale`,   `episode_id`, `trend`. Read `grade_scale` to anchor the   grade assigned in `recordClinicalImpression`. It is present   whenever the term has a curated CTCAE ladder, and ABSENT   when it does not — an absent `grade_scale` means there is no   rubric for this term, not that one was withheld. An absent   `grade_scale` means the term has no curated rubric, not   that one was withheld — so there is nothing to grade   against from memory. Call `lookupCtcaeEntry` when you   suspect the term itself is wrong; otherwise say where the   grade came from in `grade_estimate.source`.\n- `kind=medication`: `adherence_status` (`started` |   `ongoing` | `non_adherent` | …).\n- `kind=condition`: `clinical_status` (`active` | `resolved`   | …) — patient self-report of an existing diagnosis   (distinct from `openCondition` which commits a new   agent-tracked case).\n- `kind=procedure`: patient-reported procedure done   elsewhere (distinct from `recordIntervention` which is   agent-authored); `venue`/`outcome` may be null in the   current extraction phase.\n- `kind=appointment`: `scheduled_for`, `purpose` (may be   null in the current extraction phase).\nThe system writes the matching FHIR resource (Observation / MedicationStatement / Condition / Procedure / Appointment) + `Provenance` per fact on the audit lane; `allergy`, `comorbidity`, and `performance_status` are captured in a dedicated aggregate, not as a per-fact resource.\n\n**When the result asks you to confirm:** `data.pending_confirmation[]` means the patient reported a REAL clinical event but named it only generically («me suspendieron el tratamiento»), so it was deliberately NOT recorded. Each entry carries `{term, category, missing, quote}`; the list holds EVERY fact withheld this turn, but ask about the FIRST one only. Ask the patient for exactly what its `missing` names, in ONE short natural question, and never state or imply that anything was recorded. When they answer, call `extractClinicalInfo` again on their reply and it will be recorded then. `data.context_gaps[]` — only ever sent when there is nothing to confirm — names ONE stored variable that is stale or incomplete; raise it only if the conversation allows it naturally. Both lists are empty whenever the turn carries a safety flag: never ask housekeeping questions during a safety event.\n\n**Side effects:** System emits a FHIR resource + `Provenance` per fact on the audit lane, except `allergy`/`comorbidity`/`performance_status` (aggregated). Facts listed in `pending_confirmation` are NOT written to the patient record — they are held back until the patient confirms them.',
+  description: '**Does:** Extracts ALL structured clinical facts from the current patient message — symptoms, labs, medications, diagnoses, appointments, treatments — and returns them as a discriminated-union `clinical_facts[]` list keyed by `kind`. Call ONCE per turn with ALL detected tags in a single call — one call covers every category.\n\n**Required inputs:** `raw_message` (the patient\'s current turn text, VERBATIM — the full contents of `<patient_message>`, every line of it when the turn carries more than one), `detected_tags` (list, at least one of: `symptom`, `indication`, `treatment`, `adherence`, `medication`, `appointment`, `emotion`, `lab_value`, `diagnosis`, `allergy`, `comorbidity`, `performance_status`; empty only for a purely conversational message or when declaring `non_clinical_request`), `intake_source` (`self` | `caregiver` | `team_relay`).\n\n**When to call:** at the start of any turn where the patient message mentions, explicitly or implicitly, any of the 12 supported categories. The result drives every downstream router-side read (landscape / history / risk / patterns).\n\n**When NOT to call:**\n- When the patient SHARED raw numeric results / lab values / files — use `reportResultsReceived` instead (it both logs the share AND emits FHIR Observations directly).\n- More than once per turn — a single call covers every category.\n\n**Returns:** `data.clinical_facts[]` — a discriminated-union list where each record has `kind` (observation | medication | condition | procedure | appointment | allergy) plus common fields `{id, code, effective, notes}` (null/default fields are OMITTED — e.g. `interpretation` appears only when non-default) and kind-specific fields:\n- `kind=observation`: `code_ctcae`, `value`, `grade_scale`,   `episode_id`, `trend`. Read `grade_scale` to anchor the   grade assigned in `recordClinicalImpression`. It is present   whenever the term has a curated CTCAE ladder, and ABSENT   when it does not — an absent `grade_scale` means there is no   rubric for this term, not that one was withheld. An absent   `grade_scale` means the term has no curated rubric, not   that one was withheld — so there is nothing to grade   against from memory. Call `lookupCtcaeEntry` when you   suspect the term itself is wrong; otherwise say where the   grade came from in `grade_estimate.source`.\n- `kind=medication`: `adherence_status` (`started` |   `ongoing` | `non_adherent` | …).\n- `kind=condition`: `clinical_status` (`active` | `resolved`   | …) — patient self-report of an existing diagnosis   (distinct from `openCondition` which commits a new   agent-tracked case).\n- `kind=procedure`: patient-reported procedure done   elsewhere (distinct from `recordIntervention` which is   agent-authored); `venue`/`outcome` may be null in the   current extraction phase.\n- `kind=appointment`: `scheduled_for`, `purpose` (may be   null in the current extraction phase).\nThe system writes the matching FHIR resource (Observation / MedicationStatement / Condition / Procedure / Appointment) + `Provenance` per fact on the audit lane; `allergy`, `comorbidity`, and `performance_status` are captured in a dedicated aggregate, not as a per-fact resource.\n\n`data.activated_skills[]` — present when clinical facts were extracted and `clinical_routing` is enabled but not yet loaded this turn: its `body` is the routing protocol. Read it before `submitRoutingDecision`; no `Skill` call needed.\n\n**When the result asks you to confirm:** `data.pending_confirmation[]` means the patient reported a REAL clinical event but named it only generically («me suspendieron el tratamiento»), so it was deliberately NOT recorded. Each entry carries `{term, category, missing, quote}`; the list holds EVERY fact withheld this turn, but ask about the FIRST one only. Ask the patient for exactly what its `missing` names, in ONE short natural question, and never state or imply that anything was recorded. When they answer, call `extractClinicalInfo` again on their reply and it will be recorded then. `data.context_gaps[]` — only ever sent when there is nothing to confirm — names ONE stored variable that is stale or incomplete; raise it only if the conversation allows it naturally. Both lists are empty whenever the turn carries a safety flag: never ask housekeeping questions during a safety event.\n\n**Side effects:** System emits a FHIR resource + `Provenance` per fact on the audit lane, except `allergy`/`comorbidity`/`performance_status` (aggregated). Facts listed in `pending_confirmation` are NOT recorded as facts — they never reach the clinical intake or the patient\'s chart; FHIR keeps them only as unconfirmed drafts until the patient confirms them.',
   strict: true,
   parameters: {
     type: 'object',
@@ -265,6 +266,10 @@ async function handler(args, context = {}) {
   const gradeScales = {};
   for (const term of terms) gradeScales[term] = catalog.getGradeScale(term);
   const envelope = projectClinicalFacts({ clinicalMentions, safetyFlags, gradeScales, askAgenda });
+  const routingSkill = clinicalMentions.length || pendingMentions.length
+    ? await attachRequiredSkill(runtime, ROUTING_SKILL)
+    : null;
+  if (routingSkill) envelope.data.activated_skills = [routingSkill];
   return JSON.stringify(envelope);
 }
 

package/lib/clinical/tools/reportMedicalEscalationTool.js

@@ -349,6 +349,7 @@ async function handler(args, context = {}) {
         ...(patternFloor ? { clinicalPatternFloor: { ...patternFloor, raised: raisedByPattern } } : {}),
         ...(gateCheck?.degraded ? { triageGateFloorDegraded: gateCheck.degraded } : {}),
         ...(patternCheck?.degraded ? { clinicalPatternFloorDegraded: patternCheck.degraded } : {}),
+        ...(patternCheck?.check ? { clinicalPatternFloorCheck: patternCheck.check } : {}),
       },
     });
 

package/lib/clinical/tools/skillTool.js

@@ -1,9 +1,10 @@
 const { MEDICATION_NAMING_RULE } = require('../helpers/medicationNamingRule');
+const { markSkillActivated } = require('../helpers/skillActivationHelper');
 const { loadSkillBody } = require('../services/skillService');
 
 const definition = {
   name: 'Skill',
-  description: '**Does:** Activates an enabled skill by name and returns its `SKILL.md` body inline; the body then governs the rest of the turn.\n\n**Required inputs:** `skill` (enabled skill name, no leading slash, e.g. `emergency`), `args` (context string the skill body can interpret — pass `null` when there is no additional context).\n\n**When to call:** the turn matches a protocol the operator has enabled for this run (e.g. an emergency/red-flag turn) and you need its full body to proceed correctly.\n\n**When NOT to call:** the skill is not enabled for this run; a plain reply covers the turn without a protocol.\n\n**Returns:** `activated_skills[]` — `{name, version, body}`; read `body` and follow it verbatim. A skill not enabled for this run returns the enabled skill names, and an unknown name returns the available skill names, in the error payload for self-correction. Read-only.',
+  description: '**Does:** Activates an enabled skill by name and returns its `SKILL.md` body inline; the body then governs the rest of the turn.\n\n**Required inputs:** `skill` (enabled skill name, no leading slash, e.g. `emergency`), `args` (context string the skill body can interpret — pass `null` when there is no additional context).\n\n**When to call:** the turn matches a protocol the operator has enabled for this run (e.g. an emergency/red-flag turn) and you need its full body to proceed correctly.\n\n**When NOT to call:** the skill is not enabled for this run; a plain reply covers the turn without a protocol.\n\n**Returns:** `activated_skills[]` — `{name, version, body}`; read `body` and follow it verbatim. A skill already returned this turn (by `Skill` or inside another tool\'s `activated_skills`) returns `already_active` instead of the body again. A skill not enabled for this run returns the enabled skill names, and an unknown name returns the available skill names, in the error payload for self-correction. Read-only.',
   strict: true,
   replayScope: 'turn',
   parameters: {
@@ -46,6 +47,14 @@ async function handler(args, context) {
       });
     }
 
+    const runtime = context?.toolRuntimeContext;
+    if (runtime?.activatedSkills?.has(name)) {
+      return JSON.stringify({
+        success: true,
+        data: { already_active: name, note: `The ${name} body was already returned to you in this turn; follow it from there.` },
+      });
+    }
+
     const { skill, availableSkills } = await loadSkillBody(name);
     if (!skill) {
       return JSON.stringify({
@@ -58,11 +67,7 @@ async function handler(args, context) {
     const fragment = { name: skill.name, version: skill.version, body: skill.body };
     if (args?.args) fragment.args_received = args.args;
 
-    const runtime = context?.toolRuntimeContext;
-    runtime?.activatedSkills?.add(skill.name);
-    if (runtime?.skillActivationIteration && !runtime.skillActivationIteration.has(skill.name)) {
-      runtime.skillActivationIteration.set(skill.name, runtime.currentIteration ?? null);
-    }
+    markSkillActivated(runtime, skill.name);
 
     return JSON.stringify({ success: true, data: { activated_skills: [fragment] } });
   } catch (err) {

package/lib/clinical/tools/submitRoutingDecisionTool.js

@@ -1,7 +1,8 @@
 const crypto = require('node:crypto');
 
-const { validateRoutingPrerequisites } = require('../helpers/clinicalWorkflowGuard');
+const { clinicalIntakeRequiresRisk, hasAlternateTerminalCommit, validateRoutingPrerequisites } = require('../helpers/clinicalWorkflowGuard');
 const { MEDICATION_NAMING_RULE } = require('../helpers/medicationNamingRule');
+const { attachRequiredSkill } = require('../helpers/skillActivationHelper');
 const { storeRoutingDecision, readRoutingDecisions, readSymptomCases } = require('../../fhir');
 const { RoutingDecision } = require('../../shared/dtos/RoutingDecision');
 const { foldAccents } = require('../../utils/formatUtils');
@@ -92,7 +93,7 @@ const _CASE_IMPLYING_ACTIONS = new Set([
 
 const definition = {
   name: 'submitRoutingDecision',
-  description: '**Does:** The terminal routing checkpoint — call ONCE per turn to commit the turn plan. Decomposes `trace` (the per-mention evaluation record) and `turn_plan` (the primary action + optional secondary/deferred) into a persisted RoutingDecision (assessment + disposition + provenance), sets the turn\'s outbound signals, and hands the agent the next skill to invoke.\n\n**Required inputs:** `trace.mentions_evaluated[]` — one entry per clinical mention: `clinical_reasoning`, `decision.action`, `case_id_opened_or_updated` — REQUIRED whenever `decision.action` acts on a symptom (`emergency_escalation`, `team_escalation`, `symptom_recommendation`, `symptom_probe`, `acknowledge_improvement_on_case`, `follow_up_on_open_case`, `revisit_neglected_case`, `educate_about_symptom`, `weekly_triage_recommendations`, `generate_recommendations`), null only for a genuinely caseless mention (a medication, an appointment, a mood), plus `safety_flag_disposition` (string or object) when `safety_flags_received` is non-empty. `turn_plan.primary` — exactly one `{action, reason, case_id?}`; `turn_plan.secondary[]` — up to 2 `{action, compose_as}`; `turn_plan.deferred[]` — optional `{item?, defer_reason}`.\n\n**Routing-skill prerequisite:** when `clinical_routing` is among your enabled skills and `Skill` is offered to you this turn, this checkpoint fails until that body has been read in an EARLIER iteration. Presets without either proceed straight to routing. Requesting it in the same response does not count — its content never reached you. Call `Skill` with `skill=clinical_routing`, read what it returns, then commit here. This is the most common reason a first attempt is rejected.\n\n**Risk prerequisite:** after a clinical intake with extracted mentions, this checkpoint fails until the turn trace records a successful, processed risk read with status `final`, `no_signal`, or `not_generated`. Normally call `getRouterContextBundle` first and use its `risk.turn_focus`; if `sections_returned` lacks `risk` or reports `_diagnostics.risk_error`, call `getPatientRiskAssessment`, then retry this checkpoint.\n\n**Enum coercion:** primary/secondary `action` and secondary `compose_as` are folded (case/accent/separator) and synonym-mapped to canonical values; each repair is disclosed via `auto_repairs`. A genuinely unknown action is rejected.\n\n**Returns:** `decision_id`, `downstream_skill_to_invoke` (emergency | accompaniment | symptom_management | patient_education | null, derived from `primary.action`), and `auto_repairs` (only when non-empty). Fails hard with `risk_assessment_required_before_routing` when clinical intake ran without a processed risk disposition, with `decision_already_committed_for_turn` if called twice in one turn, when a symptom-acting mention carries no `case_id_opened_or_updated`, and when a named `case_id` does not exist for this patient. A clinical `DeliverPatientMessage` remains blocked until this commit succeeds.\n\n**Side effects:** persists the RoutingDecision; sets `branch_taken=ai_agent` on the turn trace.',
+  description: '**Does:** The terminal routing checkpoint — call ONCE per turn to commit the turn plan. Decomposes `trace` (the per-mention evaluation record) and `turn_plan` (the primary action + optional secondary/deferred) into a persisted RoutingDecision (assessment + disposition + provenance), sets the turn\'s outbound signals, and returns the body of the skill that governs the reply.\n\n**Required inputs:** `trace.mentions_evaluated[]` — one entry per clinical mention: `clinical_reasoning`, `decision.action`, `case_id_opened_or_updated` — REQUIRED whenever `decision.action` acts on a symptom (`emergency_escalation`, `team_escalation`, `symptom_recommendation`, `symptom_probe`, `acknowledge_improvement_on_case`, `follow_up_on_open_case`, `revisit_neglected_case`, `educate_about_symptom`, `weekly_triage_recommendations`, `generate_recommendations`), null only for a genuinely caseless mention (a medication, an appointment, a mood), plus `safety_flag_disposition` (string or object) when `safety_flags_received` is non-empty. `turn_plan.primary` — exactly one `{action, reason, case_id?}`; `turn_plan.secondary[]` — up to 2 `{action, compose_as}`; `turn_plan.deferred[]` — optional `{item?, defer_reason}`.\n\n**Routing-skill prerequisite:** when `clinical_routing` is among your enabled skills and `Skill` is offered to you this turn, this checkpoint fails until that body has been read in an EARLIER iteration. Presets without either proceed straight to routing. `extractClinicalInfo` returns that body in its `activated_skills` when it extracts clinical mentions: read it there and commit here in a LATER response, not in the same one as the intake. If no body was returned, call `Skill` with `skill=clinical_routing` first.\n\n**Risk prerequisite:** after a clinical intake with extracted mentions, this checkpoint fails until the turn trace records a successful, processed risk read with status `final`, `no_signal`, or `not_generated`. Normally call `getRouterContextBundle` first and use its `risk.turn_focus`; if `sections_returned` lacks `risk` or reports `_diagnostics.risk_error`, call `getPatientRiskAssessment`, then retry this checkpoint.\n\n**Enum coercion:** primary/secondary `action` and secondary `compose_as` are folded (case/accent/separator) and synonym-mapped to canonical values; each repair is disclosed via `auto_repairs`. A genuinely unknown action is rejected.\n\n**Returns:** `decision_id`, `downstream_skill_to_invoke` (emergency | accompaniment | symptom_management | patient_education | null, derived from `primary.action`), `activated_skills` (that skill\'s body, when it is enabled and not yet loaded this turn — read it and compose the reply from it; no `Skill` call needed), and `auto_repairs` (only when non-empty). Fails hard with `risk_assessment_required_before_routing` when clinical intake ran without a processed risk disposition, with `decision_already_committed_for_turn` if called twice in one turn, when a symptom-acting mention carries no `case_id_opened_or_updated`, and when a named `case_id` does not exist for this patient. A clinical `DeliverPatientMessage` remains blocked until this commit succeeds.\n\n**Side effects:** persists the RoutingDecision; sets `branch_taken=ai_agent` on the turn trace.',
   strict: false,
   parameters: {
     type: 'object',
@@ -431,6 +432,9 @@ async function handler(args = {}, context = {}) {
     const downstream = derivedDownstreamSkill(plan.primaryAction);
     runtime.trace.setSignals({ downstreamSkill: downstream || null });
     const data = { decision_id: decision.decisionId, downstream_skill_to_invoke: downstream };
+    const deliveryNeedsSkill = clinicalIntakeRequiresRisk(runtime.trace) && !hasAlternateTerminalCommit(runtime.trace);
+    const downstreamSkill = deliveryNeedsSkill ? await attachRequiredSkill(runtime, downstream) : null;
+    if (downstreamSkill) data.activated_skills = [downstreamSkill];
     if (repairs.length) data.auto_repairs = repairs;
     return JSON.stringify({ success: true, data });
   } catch (err) {

package/lib/core/NexusMessaging.js

@@ -77,7 +77,11 @@ const unbatchedRoutes = {
 function loadDefaultLlmMonitor() {
   const { LlmMonitorService } = require('../clinical/monitoring/LlmMonitorService');
   const { contingencyMonitorSpec } = require('../clinical/monitoring/contingencyMonitorSpec');
-  return { LlmMonitorService, contingencyMonitorSpec };
+  const { emergencyConsultMonitorSpec } = require('../clinical/monitoring/emergencyConsultMonitorSpec');
+  const { emergencyConsultMode } = require('../clinical/flags/emergencyConsultFlags');
+  const specs = [contingencyMonitorSpec];
+  if (emergencyConsultMode() !== 'off') specs.push(emergencyConsultMonitorSpec);
+  return { LlmMonitorService, specs };
 }
 
 function normalizeLlmMonitorConfig(value) {
@@ -88,8 +92,8 @@ function normalizeLlmMonitorConfig(value) {
 function createDefaultLlmMonitor(options, loader = loadDefaultLlmMonitor) {
   if (!options.enabled) return null;
   try {
-    const { LlmMonitorService, contingencyMonitorSpec } = loader();
-    return new LlmMonitorService({ ...options, specs: [contingencyMonitorSpec] });
+    const { LlmMonitorService, specs } = loader();
+    return new LlmMonitorService({ ...options, specs });
   } catch (error) {
     logger.warn('[llmMonitor] construction failed; patient messaging remains available', {
       error: error?.message || String(error),

package/lib/fhir/projections/clinicalMentionProjection.js

@@ -5,6 +5,7 @@ const { reference, patientReference, codeableConcept, extension, toInstant } = r
 const { baseResource, problemListCategory, observationCategory } = require('../helpers/resourceHelper');
 const { MENTION_SLUG } = require('../constants/projectionSlugs');
 const { MENTION_EXT } = require('../constants/extensionSlugs');
+const { PROCEDURE_STATUS, statusFrom } = require('./contextFactProjection');
 
 const ACTIVITY_TEXT = 'clinical-mention-extraction';
 const OBSERVED_FIELD_SYSTEM_KEY = 'observedField';
@@ -137,7 +138,8 @@ function adherenceFor(assertion) {
 
 function procedureStatus(fact, provenance) {
   if (fact.assertion.negated) return 'not-done';
-  return provenance.needsConfirmation ? 'unknown' : 'completed';
+  if (provenance.needsConfirmation) return 'unknown';
+  return statusFrom(PROCEDURE_STATUS, fact.observedFields?.status, { absent: 'completed', unrecognised: 'completed' });
 }
 
 function procedureResource({ fact, provenance }) {

package/lib/fhir/projections/contextFactProjection.js

@@ -33,7 +33,7 @@ const PROCEDURE_STATUS = {
   ended: 'completed', realizada: 'completed', realizado: 'completed',
   stopped: 'stopped', suspendido: 'stopped', suspendida: 'stopped',
   suspended: 'stopped', discontinued: 'stopped', not_active: 'stopped',
-  paused: 'on-hold',
+  paused: 'on-hold', started: 'in-progress',
   finalizado: 'completed', end: 'completed', past: 'completed', previous: 'completed',
   historical: 'completed', historico: 'completed',
   cancelled: 'not-done', cancelado: 'not-done', cancelada: 'not-done',
@@ -363,6 +363,8 @@ function fromFhir(resources) {
 
 module.exports = {
   CONTEXT_RESOURCE_TYPES,
+  PROCEDURE_STATUS,
+  statusFrom,
   toFhir,
   fromFhir,
   conceptKeyOf,

package/lib/helpers/messageHelper.js

@@ -3,6 +3,8 @@ const moment = require('moment-timezone');
 const { logger } = require('../utils/logger');
 const { isPlainObject } = require('../utils/jsonUtils');
 
+const { withoutAttachedSkillBodies } = require('../clinical/helpers/skillActivationHelper');
+
 function formatMessage(reply) {
   try {
     if (!reply.createdAt) return [];
@@ -62,9 +64,8 @@ function getMessageTools(reply, { skipTools, replayArgs } = {}) {
       const argsStr = JSON.stringify(args);
       let outputStr;
       if (t.tool_output != null && !keepArgs) {
-        outputStr = typeof t.tool_output === 'string'
-          ? t.tool_output
-          : JSON.stringify(t.tool_output);
+        const output = withoutAttachedSkillBodies(t.tool_output);
+        outputStr = typeof output === 'string' ? output : JSON.stringify(output);
       } else {
         outputStr = JSON.stringify({ success: t.success !== false });
       }

package/lib/models/escalationReviewModel.js

@@ -98,6 +98,7 @@ const draftSchema = new mongoose.Schema({
   missingCharacterization: { type: [String], default: undefined },
   suggestCall: { type: suggestCallSchema, default: undefined },
   sectionsUnavailable: { type: [String], default: undefined },
+  snapshotAt: { type: Date, default: undefined },
 }, { timestamps: { createdAt: true, updatedAt: false } });
 
 const doctorHandoffSchema = new mongoose.Schema({

package/lib/services/escalationReviewService.js

@@ -44,7 +44,7 @@ const AUDIT_SOURCE = 'escalation_review';
 const RECENT_REVIEW_LIMIT = 20;
 const TIMELINE_LIMIT = 500;
 const MAX_REVIEW_UPDATES = 50;
-const DRAFT_DEBOUNCE_MS = 60 * 1000;
+const DRAFT_DEBOUNCE_MS = 20 * 1000;
 const DRAFT_OPERATOR = 'bot:escalationDraft';
 const DIRECT_CHAT_ATTEMPTS = 3;
 const RECHECK_DELAY_MS = 60 * 1000;
@@ -507,6 +507,25 @@ async function recordReviewUpdate({ code, update, now = new Date(), settleInBack
   }
 }
 
+const STALE_INTERRUPTION_NOTES = 'Cerrada automáticamente al llegar una alarma nueva; nadie verificó si la operación interrumpida se completó';
+
+async function closeStaleInterruption(EscalationReview, patientCode, now) {
+  try {
+    const stale = await EscalationReview.findOne({
+      patientCode,
+      closedAt: null,
+      status: { $in: INTERRUPTED_STATUSES },
+      updatedAt: { $lte: new Date(now.getTime() - INTERRUPTION_GRACE_MS) },
+    }, { updatedAt: 1 }).lean();
+    if (!stale) return;
+    await closeEscalationReview({
+      id: String(stale._id), closedBy: BOT_OPERATOR, interruptionNotes: STALE_INTERRUPTION_NOTES, expectedUpdatedAt: stale.updatedAt,
+    });
+  } catch (error) {
+    logger[error?.statusCode === 409 ? 'warn' : 'error']('[EscalationReview] The interrupted review was not closed before the new alarm', { error: redactedError(error) });
+  }
+}
+
 async function recordEscalationAlarm({ code, alarm, now = new Date() } = {}) {
   try {
     const patientCode = patientCodeOf(code);
@@ -518,6 +537,7 @@ async function recordEscalationAlarm({ code, alarm, now = new Date() } = {}) {
       .lean();
 
     await ensureActiveReviewIndex(EscalationReview);
+    await closeStaleInterruption(EscalationReview, patientCode, now);
     const joined = await join();
     if (joined) {
       await scheduleDoctorAlert(joined, entry, now);
@@ -1078,6 +1098,7 @@ async function settleFollowUp(snapshot, { background = true } = {}) {
 }
 
 async function generateBotDraft({ id, lease = null } = {}) {
+  const startedAt = new Date();
   const review = await loadReview(reviewIdOf(id));
   if (review.closedAt || !DOCUMENTING_STATUSES.includes(review.status)) return { review: null, retry: false };
   const latest = (review.drafts ?? []).at(-1);
@@ -1107,6 +1128,7 @@ async function generateBotDraft({ id, lease = null } = {}) {
   }
 
   const entry = {
+    snapshotAt: startedAt,
     doctorText: withIdentity({ identity, review, doctorText: draft.doctorText }),
     patientMessage: draft.patientMessage,
     writtenBy: DRAFT_OPERATOR,
@@ -1117,13 +1139,16 @@ async function generateBotDraft({ id, lease = null } = {}) {
     ...(draft.suggestCall && { suggestCall: draft.suggestCall }),
     ...(draft.sectionsUnavailable?.length && { sectionsUnavailable: draft.sectionsUnavailable }),
   };
-  const saved = await getEscalationReview().findOneAndUpdate(
-    { _id: review._id, status: { $in: DOCUMENTING_STATUSES }, draftDueAt: lease, drafts: { $size: (review.drafts ?? []).length } },
-    { $push: { drafts: entry }, $set: { status: 'draft_ready', draftDueAt: null, draftFailedAt: null }, $unset: { identityBlock: '' } },
+  const EscalationReview = getEscalationReview();
+  const saved = await EscalationReview.findOneAndUpdate(
+    { _id: review._id, status: { $in: DOCUMENTING_STATUSES }, draftDueAt: { $lte: lease }, drafts: { $size: (review.drafts ?? []).length } },
+    { $push: { drafts: entry }, $set: { status: 'draft_ready', draftFailedAt: null }, $unset: { identityBlock: '' } },
     { new: true },
   ).lean();
-  if (saved) await audit(saved, DRAFT_OPERATOR, null, { action: 'draft_saved', draftNumber: saved.drafts.length });
-  return { review: saved, retry: false };
+  if (!saved) return { review: null, retry: false };
+  const released = await EscalationReview.updateOne({ _id: review._id, draftDueAt: lease }, { $set: { draftDueAt: null } }, BOOKKEEPING);
+  await audit(saved, DRAFT_OPERATOR, null, { action: 'draft_saved', draftNumber: saved.drafts.length });
+  return { review: released.matchedCount ? { ...saved, draftDueAt: null } : saved, retry: false };
 }
 
 async function noteFactsContext(review) {
@@ -1341,7 +1366,7 @@ async function handOffToDoctor({ id, mode, physicianEmail = null, sentBy, reques
     if (!approver) throw httpError(403, 'The physician is not an escalation review approver');
   }
 
-  const draftedAt = draft.createdAt ? new Date(draft.createdAt).getTime() : null;
+  const draftedAt = draftTimeOf(draft) ? new Date(draftTimeOf(draft)).getTime() : null;
   if (draftedAt && (review.alarms ?? []).some((alarm) => new Date(alarm.raisedAt).getTime() > draftedAt)) {
     throw httpError(409, 'A new alarm arrived after this draft was written; review it and save a new draft before sending it to the doctor');
   }
@@ -1437,7 +1462,7 @@ async function recordDoctorDecision({
   // Truthiness, not != null: an empty textarea is a decline with nothing to say.
   if (decision === 'needs_intervention' && finalText) approvedText = requiredText(finalText, 'finalText');
 
-  if (APPROVALS.includes(decision) && arrivedAfter(review, draft.createdAt)) {
+  if (APPROVALS.includes(decision) && arrivedAfter(review, draftTimeOf(draft))) {
     if (review.status === 'awaiting_doctor') {
       const redraft = draft.writtenBy === DRAFT_OPERATOR ? { draftDueAt: new Date(), draftAttempts: 0 } : {};
       const returned = await updateReview(reviewId, ['awaiting_doctor'], { $set: { status: 'documenting', ...redraft } }, {
@@ -1552,6 +1577,8 @@ const latestUpdateGuard = (review) => {
   return { updates: { $size: updates.length }, [`updates.${updates.length - 1}.turnId`]: updates.at(-1).turnId };
 };
 
+const draftTimeOf = (draft) => draft.snapshotAt ?? draft.createdAt;
+
 const arrivedAfter = (review, since) => Boolean(since) && [
   ...(review.alarms ?? []).map((alarm) => alarm.raisedAt),
   ...(review.updates ?? []).map((update) => update.at),

package/lib/services/reviewDraftSweepService.js

@@ -6,7 +6,7 @@ const { getEscalationReview } = require('../models/escalationReviewModel');
 const { BOOKKEEPING, DOCUMENTING_STATUSES, generateBotDraft } = require('./escalationReviewService');
 
 const SWEEP_LIMIT = 1;
-const DEFAULT_SWEEP_INTERVAL_MS = 30 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 10 * 1000;
 const RETRY_DELAY_MS = 5 * 60 * 1000;
 const MAX_DRAFT_ATTEMPTS = 3;
 const LEASE_MS = 10 * 60 * 1000;

package/package.json

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