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

package/lib/clinical/tools/openConditionTool.js

@@ -1,136 +0,0 @@
-const crypto = require('node:crypto');
-
-const { readSymptomCases, storeSymptomCase } = require('../../fhir');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
-const { GRADE_MIN, GRADE_MAX, parseGradeEstimate } = require('../helpers/gradeEstimateHelper');
-
-const definition = {
-  name: 'openCondition',
-  description: '**Does:** Opens a NEW agent-tracked symptom case (Condition + initial ClinicalImpression) for a symptom term with no open case — the longitudinal expediente that groups 1..N episodes of the same `ctcae_term`.\n\n**Required inputs:** `ctcae_term` (English snake_case catalog key — e.g. `fever`, `pain`, `dyspnea`; use `other` only when no catalog term fits), `episode_id` (the intake episode this case wraps), `mention_id` (the intake mention that opened the case), `verbatim_quote` (exact substring of the patient message). Optional `temporality`, `grade_estimate` (`{best_estimate, confidence, possible_range, reasoning}`).\n\n**When to call:** when the turn surfaces a symptom with no open case on this `ctcae_term`. Use `recordClinicalImpression` if a case is already open — do NOT call `openCondition` twice for the same symptom.\n\n**When NOT to call:** for a new episode or subsequent assessment of an EXISTING case — use `recordClinicalImpression`.\n\n**Returns:** `case_id`, `action_taken` (`opened`), `status`, `ctcae_term`, `episode_ids`, `current_episode_id`, `grade_estimate`, `temporality`, `trajectory`. Fails hard with `case_already_open_for_term` + `existing_case_id` when an open case already exists for the term — recover via `recordClinicalImpression`.\n\n**Side effects:** writes a FHIR `Condition` + head `ClinicalImpression` + `Provenance`.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      ctcae_term: {
-        type: 'string',
-        description: 'English snake_case key from the CTCAE catalog (e.g. \'fever\', \'pain\', \'dyspnea\'). Use \'other\' only when no catalog term fits.',
-      },
-      episode_id: {
-        type: 'string',
-        description: 'The intake episode id this case wraps.',
-      },
-      mention_id: {
-        type: 'string',
-        description: 'The intake mention id that opened the case.',
-      },
-      verbatim_quote: {
-        type: 'string',
-        description: 'Exact substring of the patient\'s message.',
-      },
-      temporality: {
-        type: 'string',
-        description: 'Optional. Onset/course descriptor (e.g. \'ongoing\', \'acute\', \'progressive\').',
-      },
-      grade_estimate: {
-        type: 'object',
-        description: 'Optional. `{best_estimate: int 1-5|null, confidence: low|moderate|high, possible_range: [low, high], reasoning: str}`.',
-      },
-    },
-    required: ['ctcae_term', 'episode_id', 'mention_id', 'verbatim_quote'],
-  },
-};
-
-const uid = (prefix) => `${prefix}_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return JSON.stringify({ success: false, error: 'openCondition requires an active turn context (turnId, patientCode).', data: {} });
-    }
-    const asString = (value) => (typeof value === 'string' ? value : '');
-    const ctcaeTerm = asString(args?.ctcae_term).trim().toLowerCase();
-    const episodeId = asString(args?.episode_id).trim();
-    const mentionId = asString(args?.mention_id).trim();
-    const verbatim = asString(args?.verbatim_quote).trim();
-
-    const missing = [['ctcae_term', ctcaeTerm], ['episode_id', episodeId], ['mention_id', mentionId], ['verbatim_quote', verbatim]]
-      .filter(([, value]) => !value).map(([name]) => name);
-    if (missing.length) {
-      return JSON.stringify({ success: false, error: `missing required field(s): ${missing.join(', ')}`, data: {} });
-    }
-
-    const patientId = runtime.patientCode;
-    const casesForTerm = await readSymptomCases({ patientId, ctcaeTerm });
-    const openCase = casesForTerm.find((symptomCase) => ['characterizing', 'monitoring'].includes(symptomCase.condition.clinicalStatus));
-    if (openCase) {
-      return JSON.stringify({
-        success: false,
-        error: 'case_already_open_for_term',
-        data: {
-          existing_case_id: openCase.condition.conditionId,
-          existing_status: openCase.condition.clinicalStatus,
-          hint: 'call recordClinicalImpression with event=\'add_evidence\' or \'new_episode\' to attach to the existing case',
-        },
-      });
-    }
-
-    const now = new Date().toISOString();
-    const caseId = uid('case');
-    const temporality = typeof args?.temporality === 'string' ? args.temporality : null;
-    const grade = parseGradeEstimate(args?.grade_estimate);
-    if (grade.error) {
-      return JSON.stringify({ success: false, error: 'grade_out_of_range', data: { allowed_range: [GRADE_MIN, GRADE_MAX] } });
-    }
-    const managedSymptom = new ManagedSymptom({
-      condition: {
-        conditionId: caseId,
-        patientId,
-        ctcaeTerm,
-        clinicalStatus: 'characterizing',
-        onsetAt: now,
-        temporality,
-        evidenceEpisodeIds: [episodeId],
-        currentEpisodeId: episodeId,
-        evidenceMentionIds: [mentionId],
-      },
-      latestAssessment: {
-        assessmentId: uid('assessment'),
-        conditionId: caseId,
-        patientId,
-        performedAt: now,
-        previousId: null,
-        grade,
-        trajectory: null,
-      },
-    });
-
-    await storeSymptomCase({ patientId, managedSymptom });
-    const { condition, latestAssessment } = managedSymptom;
-    return JSON.stringify({
-      success: true,
-      data: {
-        case_id: condition.conditionId,
-        action_taken: 'opened',
-        status: condition.clinicalStatus,
-        ctcae_term: condition.ctcaeTerm,
-        episode_ids: [...condition.evidenceEpisodeIds],
-        current_episode_id: condition.currentEpisodeId,
-        grade_estimate: {
-          best_estimate: latestAssessment.grade.bestEstimate,
-          confidence: latestAssessment.grade.confidence,
-          possible_range: latestAssessment.grade.possibleRange,
-        },
-        temporality: condition.temporality,
-        trajectory: { direction: latestAssessment.trajectory || 'unknown' },
-      },
-    });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'openCondition failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/recordClinicalImpressionTool.js

@@ -1,251 +0,0 @@
-const crypto = require('node:crypto');
-
-const { readSymptomCases, storeSymptomCase } = require('../../fhir');
-const { ManagedSymptom } = require('../../shared/dtos/ManagedSymptom');
-const { GRADE_MIN, GRADE_MAX, parseGradeEstimate } = require('../helpers/gradeEstimateHelper');
-
-const definition = {
-  name: 'recordClinicalImpression',
-  description: '**Does:** Evolves an existing symptom case by `event`. `add_evidence`: new mention on the current episode (requires `characterizing` + a grade or trajectory). `new_episode`: a new episode for the same `ctcae_term` — attaches it and returns the case to `characterizing`. `resolve_episode`: the current episode resolved — case goes to `monitoring`. `close`: terminal — status `closed`, requires `close_reason`.\n\n**Required inputs:** `case_id` (from `openCondition` or `getActiveSymptomLandscape`), `event`. Per-event: `add_evidence`/`new_episode` require `mention_id` plus at least one of `grade_estimate` or `trajectory_direction`; `new_episode` also requires `episode_id`; `close` requires `close_reason`.\n\n**Returns:** `case_id`, `action_taken`, `status`, `ctcae_term`, `episode_ids`, `current_episode_id`, `mention_ids`, `grade_estimate`, `temporality`, `trajectory`, `decision_posture`, `close_reason`, `abatement_at`. Fails hard on status guards (e.g. `add_evidence` on a non-`characterizing` case), duplicate `mention_id`, or an already-attached `episode_id`.\n\n**Side effects:** appends a FHIR `ClinicalImpression` to the case chain and repoints the head; updates the `Condition` lifecycle.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      case_id: {
-        type: 'string',
-        description: 'The case_id returned by openCondition (or from getActiveSymptomLandscape.active_cases[].case_id).',
-      },
-      event: {
-        type: 'string',
-        enum: ['add_evidence', 'new_episode', 'resolve_episode', 'close'],
-        description: '`add_evidence`: more info on the current episode. `new_episode`: a new episode for the same term. `resolve_episode`: current episode resolved (case → monitoring). `close`: terminal (requires close_reason).',
-      },
-      mention_id: {
-        type: 'string',
-        description: 'The new intake mention id. Required for add_evidence and new_episode; optional audit trace for resolve_episode.',
-      },
-      episode_id: {
-        type: 'string',
-        description: 'The new intake episode id. Required for new_episode.',
-      },
-      grade_estimate: {
-        type: 'object',
-        description: '`{best_estimate: int 1-5|null, confidence: low|moderate|high, possible_range: [low, high], reasoning: str}`. At least one of grade_estimate or trajectory_direction is required for add_evidence and new_episode.',
-      },
-      trajectory_direction: {
-        type: 'string',
-        enum: ['improving', 'stable', 'worsening', 'unknown'],
-        description: 'Per-turn direction vs the prior impression.',
-      },
-      decision_posture: {
-        type: 'string',
-        enum: ['probe_for_discriminators', 'gather_more_evidence', 'commit_to_grade'],
-        description: 'Optional. Clinical posture for this impression.',
-      },
-      close_reason: {
-        type: 'string',
-        description: 'Required for event=close. Why the case is being closed.',
-      },
-      temporality: {
-        type: 'string',
-        description: 'Optional. Pass only when temporality changed since the last impression.',
-      },
-      reasoning: {
-        type: 'string',
-        description: 'Optional. General clinical rationale for this impression.',
-      },
-    },
-    required: ['case_id', 'event'],
-  },
-};
-
-const EVENTS = definition.parameters.properties.event.enum;
-const TRAJECTORIES = definition.parameters.properties.trajectory_direction.enum;
-const POSTURES = definition.parameters.properties.decision_posture.enum;
-const OPEN_STATUSES = ['characterizing', 'monitoring'];
-
-const uid = (prefix) => `${prefix}_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`;
-
-function coerceGrade(raw, base) {
-  if (!raw || typeof raw !== 'object') return base;
-  return parseGradeEstimate(raw);
-}
-
-function buildAssessment(condition, previous, args) {
-  const grade = coerceGrade(args?.grade_estimate, previous.grade);
-  if (grade?.error) return grade;
-  const trajectory = typeof args?.trajectory_direction === 'string' ? args.trajectory_direction : null;
-  if (trajectory !== null && !TRAJECTORIES.includes(trajectory)) return { error: 'invalid_trajectory_direction' };
-  const decisionPosture = typeof args?.decision_posture === 'string' ? args.decision_posture : null;
-  if (decisionPosture !== null && !POSTURES.includes(decisionPosture)) return { error: 'invalid_decision_posture' };
-  const reasoning = typeof args?.reasoning === 'string' ? args.reasoning : null;
-  return {
-    assessmentId: uid('assessment'),
-    conditionId: condition.conditionId,
-    patientId: condition.patientId,
-    performedAt: new Date().toISOString(),
-    previousId: previous.assessmentId,
-    grade,
-    trajectory,
-    decisionPosture,
-    reasoning,
-  };
-}
-
-function toManaged(existing, conditionPatch, newAssessment) {
-  const condition = { ...existing.condition, ...conditionPatch };
-  const priorAssessments = [existing.latestAssessment, ...existing.priorAssessments];
-  return new ManagedSymptom({
-    condition,
-    latestAssessment: newAssessment || existing.latestAssessment,
-    priorAssessments: newAssessment ? priorAssessments : existing.priorAssessments,
-  });
-}
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-function failAssessment(error, caseId, extra = {}) {
-  const allowed = {
-    grade_out_of_range: { allowed_range: [GRADE_MIN, GRADE_MAX] },
-    invalid_trajectory_direction: { allowed: TRAJECTORIES },
-    invalid_decision_posture: { allowed: POSTURES },
-  }[error] || {};
-  return fail(error, { case_id: caseId, ...allowed, ...extra });
-}
-
-function applyAddEvidence(existing, args) {
-  if (existing.condition.clinicalStatus !== 'characterizing') {
-    return fail('add_evidence requires status=characterizing. If status=monitoring, call new_episode; if closed, open a new case.', { case_id: existing.condition.conditionId, status: existing.condition.clinicalStatus });
-  }
-  const mentionId = (typeof args?.mention_id === 'string' ? args.mention_id : '').trim();
-  if (!mentionId) return fail('mention_id is required for add_evidence');
-  if (existing.condition.evidenceMentionIds.includes(mentionId)) {
-    return fail('mention_already_recorded_on_case', { case_id: existing.condition.conditionId, mention_id: mentionId });
-  }
-  if (!args?.grade_estimate && !args?.trajectory_direction) {
-    return fail('add_evidence requires at least one of `grade_estimate` or `trajectory_direction`.', { case_id: existing.condition.conditionId });
-  }
-  const assessment = buildAssessment(existing.condition, existing.latestAssessment, args);
-  if (assessment.error) return failAssessment(assessment.error, existing.condition.conditionId);
-  const patch = { evidenceMentionIds: [...existing.condition.evidenceMentionIds, mentionId] };
-  if (typeof args?.temporality === 'string') patch.temporality = args.temporality;
-  return toManaged(existing, patch, assessment);
-}
-
-function applyNewEpisode(existing, args) {
-  if (!OPEN_STATUSES.includes(existing.condition.clinicalStatus)) {
-    return fail('new_episode requires an open case (characterizing or monitoring).', { case_id: existing.condition.conditionId, status: existing.condition.clinicalStatus });
-  }
-  const episodeId = (typeof args?.episode_id === 'string' ? args.episode_id : '').trim();
-  const mentionId = (typeof args?.mention_id === 'string' ? args.mention_id : '').trim();
-  if (!episodeId || !mentionId) return fail('new_episode requires both episode_id and mention_id');
-  if (existing.condition.evidenceEpisodeIds.includes(episodeId)) {
-    return fail('episode_already_attached_to_case', { case_id: existing.condition.conditionId, episode_id: episodeId, current_episode_id: existing.condition.currentEpisodeId });
-  }
-  if (!args?.grade_estimate && !args?.trajectory_direction) {
-    return fail('new_episode requires at least one of `grade_estimate` or `trajectory_direction`.', { case_id: existing.condition.conditionId, episode_id: episodeId });
-  }
-  const assessment = buildAssessment(existing.condition, existing.latestAssessment, args);
-  if (assessment.error) return failAssessment(assessment.error, existing.condition.conditionId, { episode_id: episodeId });
-  const mentions = [...existing.condition.evidenceMentionIds];
-  if (!mentions.includes(mentionId)) mentions.push(mentionId);
-  const patch = {
-    evidenceEpisodeIds: [...existing.condition.evidenceEpisodeIds, episodeId],
-    currentEpisodeId: episodeId,
-    evidenceMentionIds: mentions,
-    clinicalStatus: 'characterizing',
-  };
-  if (typeof args?.temporality === 'string') patch.temporality = args.temporality;
-  return toManaged(existing, patch, assessment);
-}
-
-function applyResolveEpisode(existing, args) {
-  if (existing.condition.clinicalStatus !== 'characterizing') {
-    return fail('resolve_episode requires status=characterizing (there must be an active episode to resolve).', { case_id: existing.condition.conditionId, status: existing.condition.clinicalStatus });
-  }
-  const patch = { clinicalStatus: 'monitoring', currentEpisodeId: null };
-  const mentionId = (typeof args?.mention_id === 'string' ? args.mention_id : '').trim();
-  if (mentionId && !existing.condition.evidenceMentionIds.includes(mentionId)) {
-    patch.evidenceMentionIds = [...existing.condition.evidenceMentionIds, mentionId];
-  }
-  if (typeof args?.temporality === 'string') patch.temporality = args.temporality;
-  const reasoning = (typeof args?.reasoning === 'string' ? args.reasoning : '').trim();
-  if (reasoning) patch.lastTransitionReason = reasoning;
-  return toManaged(existing, patch, null);
-}
-
-function applyClose(existing, args) {
-  if (!OPEN_STATUSES.includes(existing.condition.clinicalStatus)) {
-    return fail('case_already_terminal', { case_id: existing.condition.conditionId, status: existing.condition.clinicalStatus, abatement_at: existing.condition.abatementAt, close_reason: existing.condition.closeReason });
-  }
-  const closeReason = (typeof args?.close_reason === 'string' ? args.close_reason : '').trim();
-  if (!closeReason) return fail('close_reason is required');
-  const patch = { clinicalStatus: 'closed', abatementAt: new Date().toISOString(), closeReason };
-  const reasoning = (typeof args?.reasoning === 'string' ? args.reasoning : '').trim();
-  if (reasoning) patch.lastTransitionReason = reasoning;
-  return toManaged(existing, patch, null);
-}
-
-const HANDLERS = {
-  add_evidence: applyAddEvidence,
-  new_episode: applyNewEpisode,
-  resolve_episode: applyResolveEpisode,
-  close: applyClose,
-};
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return JSON.stringify({ success: false, error: 'recordClinicalImpression requires an active turn context (turnId, patientCode).', data: {} });
-    }
-    const caseId = (typeof args?.case_id === 'string' ? args.case_id : '').trim();
-    const event = (typeof args?.event === 'string' ? args.event : '').trim().toLowerCase();
-    if (!caseId) return fail('case_id is required');
-    if (!EVENTS.includes(event)) {
-      return fail(`unknown event: '${event}'. Must be one of ${EVENTS.join(' | ')}.`);
-    }
-
-    const patientId = runtime.patientCode;
-    const cases = await readSymptomCases({ patientId });
-    const existing = cases.find((symptomCase) => symptomCase.condition.conditionId === caseId);
-    if (!existing) return fail('case_not_found_or_wrong_patient', { case_id: caseId });
-
-    const result = HANDLERS[event](existing, args);
-    if (typeof result === 'string') return result;
-
-    await storeSymptomCase({ patientId, managedSymptom: result });
-    const { condition, latestAssessment } = result;
-    return JSON.stringify({
-      success: true,
-      data: {
-        case_id: condition.conditionId,
-        action_taken: event,
-        status: condition.clinicalStatus,
-        ctcae_term: condition.ctcaeTerm,
-        episode_ids: [...condition.evidenceEpisodeIds],
-        current_episode_id: condition.currentEpisodeId,
-        mention_ids: [...condition.evidenceMentionIds],
-        grade_estimate: {
-          best_estimate: latestAssessment.grade.bestEstimate,
-          confidence: latestAssessment.grade.confidence,
-          possible_range: latestAssessment.grade.possibleRange,
-        },
-        temporality: condition.temporality,
-        trajectory: { direction: latestAssessment.trajectory || 'unknown' },
-        decision_posture: latestAssessment.decisionPosture,
-        close_reason: condition.closeReason,
-        abatement_at: condition.abatementAt,
-      },
-    });
-  } catch (err) {
-    return JSON.stringify({ success: false, error: err?.message || 'recordClinicalImpression failed', data: {} });
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/recordInterventionTool.js

@@ -1,140 +0,0 @@
-const crypto = require('node:crypto');
-
-const { readSymptomCases, readInterventions, storeIntervention } = require('../../fhir');
-const { Intervention } = require('../../shared/dtos/Intervention');
-
-const OPEN_CASE_STATUSES = ['characterizing', 'monitoring'];
-const KINDS = ['otc', 'self_care', 'other', 'education', 'team_escalation', 'follow_up_check'];
-const OUTCOMES = ['pending', 'improved', 'no_relief', 'side_effects', 'worsened', 'unknown'];
-const ACTIONS = ['create', 'record_outcome'];
-
-const definition = {
-  name: 'recordIntervention',
-  description: '**Does:** Records an agent-delivered intervention against an open symptom case (`action:\'create\'`) or patches the outcome of one already recorded (`action:\'record_outcome\'`). One intervention = one clinical action (OTC advice, self-care, education, a team escalation task, or a follow-up check).\n\n**Create inputs:** `case_id` (an OPEN case from `openCondition`/`getActiveSymptomLandscape`), `intervention_label`, `intervention_kind` (`otc` | `self_care` | `other` | `education` | `team_escalation` | `follow_up_check`); optional `rationale`. Fails hard with `case_not_found_or_wrong_patient` or `case_is_dormant` (recover via `recordClinicalImpression` reactivation), or `invalid intervention_kind`.\n\n**Outcome inputs (`action:\'record_outcome\'`):** `intervention_id` (the handle create returned), `outcome` (`pending` | `improved` | `no_relief` | `side_effects` | `worsened` | `unknown`); optional `outcome_notes`. Single-write: fails with `outcome_already_recorded` if the outcome is already non-pending.\n\n**When to call:** create when you deliver an intervention; record_outcome once the patient reports how it went.\n\n**Returns:** create → `{intervention_id, delivered_at}`; record_outcome → `{intervention_id, outcome}`.\n\n**Side effects:** writes a FHIR Procedure/Communication/Task/CommunicationRequest (per kind) + Provenance.',
-  strict: false,
-  parameters: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ACTIONS,
-        description: '`create` (default) records a new intervention; `record_outcome` patches an existing one\'s outcome. When omitted, presence of `intervention_id` implies `record_outcome`.',
-      },
-      case_id: {
-        type: 'string',
-        description: 'create: the OPEN case_id this intervention attaches to.',
-      },
-      intervention_label: {
-        type: 'string',
-        description: 'create: short human label for the intervention.',
-      },
-      intervention_kind: {
-        type: 'string',
-        enum: KINDS,
-        description: 'create: `otc`, `self_care`, `other`, `education`, `team_escalation`, or `follow_up_check`.',
-      },
-      rationale: {
-        type: 'string',
-        description: 'create: optional clinical rationale for the intervention.',
-      },
-      intervention_id: {
-        type: 'string',
-        description: 'record_outcome: the handle returned when the intervention was created.',
-      },
-      outcome: {
-        type: 'string',
-        enum: OUTCOMES,
-        description: 'record_outcome: `pending`, `improved`, `no_relief`, `side_effects`, `worsened`, or `unknown`.',
-      },
-      outcome_notes: {
-        type: 'string',
-        description: 'record_outcome: optional free-text notes on the outcome.',
-      },
-    },
-    required: [],
-  },
-};
-
-function fail(error, data = {}) {
-  return JSON.stringify({ success: false, error, data });
-}
-
-async function recordOutcome(patientId, interventionId, args) {
-  const outcome = (typeof args?.outcome === 'string' ? args.outcome : '').trim().toLowerCase();
-  if (!OUTCOMES.includes(outcome)) {
-    return fail(`invalid outcome: '${outcome}'. Must be one of ${OUTCOMES.join(' | ')}.`, { outcome });
-  }
-  const existing = (await readInterventions({ patientId })).find((i) => i.interventionId === interventionId);
-  if (!existing) return fail('intervention_not_found_or_wrong_patient', { intervention_id: interventionId });
-  if (existing.outcome && existing.outcome !== 'pending') {
-    return fail('outcome_already_recorded', { intervention_id: interventionId, outcome: existing.outcome });
-  }
-  const outcomeNotes = typeof args?.outcome_notes === 'string' ? (args.outcome_notes.trim() || null) : null;
-  const patched = new Intervention({ ...existing, outcome, outcomeNotes });
-  await storeIntervention({ patientId, intervention: patched });
-  return JSON.stringify({ success: true, data: { intervention_id: patched.interventionId, outcome: patched.outcome } });
-}
-
-async function create(patientId, args) {
-  const caseId = (typeof args?.case_id === 'string' ? args.case_id : '').trim();
-  const label = (typeof args?.intervention_label === 'string' ? args.intervention_label : '').trim();
-  const kind = (typeof args?.intervention_kind === 'string' ? args.intervention_kind : '').trim().toLowerCase();
-  const rationale = typeof args?.rationale === 'string' ? (args.rationale.trim() || null) : null;
-
-  const missing = [['case_id', caseId], ['intervention_label', label], ['intervention_kind', kind]]
-    .filter(([, v]) => !v).map(([n]) => n);
-  if (missing.length) return fail(`missing required field(s): ${missing.join(', ')}`);
-  if (!KINDS.includes(kind)) return fail(`invalid intervention_kind: '${kind}'. Must be one of ${KINDS.join(' | ')}.`, { intervention_kind: kind });
-
-  const targetCase = (await readSymptomCases({ patientId })).find((c) => c.condition.conditionId === caseId);
-  if (!targetCase) return fail('case_not_found_or_wrong_patient', { case_id: caseId });
-  if (!OPEN_CASE_STATUSES.includes(targetCase.condition.clinicalStatus)) {
-    return fail('case_is_dormant — interventions attach to open cases; if the symptom recurred, reactivate the case via recordClinicalImpression first.', { case_id: caseId, status: targetCase.condition.clinicalStatus });
-  }
-
-  const deliveredAt = new Date().toISOString();
-  const intervention = new Intervention({
-    kind,
-    interventionId: `intv_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`,
-    patientId,
-    caseId,
-    interventionLabel: label,
-    rationale,
-    deliveredAt,
-  });
-  await storeIntervention({ patientId, intervention });
-  return JSON.stringify({ success: true, data: { intervention_id: intervention.interventionId, delivered_at: deliveredAt } });
-}
-
-async function handler(args = {}, context = {}) {
-  try {
-    const runtime = context?.toolRuntimeContext || null;
-    if (!runtime?.turnId || !runtime?.patientCode) {
-      return fail('recordIntervention requires an active turn context (turnId, patientCode).');
-    }
-    const patientId = runtime.patientCode;
-    const interventionId = (typeof args?.intervention_id === 'string' ? args.intervention_id : '').trim();
-    const action = (typeof args?.action === 'string' ? args.action : '').trim().toLowerCase();
-    if (action && !ACTIONS.includes(action)) {
-      return fail(`invalid action: '${action}'. Must be one of ${ACTIONS.join(' | ')}.`);
-    }
-    if (action === 'record_outcome' && !interventionId) {
-      return fail('action=record_outcome requires `intervention_id`.');
-    }
-    if (action === 'create' && interventionId) {
-      return fail('action=create must NOT carry `intervention_id` — use action=record_outcome to patch an outcome.', { intervention_id: interventionId });
-    }
-
-    if (action === 'record_outcome' || (!action && interventionId)) {
-      return await recordOutcome(patientId, interventionId, args);
-    }
-    return await create(patientId, args);
-  } catch (err) {
-    return fail(err?.message || 'recordIntervention failed');
-  }
-}
-
-module.exports = {
-  definition,
-  handler,
-};

package/lib/clinical/tools/registerClinicalTools.js

@@ -1,39 +0,0 @@
-const { registerTool } = require('../../services/toolRegistryService');
-
-const TOOLS = [
-  require('./extractClinicalInfoTool'),
-  require('./lookupCtcaeEntryTool'),
-  require('./reportMedicalEscalationTool'),
-  require('./reportCrisisTool'),
-  require('./reportUnresolvedRequestv2Tool'),
-  require('./reportResultsReceivedTool'),
-  require('./schedulePatientReminderTool'),
-  require('./openClusterHypothesisTool'),
-  require('./updateClusterHypothesisTool'),
-  require('./submitRoutingDecisionTool'),
-  require('./analyzeSymptomPatternsTool'),
-  require('./openConditionTool'),
-  require('./recordClinicalImpressionTool'),
-  require('./getActiveSymptomLandscapeTool'),
-  require('./recordInterventionTool'),
-  require('./setContingencyPlanTool'),
-  require('./getPatientRiskProfileTool'),
-  require('./getPatientHistoryTool'),
-  require('./getRouterContextBundleTool'),
-  require('./deliverPatientMessageTool'),
-  require('./skillTool'),
-];
-
-function registerClinicalTools() {
-  for (const tool of TOOLS) {
-    registerTool({
-      name: tool.definition.name,
-      description: tool.definition.description,
-      parameters: tool.definition.parameters,
-      strict: tool.definition.strict,
-      handler: tool.handler,
-    });
-  }
-}
-
-module.exports = { registerClinicalTools };