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

package/lib/clinical/tools/reportUnresolvedRequestv2Tool.js

@@ -1,177 +0,0 @@
-const { recordUnresolvedRequest } = require('../services/clinicalAirtableService');
-const { logger } = require('../../utils/logger');
-
-const definition = {
-  'name': 'reportUnresolvedRequestv2',
-  'description': '**Does:** Escalates ADMINISTRATIVE / OPERATIVE matters — and non-clinical referrals to other services (psico-oncología, paliativos, non-oncology medical) — to the appropriate team queue. Records what was left pending, why it needs the team, operational urgency, and what was already communicated to the patient. It carries NO clinical-escalation semantics for the patient\'s oncology condition — those go to `reportMedicalEscalation`.\n\n**Required inputs:** `unresolved_question`, `category` (operational routing — REQUIRED for the queue), `urgency` (`routine` | `soon` | `urgent`; default `routine`), `escalation_details`, `resolution_attempted` (bool).\n\n**When to call:**\n- Administrative matter (appointments / insurance / authorisations / letters / rescheduling / transport).\n- Patient request that needs human (non-clinical) intervention.\n- Outside the agent\'s scope or knowledge (non-clinical).\n- A routine referral (psico-oncología, paliativos).\n- Callback from a specific team member (`category=contact_team_member`), or enrollment in a program / workshop / support group (`category=program_enrollment`).\nAlways pair with a `DeliverPatientMessage` acknowledging the escalation.\n\n**When NOT to call (use the clinical tools instead):**\n- ANY medical escalation — confirmed emergency, same-day evaluation, OR an asynchronous clinical concern (a symptom persisting >72h, a worrying trend, a treatment concern, stale clinical context) — use `reportMedicalEscalation` (urgency_level stat | asap | urgent | routine).\n- Active mental-health crisis — use `reportCrisis`.\n- Patient SHARED results / values / files — use `reportResultsReceived`.\n- Questions answerable from the CTCAE catalog or skill protocols — answer directly.\n\n**Returns:** an ack ({} on the happy path). Out-of-enum `urgency`/`category` are coerced (to `routine`/`other`) and disclosed via `coerced_urgency`/`coerced_category`; inputs over 500 chars are truncated and disclosed via `truncated_fields`. If the escalation could not be queued to the team it comes back with `queued: false` — do NOT tell the patient the team was notified in that case; acknowledge and say you are still working on it.\n\n**Side effects:** Emits `OUT_OF_SCOPE_LOGGED` to the appropriate team queue.',
-  'strict': true,
-  'parameters': {
-    'type': 'object',
-    'properties': {
-      'unresolved_question': {
-        'type': 'string',
-        'description': 'El pendiente ADMINISTRATIVO / OPERATIVO o de DERIVACIÓN que requiere al equipo. Cubre: (1) administrativo — citas, seguros, autorizaciones, cartas, reprogramación, transporte; (2) solicitud que requiere intervención humana no clínica; (3) fuera de tus alcances o conocimientos; (4) derivación/referencia a otro servicio (psico-oncología, paliativos, médico no oncológico) — eso es COORDINACIÓN, no escalación clínica. NO uses esta herramienta para ESCALACIONES CLÍNICAS del cuadro oncológico — un síntoma que persiste, una tendencia preocupante, un treatment_concern o contexto clínico desactualizado van por `reportMedicalEscalation` (urgency_level `routine` para revisión asíncrona del equipo). Resultados ya realizados que compartió el paciente van por `reportResultsReceived`.'
-      },
-      'escalation_details': {
-        'type': 'string',
-        'description': 'Por qué requiere al equipo y a quién va: equipo médico, navegadora, área administrativa, etc. Incluye urgencia operativa y qué se le comunicó al paciente.'
-      },
-      'category': {
-        'type': 'string',
-        'enum': [
-          'scheduling',
-          'insurance_authorization',
-          'transportation',
-          'legal_administrative',
-          'non_oncology_medical',
-          'document_interpretation',
-          'psicooncologia_referral',
-          'palliative_referral',
-          'contact_team_member',
-          'program_enrollment',
-          'other'
-        ],
-        'description': 'Categoría operativa/administrativa o de derivación del pendiente para ruteo. `contact_team_member` = el paciente quiere hablar con / pasar un mensaje a / que lo llame de vuelta un miembro del equipo. `program_enrollment` = inscribirse a charlas, talleres, grupos de apoyo o check-ups. Las categorías de ESCALACIÓN CLÍNICA (symptom_persistent, treatment_concern, stale_context) se retiraron — esas escalaciones van por `reportMedicalEscalation`.'
-      },
-      'resolution_attempted': {
-        'anyOf': [
-          {
-            'type': 'boolean',
-            'description': 'Si se intentó resolver en el chat antes de escalar.'
-          },
-          {
-            'type': 'null'
-          }
-        ]
-      },
-      'urgency': {
-        'anyOf': [
-          {
-            'type': 'string',
-            'enum': [
-              'routine',
-              'soon',
-              'urgent'
-            ],
-            'description': 'routine = sin plazo; soon = plazo en la semana; urgent = mismo día (transporte para hoy, conflicto de cita mañana).'
-          },
-          {
-            'type': 'null'
-          }
-        ]
-      },
-      'reasoning': {
-        'type': 'object',
-        'description': 'Trazabilidad interna de la decisión (auditoría). NUNCA se muestra al paciente. Úsalo para dejar por qué llamaste esta herramienta AHORA, con evidencia y alternativas descartadas.',
-        'properties': {
-          'brief': {
-            'type': 'string',
-            'description': 'UNA oración explicando por qué esta llamada en este turno. Observacional, no justificación genérica. E.g. \'Constelación neuro: visión borrosa + no camina en <2 turnos\'.'
-          },
-          'evidence_quote': {
-            'type': 'string',
-            'description': 'Cita textual del paciente (o del contexto inyectado) que soporta la decisión. Vacío si la evidencia es derivada de una tool anterior (menciónala en brief).'
-          },
-          'alternatives_considered': {
-            'anyOf': [
-              {
-                'type': 'array',
-                'items': {
-                  'type': 'string'
-                },
-                'description': 'Opciones que sopesaste y descartaste este turno (e.g., \'esperar una caracterización más\', \'ofrecer OTC en vez de non-pharm\'). Lista vacía si no hubo tradeoff real.'
-              },
-              {
-                'type': 'null'
-              }
-            ]
-          }
-        },
-        'required': [
-          'brief',
-          'evidence_quote',
-          'alternatives_considered'
-        ],
-        'additionalProperties': false
-      }
-    },
-    'required': [
-      'unresolved_question',
-      'escalation_details',
-      'category',
-      'resolution_attempted',
-      'urgency',
-      'reasoning'
-    ],
-    'additionalProperties': false
-  }
-};
-
-const CATEGORIES = definition.parameters.properties.category.enum;
-const URGENCIES = definition.parameters.properties.urgency.anyOf.find((v) => v.enum).enum;
-const MAX_LEN = 500;
-
-async function handler(args = {}, context = {}) {
-  try {
-    const trace = context?.toolRuntimeContext?.trace || null;
-    if (!trace) {
-      logger.error('[reportUnresolvedRequestv2] Escalation dropped — no active turn trace', { patientCode: context?.toolRuntimeContext?.patientCode || null });
-      return JSON.stringify({ success: false, error: 'reportUnresolvedRequestv2 requires an active turn trace.' });
-    }
-    const rawUrgency = (args?.urgency || 'routine').toLowerCase();
-    const urgency = URGENCIES.includes(rawUrgency) ? rawUrgency : 'routine';
-    const rawCategory = (args?.category || 'other').trim();
-    const category = CATEGORIES.includes(rawCategory) ? rawCategory : 'other';
-    const question = args?.unresolved_question || '';
-    const details = args?.escalation_details || '';
-
-    if (!trace.safetyDecision?.escalationKind) trace.setSafetyDecision({ escalationKind: 'out_of_scope' });
-    trace.setSignals({
-      unresolvedRequest: {
-        category,
-        unresolvedQuestion: question.slice(0, MAX_LEN),
-        escalationDetails: details.slice(0, MAX_LEN),
-        urgency,
-        resolutionAttempted: Boolean(args?.resolution_attempted),
-      },
-    });
-
-    const patientCode = context?.toolRuntimeContext?.patientCode;
-    let queued = false;
-    if (patientCode) {
-      queued = await recordUnresolvedRequest({
-        code: patientCode,
-        trace,
-        question,
-        details,
-        resolutionAttempted: Boolean(args?.resolution_attempted),
-        category,
-        urgency,
-      });
-    }
-
-    const data = {};
-    // auditedWrite swallows a failed write and returns false rather than throwing.
-    if (!queued) {
-      data.queued = false;
-      logger.error('[reportUnresolvedRequestv2] Escalation not queued — the team was not notified', {
-        patientCode: patientCode || null,
-        reason: patientCode ? 'airtable_write_failed' : 'no_patient_code',
-      });
-    }
-    if (urgency !== rawUrgency) { data.urgency = urgency; data.coerced_urgency = true; }
-    if (category !== rawCategory) { data.category = category; data.coerced_category = true; }
-    const truncated = [['unresolved_question', question], ['escalation_details', details]]
-      .filter(([, value]) => value.length > MAX_LEN)
-      .map(([field]) => field);
-    if (truncated.length) data.truncated_fields = truncated;
-    return JSON.stringify({ success: true, data });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'reportUnresolvedRequestv2 failed' });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/schedulePatientReminderTool.js

@@ -1,149 +0,0 @@
-const moment = require('moment-timezone');
-
-const { dispatchReminder } = require('../services/reminderDispatchService');
-const { recordReminder } = require('../services/clinicalAirtableService');
-const { logger } = require('../../utils/logger');
-
-const DEFAULT_TIMEZONE = 'America/Mexico_City';
-
-const definition = {
-  name: 'schedulePatientReminder',
-  description: '**Does:** Schedules a proactive WhatsApp message to the patient at a specific future date/time.\n\n**Required inputs:** `reminder_date` (ISO8601 `YYYY-MM-DDTHH:mm`, future, patient-local wall-clock — interpreted in the clinic timezone), `reminder_description` (becomes the WhatsApp message body), `reminder_type` (`medicamento` | `exámen` | `examen` | `cita` | `check_in` | `otros`), `reminder_action_type` (`create` | `update`), `reminder_id` (nullable — REQUIRED to be the id of the reminder to modify when `reminder_action_type=update`; `null` when creating).\n\n**When to call:** appointment reminders, dose reminders, proactive check-ins promised to the patient ("mañana te pregunto cómo amaneciste del dolor"), or any case where the patient was told the system would write at a specific future time. Maximum 2–3 punctual reminders per turn.\n\n**When NOT to call:**\n- A reactive follow-up derived from this turn\'s clinical decision (post-OTC, post-education) — that is a separate care-plan concern.\n- Recurring calendar reminders — out of scope (the medical team owns that surface).\n\n**Returns:** `reminder_id`, `reminder_slug`, `action_type`, `reminder_type`, `fire_at` (patient-local wall-clock), `time_zone`, `channel`. Out-of-enum `reminder_type`/`reminder_action_type` are coerced to `otros`/`create`; a non-ISO or non-future `reminder_date` is rejected — re-issue with `YYYY-MM-DDTHH:mm`. A message body over 200 chars is stored truncated and disclosed via `description_truncated`.\n\n**Side effects:** Records the scheduled-reminder intent (with `timeZone`) on the turn trace.',
-  strict: true,
-  parameters: {
-    type: 'object',
-    properties: {
-      reminder_date: {
-        type: 'string',
-        description: 'Target date and time for the reminder in ISO 8601 format (YYYY-MM-DDTHH:mm). Must be in the future. Use the patient\'s local time context.',
-      },
-      reminder_description: {
-        type: 'string',
-        description: 'Short description of what the reminder is for (e.g. \'tomar ondansetrón antes del desayuno\', \'preguntarle cómo amaneció del dolor de cabeza\'). This becomes the WhatsApp message body.',
-      },
-      reminder_type: {
-        type: 'string',
-        enum: ['medicamento', 'exámen', 'examen', 'cita', 'check_in', 'otros'],
-        description: '\'check_in\' = AUNA proactively asks the patient how they are doing. \'medicamento\' = pill/infusion dose nudge. \'cita\'/\'examen\' = clinical appointment or study. \'otros\' = other punctual reminder.',
-      },
-      reminder_action_type: {
-        type: 'string',
-        enum: ['create', 'update'],
-        description: '\'create\' = new reminder. \'update\' = modify an existing reminder (change date/time/description) — pass its id in `reminder_id`.',
-      },
-      reminder_id: {
-        type: ['string', 'null'],
-        description: 'The id of the reminder to modify (from a prior schedulePatientReminder call) when `reminder_action_type=update`; `null` when creating a new reminder.',
-      },
-    },
-    required: ['reminder_date', 'reminder_description', 'reminder_type', 'reminder_action_type', 'reminder_id'],
-    additionalProperties: false,
-  },
-};
-
-const REMINDER_TYPES = definition.parameters.properties.reminder_type.enum;
-const ACTION_TYPES = definition.parameters.properties.reminder_action_type.enum;
-
-const ISO_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?$/;
-const FIRE_AT_FORMATS = ['YYYY-MM-DDTHH:mm:ss', 'YYYY-MM-DDTHH:mm', 'YYYY-MM-DD HH:mm:ss', 'YYYY-MM-DD HH:mm'];
-
-function parseFireAt(reminderDate, timeZone) {
-  if (!ISO_DATETIME.test(reminderDate)) return null;
-  const at = moment.tz(reminderDate, FIRE_AT_FORMATS, true, timeZone);
-  return at.isValid() ? at : null;
-}
-
-function slugify(value, maxLen = 32) {
-  if (!value) return '';
-  const stripped = value.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
-  const hyphenated = stripped.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
-  return hyphenated.slice(0, maxLen).replace(/^-+|-+$/g, '');
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    const trace = runtime?.trace || null;
-    if (!runtime?.turnId || !trace?.setSignals) {
-      return JSON.stringify({ success: false, error: 'schedulePatientReminder requires an active turn context (turnId) with a trace.', data: {} });
-    }
-    const { turnId } = runtime;
-
-    const reminderDate = (args?.reminder_date || '').trim();
-    const description = (args?.reminder_description || '').trim();
-    if (!reminderDate || !description) {
-      return JSON.stringify({ success: false, error: 'schedulePatientReminder requires `reminder_date` and `reminder_description`.', data: {} });
-    }
-
-    const rawType = (args?.reminder_type || 'otros').toLowerCase();
-    const reminderType = REMINDER_TYPES.includes(rawType) ? rawType : 'otros';
-    const rawAction = (args?.reminder_action_type || 'create').toLowerCase();
-    const actionType = ACTION_TYPES.includes(rawAction) ? rawAction : 'create';
-    const targetId = typeof args?.reminder_id === 'string' && args.reminder_id.trim() ? args.reminder_id.trim() : null;
-
-    const timeZone = DEFAULT_TIMEZONE;
-    const fireMoment = parseFireAt(reminderDate, timeZone);
-    if (!fireMoment) {
-      return JSON.stringify({ success: false, error: `reminder_date must be ISO 8601 (YYYY-MM-DDTHH:mm) — got '${reminderDate}'.`, data: {} });
-    }
-    if (!fireMoment.isAfter(moment.tz(timeZone))) {
-      return JSON.stringify({ success: false, error: `reminder_date must be in the future (${timeZone}) — got '${reminderDate}'.`, data: {} });
-    }
-
-    const fireAt = fireMoment.format('YYYY-MM-DDTHH:mm:ss');
-    const existing = Array.isArray(trace.signals?.reminderIntents) ? trace.signals.reminderIntents : [];
-    const reminderId = actionType === 'update' && targetId ? targetId : `rem_${turnId}_${existing.length}`;
-    const reminderSlug = [reminderType, fireMoment.format('YYYY-MM-DDTHHmm'), slugify(description, 24)].filter(Boolean).join('-');
-    const storedDescription = description.slice(0, 200);
-
-    const intent = {
-      reminderId,
-      reminderType,
-      actionType,
-      fireAt,
-      timeZone,
-      description: storedDescription,
-      channel: 'whatsapp',
-    };
-    trace.setSignals({ reminderIntents: [...existing, intent] });
-
-    if (runtime.patientCode) {
-      try {
-        await dispatchReminder({ intent, patientId: runtime.patientCode });
-      } catch (err) {
-        logger.warn('[schedulePatientReminder] reminder FHIR projection failed; ack unaffected', { turnId, error: err?.message });
-      }
-    }
-
-    if (runtime.patientCode) {
-      await recordReminder({
-        code: runtime.patientCode,
-        trace,
-        actionType,
-        reminderId,
-        reminderDateUtc: fireMoment.toISOString(),
-        reminderType,
-        description: storedDescription,
-      });
-    }
-
-    const data = {
-      reminder_id: reminderId,
-      reminder_slug: reminderSlug,
-      action_type: actionType,
-      reminder_type: reminderType,
-      fire_at: fireAt,
-      time_zone: timeZone,
-      channel: 'whatsapp',
-    };
-    if (description.length > 200) data.description_truncated = true;
-    return JSON.stringify({ success: true, data });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'schedulePatientReminder failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/setContingencyPlanTool.js

@@ -1,176 +0,0 @@
-const crypto = require('node:crypto');
-
-const { readSymptomCases, readClusters, readContingencies, storeContingency } = require('../../fhir');
-const {
-  ContingencySafetyNet,
-  ESCALATION_PRIORITIES,
-  ACTIVE_CARE_PLAN_STATUSES,
-} = require('../../shared/dtos/ContingencySafetyNet');
-
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
-const STEP_SHAPE = '{recipient, message, priority, action_requested, fires_after_silence_minutes}';
-
-const definition = {
-  name: 'setContingencyPlan',
-  description: `**Does:** Arms a contingency safety net — a CarePlan anchor plus a team escalation that fires after patient silence, and an optional patient follow-up reminder. Guards an open case or cluster against a specific feared trajectory.\n\n**Required inputs:** \`concern\`, \`awaiting_characterization\`, \`why_this_matters\`, \`creation_reasoning\`; at least one of \`related_case_id\` / \`related_cluster_id\`; \`team_escalation\` \`${STEP_SHAPE}\` (message + priority + action_requested + a positive \`fires_after_silence_minutes\`). Optional \`patient_followup_reminder\` (same shape).\n\n**When to call:** when an open case/cluster needs a monitored fallback if the patient goes quiet.\n\n**When NOT to call:** when a target already has an active plan (fails hard) or the target is closed/dissolved.\n\n**Returns:** \`{plan_id}\`. Fails hard with \`case_not_found_or_wrong_patient\` / \`cluster_not_found_or_wrong_patient\`, \`target_not_open\`, or \`active_plan_already_exists_for_case\` / \`active_plan_already_exists_for_cluster\`.\n\n**Side effects:** writes a FHIR CarePlan + team CommunicationRequest (+ optional patient CommunicationRequest) + Provenance.`,
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      concern: {
-        type: 'string',
-        description: 'The feared trajectory this plan guards against.',
-      },
-      awaiting_characterization: {
-        type: 'string',
-        description: 'What the plan is waiting to observe or characterize.',
-      },
-      why_this_matters: {
-        type: 'string',
-        description: 'Why this contingency is clinically important.',
-      },
-      creation_reasoning: {
-        type: 'string',
-        description: 'Why the plan is being armed now.',
-      },
-      related_case_id: {
-        type: 'string',
-        description: 'The open case this plan guards. At least one of related_case_id / related_cluster_id is required.',
-      },
-      related_cluster_id: {
-        type: 'string',
-        description: 'The non-dissolved cluster this plan guards. At least one of related_case_id / related_cluster_id is required.',
-      },
-      team_escalation: {
-        type: 'object',
-        description: `Required. ${STEP_SHAPE}: message + priority + action_requested (strings) + fires_after_silence_minutes (> 0).`,
-      },
-      patient_followup_reminder: {
-        type: 'object',
-        description: `Optional. Same shape as team_escalation ${STEP_SHAPE}.`,
-      },
-    },
-    required: ['concern', 'awaiting_characterization', 'why_this_matters', 'creation_reasoning', 'team_escalation'],
-  },
-};
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-function buildStep(raw, recipient, label) {
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-    return { error: `${label} must be a non-empty object ${STEP_SHAPE}` };
-  }
-  const silence = raw.fires_after_silence_minutes;
-  if (typeof silence !== 'number' || !Number.isInteger(silence) || silence <= 0) {
-    return { error: `${label}.fires_after_silence_minutes is required and must be a positive integer` };
-  }
-  const message = (typeof raw.message === 'string' ? raw.message : '').trim();
-  if (!message) return { error: `${label}.message is required` };
-  const step = {
-    recipient,
-    message,
-    firesAfterSilenceMinutes: silence,
-  };
-  if (typeof raw.priority === 'string' && raw.priority.trim()) {
-    const priority = raw.priority.trim();
-    if (!ESCALATION_PRIORITIES.includes(priority)) {
-      return { error: 'invalid_priority', data: { priority, allowed: ESCALATION_PRIORITIES } };
-    }
-    step.priority = priority;
-  }
-  if (recipient === 'care_team') {
-    const actionRequested = (typeof raw.action_requested === 'string' ? raw.action_requested : '').trim();
-    if (!actionRequested) return { error: `${label}.action_requested is required` };
-    step.actionRequested = actionRequested;
-  } else if (typeof raw.action_requested === 'string' && raw.action_requested.trim()) {
-    step.actionRequested = raw.action_requested.trim();
-  }
-  return { step };
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return fail('setContingencyPlan requires an active turn context (turnId, patientCode).');
-    }
-    const str = (v) => (typeof v === 'string' ? v : '');
-    const concern = str(args?.concern).trim();
-    const awaiting = str(args?.awaiting_characterization).trim();
-    const why = str(args?.why_this_matters).trim();
-    const reasoning = str(args?.creation_reasoning).trim();
-    const relatedCaseId = str(args?.related_case_id).trim() || null;
-    const relatedClusterId = str(args?.related_cluster_id).trim() || null;
-
-    const missing = [['concern', concern], ['awaiting_characterization', awaiting], ['why_this_matters', why], ['creation_reasoning', reasoning]]
-      .filter(([, v]) => !v).map(([n]) => n);
-    if (missing.length) return fail(`missing required field(s): ${missing.join(', ')}`);
-    if (!relatedCaseId && !relatedClusterId) {
-      return fail('at least one of related_case_id or related_cluster_id is required — a plan must link to a target');
-    }
-
-    const team = buildStep(args?.team_escalation, 'care_team', 'team_escalation');
-    if (team.error) return fail(team.error, team.data);
-    let reminder = null;
-    if (args?.patient_followup_reminder != null) {
-      const built = buildStep(args.patient_followup_reminder, 'patient', 'patient_followup_reminder');
-      if (built.error) return fail(built.error, built.data);
-      reminder = built.step;
-    }
-
-    const patientId = runtime.patientCode;
-    if (relatedCaseId) {
-      const targetCase = (await readSymptomCases({ patientId })).find((c) => c.condition.conditionId === relatedCaseId);
-      if (!targetCase) return fail('case_not_found_or_wrong_patient', { related_case_id: relatedCaseId });
-      if (!OPEN_CASE_STATUSES.includes(targetCase.condition.clinicalStatus)) {
-        return fail('target_not_open — contingency plans require an active case', { related_case_id: relatedCaseId, current_status: targetCase.condition.clinicalStatus });
-      }
-    }
-    if (relatedClusterId) {
-      const targetCluster = (await readClusters({ patientId })).find((c) => c.clusterId === relatedClusterId);
-      if (!targetCluster) return fail('cluster_not_found_or_wrong_patient', { related_cluster_id: relatedClusterId });
-      if (targetCluster.status === 'dissolved') {
-        return fail('target_not_open — contingency plans require a non-dissolved cluster', { related_cluster_id: relatedClusterId, current_status: targetCluster.status });
-      }
-    }
-
-    if (relatedCaseId) {
-      const active = (await readContingencies({ patientId, caseId: relatedCaseId })).find((n) => ACTIVE_CARE_PLAN_STATUSES.includes(n.carePlan.status));
-      if (active) return fail('active_plan_already_exists_for_case', { existing_plan_id: active.carePlan.planId, existing_status: active.carePlan.status });
-    }
-    if (relatedClusterId) {
-      const active = (await readContingencies({ patientId, clusterId: relatedClusterId })).find((n) => ACTIVE_CARE_PLAN_STATUSES.includes(n.carePlan.status));
-      if (active) return fail('active_plan_already_exists_for_cluster', { existing_plan_id: active.carePlan.planId, existing_status: active.carePlan.status });
-    }
-
-    const now = new Date().toISOString();
-    const planId = `plan_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
-    const contingency = new ContingencySafetyNet({
-      carePlan: {
-        planId,
-        patientId,
-        relatedCaseId,
-        relatedClusterId,
-        concern,
-        awaitingCharacterization: awaiting,
-        whyThisMatters: why,
-        creationReasoning: reasoning,
-        createdAt: now,
-      },
-      teamEscalation: team.step,
-      patientReminder: reminder,
-    });
-
-    await storeContingency({ patientId, contingency });
-    return JSON.stringify({ success: true, data: { plan_id: planId } });
-  } catch (err) {
-    return fail(err?.message || 'setContingencyPlan failed');
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/skillTool.js

@@ -1,67 +0,0 @@
-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.',
-  strict: true,
-  parameters: {
-    type: 'object',
-    properties: {
-      skill: {
-        type: 'string',
-        description: 'Name of the skill protocol to activate.',
-      },
-      args: {
-        type: ['string', 'null'],
-        description: 'Context string the skill body can interpret; `null` when there is no additional context.',
-      },
-    },
-    required: ['skill', 'args'],
-    additionalProperties: false,
-  },
-};
-
-async function handler(args, context) {
-  try {
-    const name = typeof args?.skill === 'string' ? args.skill.trim() : '';
-    if (!name) {
-      return JSON.stringify({
-        success: false,
-        error: 'Skill requires `skill` (name of the skill to activate).',
-      });
-    }
-
-    const enabledSkills = context?.toolRuntimeContext?.enabledSkills;
-    if (!Array.isArray(enabledSkills) || !enabledSkills.includes(name)) {
-      return JSON.stringify({
-        success: false,
-        error: `Skill '${name}' is not enabled for this run.`,
-        data: {
-          requested_skill: name,
-          enabled_skills: Array.isArray(enabledSkills) ? [...enabledSkills].sort() : [],
-        },
-      });
-    }
-
-    const { skill, availableSkills } = await loadSkillBody(name);
-    if (!skill) {
-      return JSON.stringify({
-        success: false,
-        error: `Skill '${name}' is not registered.`,
-        data: { requested_skill: name, available_skills: availableSkills },
-      });
-    }
-
-    const fragment = { name: skill.name, version: skill.version, body: skill.body };
-    if (args?.args) fragment.args_received = args.args;
-
-    return JSON.stringify({ success: true, data: { activated_skills: [fragment] } });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'Skill failed' });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};