@absolutejs/voice 0.0.21 → 0.0.22-beta.0

package/dist/index.js

@@ -434,6 +434,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -475,6 +527,933 @@ var resolveVoiceRuntimePreset = (name = "default") => {
   };
 };
 
+// src/ops.ts
+var ensureTaskHistory = (task, entry) => ({
+  ...task,
+  history: [
+    ...task.history ?? [],
+    {
+      ...entry,
+      at: entry.at ?? Date.now()
+    }
+  ],
+  updatedAt: Date.now()
+});
+var withVoiceOpsTaskId = (id, task) => ({
+  ...task,
+  id
+});
+var withVoiceIntegrationEventId = (id, event) => ({
+  ...event,
+  id
+});
+var buildVoiceOpsTaskFromReview = (review) => {
+  const createdAt = review.generatedAt ?? Date.now();
+  const common = {
+    createdAt,
+    history: [
+      {
+        actor: "system",
+        at: createdAt,
+        detail: review.postCall?.summary,
+        type: "created"
+      }
+    ],
+    id: `${review.id}:ops`,
+    intakeId: review.id,
+    outcome: review.summary.outcome,
+    recommendedAction: review.postCall?.recommendedAction ?? "Review the voice artifact and decide the next operator action.",
+    reviewId: review.id,
+    status: "open",
+    target: review.postCall?.target,
+    updatedAt: createdAt
+  };
+  switch (review.summary.outcome) {
+    case "voicemail":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "Caller reached voicemail and needs a callback follow-up.",
+        kind: "callback",
+        title: review.postCall?.target ? `Call back voicemail from ${review.postCall.target}` : "Call back voicemail lead"
+      };
+    case "no-answer":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "Live contact was not established and should be retried.",
+        kind: "callback",
+        title: "Retry no-answer call"
+      };
+    case "escalated":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The automated path escalated this call for human review.",
+        kind: "escalation",
+        title: "Review escalated call"
+      };
+    case "transferred":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The call was transferred and should be verified downstream.",
+        kind: "transfer-check",
+        title: review.postCall?.target ? `Verify transfer to ${review.postCall.target}` : "Verify call transfer"
+      };
+    case "failed":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The call failed and needs operator review before retry.",
+        kind: "retry-review",
+        title: "Inspect failed call before retry"
+      };
+    default:
+      return null;
+  }
+};
+var assignVoiceOpsTask = (task, owner, input = {}) => {
+  const normalizedOwner = owner.trim() || "ops";
+  return ensureTaskHistory({
+    ...task,
+    assignee: normalizedOwner
+  }, {
+    actor: input.actor ?? normalizedOwner,
+    at: input.at,
+    detail: `Assigned to ${normalizedOwner}`,
+    type: "assigned"
+  });
+};
+var startVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  status: "in-progress"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Work started",
+  type: "started"
+});
+var completeVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  status: "done"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Marked done",
+  type: "completed"
+});
+var reopenVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  status: "open"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Task reopened",
+  type: "reopened"
+});
+var listVoiceOpsTasks = (tasks) => [...tasks].sort((left, right) => right.createdAt - left.createdAt);
+var summarizeVoiceOpsTasks = (tasks) => {
+  const summary = {
+    byKind: new Map,
+    byOutcome: new Map,
+    done: 0,
+    inProgress: 0,
+    open: 0,
+    topAssignees: new Map,
+    topTargets: new Map,
+    total: tasks.length
+  };
+  for (const task of tasks) {
+    if (task.status === "open") {
+      summary.open += 1;
+    } else if (task.status === "in-progress") {
+      summary.inProgress += 1;
+    } else if (task.status === "done") {
+      summary.done += 1;
+    }
+    summary.byKind.set(task.kind, (summary.byKind.get(task.kind) ?? 0) + 1);
+    if (task.outcome) {
+      summary.byOutcome.set(task.outcome, (summary.byOutcome.get(task.outcome) ?? 0) + 1);
+    }
+    if (task.target) {
+      summary.topTargets.set(task.target, (summary.topTargets.get(task.target) ?? 0) + 1);
+    }
+    if (task.assignee) {
+      summary.topAssignees.set(task.assignee, (summary.topAssignees.get(task.assignee) ?? 0) + 1);
+    }
+  }
+  return {
+    byKind: [...summary.byKind.entries()].sort((left, right) => right[1] - left[1]),
+    byOutcome: [...summary.byOutcome.entries()].sort((left, right) => right[1] - left[1]),
+    done: summary.done,
+    inProgress: summary.inProgress,
+    open: summary.open,
+    topAssignees: [...summary.topAssignees.entries()].sort((left, right) => right[1] - left[1]),
+    topTargets: [...summary.topTargets.entries()].sort((left, right) => right[1] - left[1]),
+    total: summary.total
+  };
+};
+var createVoiceIntegrationEvent = (type, payload, input = {}) => ({
+  createdAt: input.createdAt ?? Date.now(),
+  id: input.id ?? crypto.randomUUID(),
+  payload,
+  type
+});
+var createVoiceCallCompletedEvent = (input) => createVoiceIntegrationEvent("call.completed", {
+  call: input.session.call,
+  disposition: input.disposition ?? input.session.call?.disposition,
+  scenarioId: input.session.scenarioId,
+  sessionId: input.session.id,
+  sessionSummary: input.sessionSummary,
+  status: input.session.status,
+  turnCount: input.session.turns.length
+}, {
+  id: `${input.session.id}:call.completed`
+});
+var createVoiceReviewSavedEvent = (review) => createVoiceIntegrationEvent("review.saved", {
+  elapsedMs: review.summary.elapsedMs,
+  firstTurnLatencyMs: review.summary.firstTurnLatencyMs,
+  outcome: review.summary.outcome,
+  postCall: review.postCall,
+  reviewId: review.id,
+  title: review.title
+}, {
+  id: `${review.id}:review.saved`
+});
+var createVoiceTaskCreatedEvent = (task) => createVoiceIntegrationEvent("task.created", {
+  assignee: task.assignee,
+  kind: task.kind,
+  outcome: task.outcome,
+  recommendedAction: task.recommendedAction,
+  reviewId: task.reviewId,
+  status: task.status,
+  target: task.target,
+  taskId: task.id,
+  title: task.title
+}, {
+  id: `${task.id}:task.created:${task.updatedAt}`
+});
+var createVoiceTaskUpdatedEvent = (task) => createVoiceIntegrationEvent("task.updated", {
+  assignee: task.assignee,
+  history: task.history,
+  kind: task.kind,
+  outcome: task.outcome,
+  recommendedAction: task.recommendedAction,
+  reviewId: task.reviewId,
+  status: task.status,
+  target: task.target,
+  taskId: task.id,
+  title: task.title,
+  updatedAt: task.updatedAt
+}, {
+  id: `${task.id}:task.updated:${task.updatedAt}`
+});
+
+// src/testing/review.ts
+var roundMetric = (value) => typeof value === "number" ? Math.round(value * 100) / 100 : undefined;
+var formatMetric = (label, value, unit = "ms") => typeof value === "number" ? `${label}: ${roundMetric(value)}${unit}` : undefined;
+var findTimelineEvent = (timeline, event, source) => timeline.find((entry) => entry.event === event && (source === undefined || entry.source === source));
+var formatTimelineText = (entry) => {
+  const parts = [`- ${entry.atMs}ms`, `[${entry.source}]`, entry.event];
+  if (entry.text) {
+    parts.push(`"${entry.text}"`);
+  }
+  if (entry.reason) {
+    parts.push(`reason=${entry.reason}`);
+  }
+  if (typeof entry.bytes === "number") {
+    parts.push(`bytes=${entry.bytes}`);
+  }
+  if (typeof entry.confidence === "number") {
+    parts.push(`confidence=${roundMetric(entry.confidence)}`);
+  }
+  if (entry.name) {
+    parts.push(`name=${entry.name}`);
+  }
+  return parts.join(" ");
+};
+var isLowSignalTimelineEvent = (entry) => entry.event === "inbound-media" || entry.event === "inbound-silence-pad" || entry.event === "stt-send" || entry.event === "tts-audio";
+var summarizeTimelineTraffic = (timeline) => {
+  const summaries = new Map;
+  for (const entry of timeline) {
+    const label = entry.event === "inbound-media" ? "inbound media chunks" : entry.event === "inbound-silence-pad" ? "inbound silence padding" : entry.event === "stt-send" ? "STT audio sends" : entry.event === "tts-audio" ? "post-first TTS audio chunks" : undefined;
+    if (!label) {
+      continue;
+    }
+    const summary = summaries.get(label) ?? {
+      audioMs: 0,
+      bytes: 0,
+      count: 0,
+      label
+    };
+    summary.count += 1;
+    summary.bytes += typeof entry.bytes === "number" ? entry.bytes : 0;
+    summary.audioMs = (summary.audioMs ?? 0) + (typeof entry.chunkDurationMs === "number" ? entry.chunkDurationMs : 0);
+    summaries.set(label, summary);
+  }
+  return [...summaries.values()];
+};
+var compactTimeline = (timeline) => {
+  const rows = [];
+  let index = 0;
+  while (index < timeline.length) {
+    const current = timeline[index];
+    if (!current) {
+      break;
+    }
+    const isBurstEvent = isLowSignalTimelineEvent(current) || current.event === "media" && current.source === "twilio";
+    if (!isBurstEvent) {
+      rows.push(formatTimelineText(current));
+      index += 1;
+      continue;
+    }
+    let endIndex = index;
+    let totalBytes = typeof current.bytes === "number" ? current.bytes : 0;
+    let totalChunkDurationMs = typeof current.chunkDurationMs === "number" ? current.chunkDurationMs : 0;
+    while (endIndex + 1 < timeline.length) {
+      const next = timeline[endIndex + 1];
+      if (!next) {
+        break;
+      }
+      if (next.event !== current.event || next.source !== current.source) {
+        break;
+      }
+      totalBytes += typeof next.bytes === "number" ? next.bytes : 0;
+      totalChunkDurationMs += typeof next.chunkDurationMs === "number" ? next.chunkDurationMs : 0;
+      endIndex += 1;
+    }
+    const startAt = current.atMs;
+    const endAt = timeline[endIndex]?.atMs ?? current.atMs;
+    const count = endIndex - index + 1;
+    const parts = [
+      `- ${startAt}-${endAt}ms`,
+      `[${current.source}]`,
+      `${current.event} x${count}`
+    ];
+    if (totalBytes > 0) {
+      parts.push(`bytes=${totalBytes}`);
+    }
+    if (totalChunkDurationMs > 0) {
+      parts.push(`audio=${roundMetric(totalChunkDurationMs)}ms`);
+    }
+    rows.push(parts.join(" "));
+    index = endIndex + 1;
+  }
+  return rows;
+};
+var withVoiceCallReviewId = (id, artifact) => ({
+  ...artifact,
+  id
+});
+var createVoiceCallReviewFromLiveTelephonyReport = (report, options = {}) => {
+  const fixture = report.fixtures?.[0];
+  if (!fixture) {
+    throw new Error("Live telephony review requires at least one fixture result.");
+  }
+  const timeline = [...report.trace ?? []].sort((left, right) => left.atMs - right.atMs);
+  const firstPartial = findTimelineEvent(timeline, "partial", "stt");
+  const commitEvent = findTimelineEvent(timeline, "commit", "turn");
+  const firstTtsAudio = findTimelineEvent(timeline, "tts-first-audio", "benchmark");
+  const firstOutboundMedia = findTimelineEvent(timeline, "media", "twilio");
+  const bargeInEvent = findTimelineEvent(timeline, "barge-in", "benchmark");
+  const clearEvent = findTimelineEvent(timeline, "clear", "twilio");
+  const lastSttText = [...timeline].reverse().find((entry) => entry.source === "stt" && (entry.event === "partial" || entry.event === "final") && typeof entry.text === "string" && entry.text.length > 0)?.text ?? undefined;
+  const latencyBreakdown = [
+    typeof firstPartial?.atMs === "number" ? {
+      label: "start to first partial",
+      valueMs: firstPartial.atMs
+    } : undefined,
+    typeof firstPartial?.atMs === "number" && typeof commitEvent?.atMs === "number" ? {
+      label: "first partial to commit",
+      valueMs: commitEvent.atMs - firstPartial.atMs
+    } : undefined,
+    typeof commitEvent?.atMs === "number" && typeof firstTtsAudio?.atMs === "number" ? {
+      label: "commit to first TTS audio",
+      valueMs: firstTtsAudio.atMs - commitEvent.atMs
+    } : undefined,
+    typeof commitEvent?.atMs === "number" && typeof firstOutboundMedia?.atMs === "number" ? {
+      label: "commit to first outbound media",
+      valueMs: firstOutboundMedia.atMs - commitEvent.atMs
+    } : undefined,
+    typeof bargeInEvent?.atMs === "number" && typeof clearEvent?.atMs === "number" ? {
+      label: "barge-in to clear",
+      valueMs: clearEvent.atMs - bargeInEvent.atMs
+    } : undefined
+  ].filter((value) => value !== undefined && value.valueMs >= 0);
+  const notes = [
+    report.variant?.description,
+    firstPartial?.text ? `First partial: "${firstPartial.text}"` : undefined,
+    lastSttText ? `Last STT text: "${lastSttText}"` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return {
+    config: {
+      preset: options.preset,
+      stt: report.variant ? {
+        description: report.variant.description,
+        id: report.variant.id,
+        model: report.variant.model
+      } : undefined,
+      tts: report.ttsConfig,
+      turnDetection: report.turnDetectionConfig
+    },
+    errors: fixture.errors ?? [],
+    expectedText: fixture.expectedText,
+    fixtureId: fixture.fixtureId,
+    generatedAt: report.generatedAt,
+    latencyBreakdown,
+    notes,
+    path: options.path,
+    summary: {
+      clearLatencyMs: roundMetric(fixture.clearLatencyMs),
+      elapsedMs: roundMetric(fixture.elapsedMs),
+      firstOutboundMediaLatencyMs: roundMetric(fixture.firstOutboundMediaLatencyMs),
+      firstTurnLatencyMs: roundMetric(fixture.firstTurnLatencyMs),
+      markLatencyMs: roundMetric(fixture.markLatencyMs),
+      outboundMediaCount: fixture.outboundMediaCount,
+      pass: fixture.passes,
+      termRecall: roundMetric(fixture.termRecall),
+      turnCount: fixture.turnCount,
+      wordErrorRate: roundMetric(fixture.wordErrorRate)
+    },
+    title: fixture.title ?? "Voice Call Review",
+    timeline,
+    transcript: {
+      actual: fixture.actualText,
+      expected: fixture.expectedText
+    }
+  };
+};
+var toErrorMessage = (error) => {
+  if (typeof error === "string" && error.trim().length > 0) {
+    return error;
+  }
+  if (error instanceof Error && error.message.trim().length > 0) {
+    return error.message;
+  }
+  return "Unknown call error";
+};
+var createVoiceCallReviewRecorder = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const startedAt = now();
+  const errors = [];
+  const timeline = [];
+  const committedTurns = [];
+  const committedTurnIds = new Set;
+  const push = (source, event, fields = {}) => {
+    timeline.push({
+      atMs: Math.max(0, now() - startedAt),
+      event,
+      source,
+      ...fields
+    });
+  };
+  return {
+    finalize: () => {
+      const sortedTimeline = [...timeline].sort((left, right) => left.atMs - right.atMs);
+      const firstPartial = findTimelineEvent(sortedTimeline, "partial", "stt");
+      const commitEvent = findTimelineEvent(sortedTimeline, "commit", "turn");
+      const firstTtsAudio = findTimelineEvent(sortedTimeline, "tts-first-audio", "benchmark");
+      const firstOutboundMedia = findTimelineEvent(sortedTimeline, "media", "twilio");
+      const bargeInEvent = findTimelineEvent(sortedTimeline, "barge-in", "benchmark");
+      const clearEvent = findTimelineEvent(sortedTimeline, "clear", "twilio");
+      const markEvent = findTimelineEvent(sortedTimeline, "mark", "twilio");
+      const elapsedMs = sortedTimeline.at(-1)?.atMs ?? 0;
+      const lastSttText = [...sortedTimeline].reverse().find((entry) => entry.source === "stt" && (entry.event === "partial" || entry.event === "final") && typeof entry.text === "string" && entry.text.length > 0)?.text ?? undefined;
+      const latencyBreakdown = [
+        typeof firstPartial?.atMs === "number" ? {
+          label: "start to first partial",
+          valueMs: firstPartial.atMs
+        } : undefined,
+        typeof firstPartial?.atMs === "number" && typeof commitEvent?.atMs === "number" ? {
+          label: "first partial to commit",
+          valueMs: commitEvent.atMs - firstPartial.atMs
+        } : undefined,
+        typeof commitEvent?.atMs === "number" && typeof firstTtsAudio?.atMs === "number" ? {
+          label: "commit to first TTS audio",
+          valueMs: firstTtsAudio.atMs - commitEvent.atMs
+        } : undefined,
+        typeof commitEvent?.atMs === "number" && typeof firstOutboundMedia?.atMs === "number" ? {
+          label: "commit to first outbound media",
+          valueMs: firstOutboundMedia.atMs - commitEvent.atMs
+        } : undefined,
+        typeof bargeInEvent?.atMs === "number" && typeof clearEvent?.atMs === "number" ? {
+          label: "barge-in to clear",
+          valueMs: clearEvent.atMs - bargeInEvent.atMs
+        } : undefined
+      ].filter((value) => value !== undefined && value.valueMs >= 0);
+      return {
+        config: options.config,
+        errors,
+        fixtureId: options.fixtureId,
+        generatedAt: now(),
+        latencyBreakdown,
+        notes: [
+          firstPartial?.text ? `First partial: "${firstPartial.text}"` : undefined,
+          lastSttText ? `Last STT text: "${lastSttText}"` : undefined
+        ].filter((value) => typeof value === "string"),
+        path: options.path,
+        summary: {
+          clearLatencyMs: roundMetric(typeof clearEvent?.atMs === "number" && typeof bargeInEvent?.atMs === "number" ? clearEvent.atMs - bargeInEvent.atMs : undefined),
+          elapsedMs: roundMetric(elapsedMs),
+          firstOutboundMediaLatencyMs: roundMetric(firstOutboundMedia?.atMs),
+          firstTurnLatencyMs: roundMetric(commitEvent?.atMs),
+          markLatencyMs: roundMetric(markEvent?.atMs),
+          outboundMediaCount: sortedTimeline.filter((entry) => entry.source === "twilio" && entry.event === "media").length,
+          pass: errors.length === 0,
+          turnCount: committedTurns.length
+        },
+        title: options.title ?? "Voice Call Review",
+        timeline: sortedTimeline,
+        transcript: {
+          actual: committedTurns.join(" ").trim()
+        }
+      };
+    },
+    recordError: (error) => {
+      const message = toErrorMessage(error);
+      errors.push(message);
+      push("turn", "error", {
+        reason: message
+      });
+    },
+    recordTwilioInbound: (input) => {
+      push("twilio", input.event, {
+        bytes: input.bytes,
+        chunkDurationMs: input.chunkDurationMs,
+        name: input.name,
+        reason: input.reason,
+        text: input.text,
+        track: input.track
+      });
+    },
+    recordTwilioOutbound: (input) => {
+      push("twilio", input.event, {
+        bytes: input.bytes,
+        chunkDurationMs: input.chunkDurationMs,
+        name: input.name,
+        reason: input.reason,
+        text: input.text,
+        track: input.track
+      });
+    },
+    recordVoiceMessage: (message) => {
+      switch (message.type) {
+        case "partial":
+        case "final":
+          push("stt", message.type, {
+            confidence: message.transcript.confidence,
+            text: message.transcript.text
+          });
+          return;
+        case "assistant":
+          push("turn", "assistant", {
+            text: message.text
+          });
+          return;
+        case "audio":
+          push("benchmark", timeline.some((entry) => entry.event === "tts-first-audio") ? "tts-audio" : "tts-first-audio", {
+            bytes: Math.floor(message.chunkBase64.length * 3 / 4)
+          });
+          return;
+        case "turn":
+          if (committedTurnIds.has(message.turn.id)) {
+            return;
+          }
+          committedTurnIds.add(message.turn.id);
+          committedTurns.push(message.turn.text);
+          push("turn", "commit", {
+            confidence: message.turn.quality?.averageConfidence,
+            text: message.turn.text
+          });
+          return;
+        case "error":
+          errors.push(message.message);
+          push("turn", "error", {
+            reason: message.message
+          });
+          return;
+        case "complete":
+          push("turn", "complete", {
+            text: message.sessionId
+          });
+          return;
+        case "session":
+          push("turn", "session", {
+            reason: message.status,
+            text: message.sessionId
+          });
+          return;
+        case "pong":
+          push("benchmark", "pong");
+          return;
+      }
+    }
+  };
+};
+var renderConfigSection = (config) => {
+  if (!config) {
+    return "";
+  }
+  return [
+    "## Config",
+    "",
+    "```json",
+    JSON.stringify(config, null, 2),
+    "```"
+  ].join(`
+`);
+};
+var renderTimeline = (timeline) => {
+  const focusedTimeline = timeline.filter((entry) => !isLowSignalTimelineEvent(entry));
+  if (focusedTimeline.length === 0) {
+    return `## Timeline
+
+_No timeline events captured._`;
+  }
+  const lines = compactTimeline(focusedTimeline);
+  return ["## Timeline", "", ...lines].join(`
+`);
+};
+var renderTransportSummary = (timeline) => {
+  const summaries = summarizeTimelineTraffic(timeline);
+  if (summaries.length === 0) {
+    return "";
+  }
+  return [
+    "## Transport Summary",
+    "",
+    ...summaries.map((summary) => {
+      const parts = [`- ${summary.label}: ${summary.count}`];
+      if (summary.bytes > 0) {
+        parts.push(`${summary.bytes} bytes`);
+      }
+      if ((summary.audioMs ?? 0) > 0) {
+        parts.push(`${roundMetric(summary.audioMs)}ms audio`);
+      }
+      return parts.join(", ");
+    })
+  ].join(`
+`);
+};
+var renderLatencyBreakdown = (breakdown) => {
+  if (breakdown.length === 0) {
+    return "";
+  }
+  return [
+    "## Latency Breakdown",
+    "",
+    ...breakdown.map((entry) => `- ${entry.label}: ${roundMetric(entry.valueMs)}ms`)
+  ].join(`
+`);
+};
+var renderVoiceCallReviewMarkdown = (artifact) => {
+  const summaryLines = [
+    `- pass: ${artifact.summary.pass ? "yes" : "no"}`,
+    formatMetric("first turn", artifact.summary.firstTurnLatencyMs),
+    formatMetric("first outbound media", artifact.summary.firstOutboundMediaLatencyMs),
+    formatMetric("mark", artifact.summary.markLatencyMs),
+    formatMetric("clear", artifact.summary.clearLatencyMs),
+    formatMetric("elapsed", artifact.summary.elapsedMs),
+    typeof artifact.summary.wordErrorRate === "number" ? `- word error rate: ${artifact.summary.wordErrorRate}` : undefined,
+    typeof artifact.summary.termRecall === "number" ? `- term recall: ${artifact.summary.termRecall}` : undefined,
+    typeof artifact.summary.turnCount === "number" ? `- turn count: ${artifact.summary.turnCount}` : undefined,
+    typeof artifact.summary.outboundMediaCount === "number" ? `- outbound media count: ${artifact.summary.outboundMediaCount}` : undefined
+  ].filter((value) => typeof value === "string");
+  const notes = artifact.notes.length ? ["## Notes", "", ...artifact.notes.map((note) => `- ${note}`)].join(`
+`) : "";
+  const errors = artifact.errors.length ? ["## Errors", "", ...artifact.errors.map((error) => `- ${error}`)].join(`
+`) : "";
+  const latency = renderLatencyBreakdown(artifact.latencyBreakdown);
+  const transportSummary = renderTransportSummary(artifact.timeline);
+  return [
+    `# ${artifact.title}`,
+    "",
+    artifact.path ? `Source: \`${artifact.path}\`` : undefined,
+    artifact.fixtureId ? `Fixture: \`${artifact.fixtureId}\`` : undefined,
+    "",
+    "## Summary",
+    "",
+    ...summaryLines,
+    "",
+    "## Transcript",
+    "",
+    `- expected: ${artifact.transcript.expected ?? "_n/a_"}`,
+    `- actual: ${artifact.transcript.actual}`,
+    "",
+    notes,
+    notes ? "" : undefined,
+    latency,
+    latency ? "" : undefined,
+    transportSummary,
+    transportSummary ? "" : undefined,
+    errors,
+    errors ? "" : undefined,
+    renderConfigSection(artifact.config),
+    renderConfigSection(artifact.config) ? "" : undefined,
+    renderTimeline(artifact.timeline)
+  ].filter((value) => typeof value === "string").join(`
+`);
+};
+var escapeHtml2 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderVoiceCallReviewHTML = (artifact) => {
+  const notes = artifact.notes.map((note) => `<li>${escapeHtml2(note)}</li>`).join("");
+  const latency = artifact.latencyBreakdown.map((entry) => `<li><strong>${escapeHtml2(entry.label)}:</strong> ${roundMetric(entry.valueMs)}ms</li>`).join("");
+  const transport = summarizeTimelineTraffic(artifact.timeline).map((summary) => {
+    const parts = [`${summary.count}`, "events"];
+    if (summary.bytes > 0) {
+      parts.push(`${summary.bytes} bytes`);
+    }
+    if ((summary.audioMs ?? 0) > 0) {
+      parts.push(`${roundMetric(summary.audioMs)}ms audio`);
+    }
+    return `<li><strong>${escapeHtml2(summary.label)}:</strong> ${escapeHtml2(parts.join(", "))}</li>`;
+  }).join("");
+  const timeline = compactTimeline(artifact.timeline.filter((entry) => !isLowSignalTimelineEvent(entry))).map((line) => `<li>${escapeHtml2(line.replace(/^- /u, ""))}</li>`).join("");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml2(artifact.title)}</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { font-family: ui-sans-serif, system-ui, sans-serif; margin: 0; padding: 24px; background: #0b0d10; color: #f4f4f5; }
+    main { max-width: 980px; margin: 0 auto; display: grid; gap: 16px; }
+    section { background: #13161b; border: 1px solid #232833; border-radius: 16px; padding: 18px; }
+    h1, h2 { margin: 0 0 12px; }
+    ul { margin: 0; padding-left: 20px; display: grid; gap: 8px; }
+    code, pre { font-family: ui-monospace, SFMono-Regular, monospace; }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; background: #0f1217; border-radius: 12px; padding: 14px; border: 1px solid #232833; }
+    .grid { display: grid; gap: 16px; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); }
+    .metric { display: grid; gap: 4px; }
+    .label { color: #a1a1aa; font-size: 0.82rem; text-transform: uppercase; letter-spacing: 0.08em; }
+    .value { font-size: 1.05rem; }
+  </style>
+</head>
+<body>
+  <main>
+    <section>
+      <h1>${escapeHtml2(artifact.title)}</h1>
+      <div class="grid">
+        <div class="metric"><div class="label">Pass</div><div class="value">${artifact.summary.pass ? "yes" : "no"}</div></div>
+        <div class="metric"><div class="label">First Turn</div><div class="value">${artifact.summary.firstTurnLatencyMs ?? "n/a"}ms</div></div>
+        <div class="metric"><div class="label">First Outbound Media</div><div class="value">${artifact.summary.firstOutboundMediaLatencyMs ?? "n/a"}ms</div></div>
+        <div class="metric"><div class="label">Turn Count</div><div class="value">${artifact.summary.turnCount ?? "n/a"}</div></div>
+      </div>
+    </section>
+    <section>
+      <h2>Transcript</h2>
+      <ul>
+        <li><strong>Expected:</strong> ${escapeHtml2(artifact.transcript.expected ?? "n/a")}</li>
+        <li><strong>Actual:</strong> ${escapeHtml2(artifact.transcript.actual || "n/a")}</li>
+      </ul>
+    </section>
+    <section>
+      <h2>Notes</h2>
+      <ul>${notes || "<li>No notes.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Latency Breakdown</h2>
+      <ul>${latency || "<li>No latency data.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Transport Summary</h2>
+      <ul>${transport || "<li>No transport data.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Timeline</h2>
+      <ul>${timeline || "<li>No timeline events.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Config</h2>
+      <pre>${escapeHtml2(JSON.stringify(artifact.config ?? {}, null, 2))}</pre>
+    </section>
+  </main>
+</body>
+</html>`;
+};
+
+// src/runtimeOps.ts
+var defaultReviewTitle = (session) => session.scenarioId ? `Voice call review: ${session.scenarioId}` : `Voice call review: ${session.id}`;
+var buildDefaultPostCallSummary = (input) => {
+  switch (input.disposition) {
+    case "transferred":
+      return {
+        label: "Transferred",
+        recommendedAction: input.target ? `Confirm the handoff to ${input.target} completed successfully.` : "Confirm the transfer completed successfully.",
+        reason: input.reason,
+        summary: input.target ? `The call was transferred to ${input.target}.` : "The call was transferred.",
+        target: input.target
+      };
+    case "escalated":
+      return {
+        label: "Escalated",
+        recommendedAction: "Review the escalated call and route it to a human operator.",
+        reason: input.reason,
+        summary: input.reason ? `The call escalated because ${input.reason}.` : "The call escalated for operator review."
+      };
+    case "voicemail":
+      return {
+        label: "Voicemail",
+        recommendedAction: "Queue a callback follow-up for this caller.",
+        reason: input.reason,
+        summary: "The call reached voicemail and needs a callback."
+      };
+    case "no-answer":
+      return {
+        label: "No Answer",
+        recommendedAction: "Retry the call or create a callback task.",
+        reason: input.reason,
+        summary: "The call did not reach a live respondent."
+      };
+    case "failed":
+      return {
+        label: "Failed",
+        recommendedAction: "Inspect the call review before retrying this flow.",
+        reason: input.reason,
+        summary: input.reason ? `The call failed because ${input.reason}.` : "The call failed before a successful completion."
+      };
+    case "closed":
+      return {
+        label: "Closed",
+        recommendedAction: "Inspect the review if this early closure was unexpected.",
+        reason: input.reason,
+        summary: "The call closed before an explicit completion."
+      };
+    case "completed":
+    default:
+      return {
+        label: "Completed",
+        recommendedAction: "No follow-up action is required.",
+        reason: input.reason,
+        summary: "The call completed successfully."
+      };
+  }
+};
+var createVoiceCallReviewFromSession = (input) => {
+  const generatedAt = input.generatedAt ?? Date.now();
+  const actual = input.session.turns.map((turn) => turn.text).join(" ").trim();
+  const elapsedMs = (input.session.lastActivityAt ?? generatedAt) - input.session.createdAt;
+  return {
+    errors: input.disposition === "failed" && input.reason ? [input.reason] : [],
+    generatedAt,
+    latencyBreakdown: typeof elapsedMs === "number" && elapsedMs >= 0 ? [
+      {
+        label: "Session elapsed",
+        valueMs: elapsedMs
+      }
+    ] : [],
+    notes: [],
+    postCall: buildDefaultPostCallSummary({
+      disposition: input.disposition,
+      reason: input.reason,
+      target: input.target
+    }),
+    summary: {
+      elapsedMs: elapsedMs >= 0 ? elapsedMs : undefined,
+      outcome: input.disposition,
+      pass: input.disposition !== "failed",
+      turnCount: input.session.turns.length
+    },
+    title: defaultReviewTitle(input.session),
+    timeline: input.session.call?.events.map((event) => ({
+      atMs: Math.max(0, event.at - input.session.createdAt),
+      event: `call-${event.type}`,
+      reason: event.reason,
+      source: "turn",
+      text: event.target ?? event.disposition,
+      track: event.target
+    })) ?? [],
+    transcript: {
+      actual
+    }
+  };
+};
+var asStoredReview = (sessionId, review) => {
+  if (typeof review.id === "string" && review.id.length > 0) {
+    return review;
+  }
+  return withVoiceCallReviewId(`${sessionId}:review`, review);
+};
+var asStoredTask = (review, task) => {
+  if ("id" in task && typeof task.id === "string" && task.id.length > 0) {
+    return task;
+  }
+  return withVoiceOpsTaskId(`${review.id}:ops`, task);
+};
+var emitRuntimeEvent = async (input) => {
+  await input.config.events?.set(input.event.id, input.event);
+  await input.config.onEvent?.({
+    api: input.api,
+    context: input.context,
+    event: input.event,
+    session: input.session
+  });
+};
+var recordVoiceRuntimeOps = async (input) => {
+  if (!input.config) {
+    return;
+  }
+  const result = input.session.turns.at(-1)?.result;
+  const reviewCandidate = await input.config.buildReview?.({
+    api: input.api,
+    context: input.context,
+    disposition: input.disposition,
+    metadata: input.metadata,
+    reason: input.reason,
+    result,
+    session: input.session,
+    target: input.target
+  }) ?? createVoiceCallReviewFromSession({
+    disposition: input.disposition,
+    reason: input.reason,
+    session: input.session,
+    target: input.target
+  });
+  const review = reviewCandidate ? asStoredReview(input.session.id, reviewCandidate) : undefined;
+  if (review) {
+    await input.config.reviews?.set(review.id, review);
+    await emitRuntimeEvent({
+      api: input.api,
+      config: input.config,
+      context: input.context,
+      event: createVoiceReviewSavedEvent(review),
+      session: input.session
+    });
+  }
+  let task;
+  if (review) {
+    const taskCandidate = await input.config.createTaskFromReview?.({
+      api: input.api,
+      context: input.context,
+      disposition: input.disposition,
+      review,
+      session: input.session
+    }) ?? buildVoiceOpsTaskFromReview(review) ?? undefined;
+    if (taskCandidate) {
+      task = asStoredTask(review, taskCandidate);
+      await input.config.tasks?.set(task.id, task);
+      await emitRuntimeEvent({
+        api: input.api,
+        config: input.config,
+        context: input.context,
+        event: createVoiceTaskCreatedEvent(task),
+        session: input.session
+      });
+    }
+  }
+  await emitRuntimeEvent({
+    api: input.api,
+    config: input.config,
+    context: input.context,
+    event: createVoiceCallCompletedEvent({
+      disposition: input.disposition,
+      session: input.session
+    }),
+    session: input.session
+  });
+  return {
+    review,
+    task
+  };
+};
+
 // src/store.ts
 var createId = () => crypto.randomUUID();
 var createVoiceSessionRecord = (id, scenarioId) => ({
@@ -515,6 +1494,9 @@ var toVoiceSessionSummary = (session) => ({
   turnCount: session.turns.length
 });
 
+// src/session.ts
+import { Buffer } from "buffer";
+
 // src/turnDetection.ts
 var DEFAULT_SILENCE_MS = 700;
 var DEFAULT_SPEECH_THRESHOLD = 0.015;
@@ -560,6 +1542,9 @@ var selectPreferredTranscriptText = (currentText, nextText) => {
   if (countWords(next) > countWords(current)) {
     return next;
   }
+  if (countWords(next) === countWords(current) && next.length > current.length) {
+    return next;
+  }
   return current;
 };
 var mergeSequentialTranscriptText = (currentText, nextText) => {
@@ -642,6 +1627,8 @@ var DEFAULT_FALLBACK_MAX_ATTEMPTS_PER_TURN = 1;
 var DEFAULT_DUPLICATE_TURN_WINDOW_MS = 5000;
 var FALLBACK_CONFIDENCE_SELECTION_DELTA = 0.05;
 var FALLBACK_WORD_COUNT_SELECTION_MARGIN_RATIO = 0.12;
+var EXTENDED_VENDOR_COMMIT_SILENCE_THRESHOLD_MS = 200;
+var MAX_VENDOR_COMMIT_GRACE_MS = 1200;
 var DEFAULT_FORMAT = {
   channels: 1,
   container: "raw",
@@ -660,6 +1647,7 @@ var createEmptyCurrentTurn = () => ({
   transcripts: []
 });
 var cloneTranscript = (transcript) => ({ ...transcript });
+var encodeBase64 = (chunk) => Buffer.from(chunk).toString("base64");
 var countWords2 = (text) => text.trim().split(/\s+/).filter(Boolean).length;
 var normalizeText2 = (text) => text.trim().replace(/\s+/g, " ");
 var getAudioChunkDurationMs = (chunk) => chunk.byteLength / (DEFAULT_FORMAT.sampleRateHz * DEFAULT_FORMAT.channels * 2) * 1000;
@@ -678,13 +1666,14 @@ var calculateMeanConfidence = (transcripts) => {
   }
   return sum / total;
 };
-var createTurnQuality = (transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics) => {
+var createTurnQuality = (transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics, costEstimate) => {
   const sampledTranscripts = transcripts.filter((transcript) => typeof transcript.confidence === "number");
   const confidenceSampleCount = sampledTranscripts.length;
   return {
     averageConfidence: confidenceSampleCount > 0 ? sampledTranscripts.reduce((sum, transcript) => sum + transcript.confidence, 0) / confidenceSampleCount : undefined,
     confidenceSampleCount,
     correction: correctionDiagnostics,
+    cost: costEstimate,
     fallback: fallbackDiagnostics,
     fallbackUsed,
     finalTranscriptCount: transcripts.filter((transcript) => transcript.isFinal).length,
@@ -693,6 +1682,19 @@ var createTurnQuality = (transcripts, source, fallbackUsed, fallbackDiagnostics,
     source
   };
 };
+var createTurnCostEstimate = (input) => {
+  const primaryMinutes = Math.max(0, input.primaryAudioMs) / 60000;
+  const fallbackMinutes = Math.max(0, input.fallbackReplayAudioMs) / 60000;
+  const primaryCostUnit = input.primaryPassCostUnit ?? 1;
+  const fallbackCostUnit = input.fallbackPassCostUnit ?? primaryCostUnit;
+  return {
+    estimatedRelativeCostUnits: primaryMinutes * primaryCostUnit + fallbackMinutes * fallbackCostUnit,
+    fallbackAttemptCount: input.fallbackAttemptCount,
+    fallbackReplayAudioMs: Math.max(0, input.fallbackReplayAudioMs),
+    primaryAudioMs: Math.max(0, input.primaryAudioMs),
+    totalBillableAudioMs: Math.max(0, input.primaryAudioMs) + Math.max(0, input.fallbackReplayAudioMs)
+  };
+};
 var normalizeCorrectionText = (text) => normalizeText2(text);
 var isFallbackNeeded = (candidate, config) => {
   const trimmed = normalizeText2(candidate.text);
@@ -761,6 +1763,36 @@ var setTurnResult = (session, turnId, input) => {
     result: input.result ?? turn.result
   } : turn);
 };
+var ensureCallLifecycleState = (session) => {
+  const startedAt = session.createdAt;
+  session.call ??= {
+    events: [],
+    lastEventAt: startedAt,
+    startedAt
+  };
+  return session.call;
+};
+var pushCallLifecycleEvent = (session, input) => {
+  const lifecycle = ensureCallLifecycleState(session);
+  const at = Date.now();
+  lifecycle.events = [
+    ...lifecycle.events,
+    {
+      at,
+      disposition: input.disposition,
+      metadata: input.metadata,
+      reason: input.reason,
+      target: input.target,
+      type: input.type
+    }
+  ];
+  lifecycle.lastEventAt = at;
+  if (input.type === "end") {
+    lifecycle.disposition = input.disposition;
+    lifecycle.endedAt = at;
+  }
+  return lifecycle;
+};
 var createVoiceSession = (options) => {
   const logger = resolveLogger(options.logger);
   const reconnect = {
@@ -784,15 +1816,21 @@ var createVoiceSession = (options) => {
     trigger: options.sttFallback.trigger ?? "empty-or-low-confidence"
   } : undefined;
   const phraseHints = options.phraseHints ?? [];
+  const lexicon = options.lexicon ?? [];
   let socket = options.socket;
   let sttSession = null;
+  let ttsSession = null;
+  let ttsSessionPromise = null;
   let silenceTimer = null;
+  let pendingCommitReason = null;
   let speechDetected = false;
   let operationQueue = Promise.resolve();
   let adapterGenerationCounter = 0;
   let activeAdapterGeneration = 0;
+  let activeTTSTurnId;
   const currentTurnAudio = [];
   let fallbackAttemptsForCurrentTurn = 0;
+  let fallbackReplayAudioMsForCurrentTurn = 0;
   const pruneTurnAudio = () => {
     const replayWindowMs = sttFallback?.replayWindowMs ?? DEFAULT_FALLBACK_REPLAY_MS;
     const cutoffAt = Date.now() - replayWindowMs;
@@ -825,6 +1863,13 @@ var createVoiceSession = (options) => {
     }
     clearTimeout(silenceTimer);
     silenceTimer = null;
+    pendingCommitReason = null;
+  };
+  const getVendorCommitDelayMs = () => {
+    if (turnDetection.silenceMs < EXTENDED_VENDOR_COMMIT_SILENCE_THRESHOLD_MS || turnDetection.transcriptStabilityMs < EXTENDED_VENDOR_COMMIT_SILENCE_THRESHOLD_MS) {
+      return turnDetection.transcriptStabilityMs;
+    }
+    return Math.max(turnDetection.transcriptStabilityMs, Math.min(MAX_VENDOR_COMMIT_GRACE_MS, turnDetection.silenceMs * 2));
   };
   const send = async (message) => {
     try {
@@ -875,6 +1920,24 @@ var createVoiceSession = (options) => {
       });
     }
   };
+  const closeTTSSession = async (reason) => {
+    const activeSession = ttsSession;
+    ttsSession = null;
+    ttsSessionPromise = null;
+    activeTTSTurnId = undefined;
+    if (!activeSession) {
+      return;
+    }
+    try {
+      await activeSession.close(reason);
+    } catch (error) {
+      logger.warn("voice tts adapter close failed", {
+        error: toError(error).message,
+        reason,
+        sessionId: options.id
+      });
+    }
+  };
   const scheduleTurnCommit = (delayMs, reason, reset = true) => {
     if (!reset && silenceTimer) {
       return;
@@ -882,8 +1945,10 @@ var createVoiceSession = (options) => {
     if (reset) {
       clearSilenceTimer();
     }
+    pendingCommitReason = reason;
     silenceTimer = setTimeout(() => {
       silenceTimer = null;
+      pendingCommitReason = null;
       api.commitTurn(reason);
     }, delayMs);
   };
@@ -898,6 +1963,10 @@ var createVoiceSession = (options) => {
       return;
     }
     const transcriptStabilityAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : undefined;
+    if (reason === "vendor") {
+      scheduleTurnCommit(getVendorCommitDelayMs(), reason);
+      return;
+    }
     if (reason !== "manual" && typeof transcriptStabilityAge === "number" && transcriptStabilityAge < turnDetection.transcriptStabilityMs) {
       scheduleTurnCommit(turnDetection.transcriptStabilityMs - transcriptStabilityAge, reason);
       return;
@@ -906,16 +1975,32 @@ var createVoiceSession = (options) => {
   };
   const failInternal = async (error) => {
     clearSilenceTimer();
+    let didFail = false;
     const session = await writeSession((currentSession) => {
+      if (currentSession.status === "failed") {
+        return;
+      }
+      didFail = true;
       currentSession.lastActivityAt = Date.now();
       currentSession.status = "failed";
+      if (!currentSession.call?.endedAt) {
+        pushCallLifecycleEvent(currentSession, {
+          disposition: "failed",
+          reason: toError(error).message,
+          type: "end"
+        });
+      }
     });
-    const resolvedError = toError(error);
+    if (!didFail) {
+      return;
+    }
+    const resolvedError = toError(error);
     await send({
       message: resolvedError.message,
       recoverable: false,
       type: "error"
     });
+    await closeTTSSession("failed");
     await closeAdapter("failed");
     speechDetected = false;
     rewindFallbackTurnAudio();
@@ -926,13 +2011,24 @@ var createVoiceSession = (options) => {
       session,
       sessionId: options.id
     });
+    await options.route.onCallEnd?.({
+      api,
+      context: options.context,
+      disposition: "failed",
+      reason: resolvedError.message,
+      session
+    });
   };
-  const completeInternal = async (result) => {
+  const completeInternal = async (result, input = {}) => {
     clearSilenceTimer();
+    const disposition = input.disposition ?? "completed";
+    const shouldInvokeOnComplete = input.invokeOnComplete ?? disposition === "completed";
+    let didComplete = false;
     const session = await writeSession((currentSession) => {
-      if (currentSession.status === "completed") {
+      if (currentSession.status === "completed" || currentSession.status === "failed") {
         return;
       }
+      didComplete = true;
       currentSession.lastActivityAt = Date.now();
       currentSession.status = "completed";
       if (result !== undefined && currentSession.turns.length > 0) {
@@ -943,18 +2039,135 @@ var createVoiceSession = (options) => {
           });
         }
       }
+      if (!currentSession.call?.endedAt) {
+        pushCallLifecycleEvent(currentSession, {
+          disposition,
+          metadata: input.metadata,
+          reason: input.reason,
+          target: input.target,
+          type: "end"
+        });
+      }
     });
+    if (!didComplete) {
+      return;
+    }
     await send({
       sessionId: options.id,
       type: "complete"
     });
+    await closeTTSSession("complete");
     await closeAdapter("complete");
     speechDetected = false;
     rewindFallbackTurnAudio();
-    await options.route.onComplete({
+    if (disposition === "transferred" && input.target) {
+      await options.route.onTransfer?.({
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        reason: input.reason,
+        session,
+        target: input.target
+      });
+    }
+    if (disposition === "escalated" && input.reason) {
+      await options.route.onEscalation?.({
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        reason: input.reason,
+        session
+      });
+    }
+    if (disposition === "voicemail") {
+      await options.route.onVoicemail?.({
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        session
+      });
+    }
+    if (disposition === "no-answer") {
+      await options.route.onNoAnswer?.({
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        session
+      });
+    }
+    if (shouldInvokeOnComplete) {
+      await options.route.onComplete({
+        api,
+        context: options.context,
+        session
+      });
+    }
+    await options.route.onCallEnd?.({
       api,
       context: options.context,
-      session
+      disposition,
+      metadata: input.metadata,
+      reason: input.reason,
+      session,
+      target: input.target
+    });
+  };
+  const transferInternal = async (input) => {
+    await writeSession((currentSession) => {
+      pushCallLifecycleEvent(currentSession, {
+        metadata: input.metadata,
+        reason: input.reason,
+        target: input.target,
+        type: "transfer"
+      });
+    });
+    await completeInternal(input.result, {
+      disposition: "transferred",
+      invokeOnComplete: false,
+      metadata: input.metadata,
+      reason: input.reason,
+      target: input.target
+    });
+  };
+  const escalateInternal = async (input) => {
+    await writeSession((currentSession) => {
+      pushCallLifecycleEvent(currentSession, {
+        metadata: input.metadata,
+        reason: input.reason,
+        type: "escalation"
+      });
+    });
+    await completeInternal(input.result, {
+      disposition: "escalated",
+      invokeOnComplete: false,
+      metadata: input.metadata,
+      reason: input.reason
+    });
+  };
+  const markNoAnswerInternal = async (input) => {
+    await writeSession((currentSession) => {
+      pushCallLifecycleEvent(currentSession, {
+        metadata: input?.metadata,
+        type: "no-answer"
+      });
+    });
+    await completeInternal(input?.result, {
+      disposition: "no-answer",
+      invokeOnComplete: false,
+      metadata: input?.metadata
+    });
+  };
+  const markVoicemailInternal = async (input) => {
+    await writeSession((currentSession) => {
+      pushCallLifecycleEvent(currentSession, {
+        metadata: input?.metadata,
+        type: "voicemail"
+      });
+    });
+    await completeInternal(input?.result, {
+      disposition: "voicemail",
+      invokeOnComplete: false,
+      metadata: input?.metadata
     });
   };
   const handleError = async (event) => {
@@ -980,6 +2193,7 @@ var createVoiceSession = (options) => {
   };
   const rewindFallbackTurnAudio = () => {
     fallbackAttemptsForCurrentTurn = 0;
+    fallbackReplayAudioMsForCurrentTurn = 0;
     currentTurnAudio.length = 0;
   };
   const runFallbackTranscription = async (primaryText, primaryTranscripts) => {
@@ -1007,6 +2221,8 @@ var createVoiceSession = (options) => {
     try {
       fallbackSession = await sttFallback.adapter.open({
         format: DEFAULT_FORMAT,
+        languageStrategy: options.languageStrategy,
+        lexicon,
         phraseHints,
         sessionId: `${options.id}:fallback:${fallbackAttemptsForCurrentTurn}`
       });
@@ -1060,6 +2276,7 @@ var createVoiceSession = (options) => {
         await fallbackSession.send(chunk);
       }
       const replayDurationMs = getBufferedAudioDurationMs(replayAudio);
+      fallbackReplayAudioMsForCurrentTurn += replayDurationMs;
       const completionTimeoutMs = Math.max(sttFallback.completionTimeoutMs, Math.min(4000, Math.max(sttFallback.settleMs * 4, Math.round(replayDurationMs * 0.18))));
       const waitStartedAt = Date.now();
       while (Date.now() - waitStartedAt < completionTimeoutMs) {
@@ -1152,6 +2369,7 @@ var createVoiceSession = (options) => {
       api,
       context: options.context,
       fallback: input.fallbackDiagnostics,
+      lexicon,
       phraseHints,
       session: input.session,
       text: originalText,
@@ -1220,46 +2438,52 @@ var createVoiceSession = (options) => {
     };
   };
   const handlePartial = async (transcript) => {
-    await writeSession((session) => {
-      const nextPartialStartedAt = transcript.startedAtMs ?? session.currentTurn.partialStartedAt;
-      const nextPartialEndedAt = transcript.endedAtMs ?? session.currentTurn.partialEndedAt;
-      const preferredPartial = selectPreferredTranscriptText(session.currentTurn.partialText, transcript.text);
-      session.currentTurn.lastTranscriptAt = Date.now();
-      session.currentTurn.partialStartedAt = nextPartialStartedAt;
-      session.currentTurn.partialEndedAt = nextPartialEndedAt;
-      session.currentTurn.partialText = buildTurnText(session.currentTurn.transcripts, preferredPartial, {
+    const session = await writeSession((session2) => {
+      const nextPartialStartedAt = transcript.startedAtMs ?? session2.currentTurn.partialStartedAt;
+      const nextPartialEndedAt = transcript.endedAtMs ?? session2.currentTurn.partialEndedAt;
+      const preferredPartial = selectPreferredTranscriptText(session2.currentTurn.partialText, transcript.text);
+      session2.currentTurn.lastTranscriptAt = Date.now();
+      session2.currentTurn.partialStartedAt = nextPartialStartedAt;
+      session2.currentTurn.partialEndedAt = nextPartialEndedAt;
+      session2.currentTurn.partialText = buildTurnText(session2.currentTurn.transcripts, preferredPartial, {
         partialEndedAtMs: nextPartialEndedAt,
         partialStartedAtMs: nextPartialStartedAt
       });
-      session.lastActivityAt = Date.now();
-      session.status = "active";
+      session2.lastActivityAt = Date.now();
+      session2.status = "active";
     });
+    if (silenceTimer && pendingCommitReason === "vendor") {
+      scheduleTurnCommit(getVendorCommitDelayMs(), "vendor");
+    }
     await send({
       transcript,
       type: "partial"
     });
   };
   const handleFinal = async (transcript) => {
-    await writeSession((session) => {
-      const alreadyPresent = session.currentTurn.transcripts.some((existing) => existing.id === transcript.id);
+    const session = await writeSession((session2) => {
+      const alreadyPresent = session2.currentTurn.transcripts.some((existing) => existing.id === transcript.id);
       if (!alreadyPresent) {
-        session.currentTurn.transcripts = [
-          ...session.currentTurn.transcripts,
+        session2.currentTurn.transcripts = [
+          ...session2.currentTurn.transcripts,
           cloneTranscript(transcript)
         ];
-        session.transcripts = [
-          ...session.transcripts,
+        session2.transcripts = [
+          ...session2.transcripts,
           cloneTranscript(transcript)
         ];
       }
-      session.currentTurn.finalText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
-        partialEndedAtMs: session.currentTurn.partialEndedAt,
-        partialStartedAtMs: session.currentTurn.partialStartedAt
+      session2.currentTurn.finalText = buildTurnText(session2.currentTurn.transcripts, session2.currentTurn.partialText, {
+        partialEndedAtMs: session2.currentTurn.partialEndedAt,
+        partialStartedAtMs: session2.currentTurn.partialStartedAt
       });
-      session.currentTurn.lastTranscriptAt = Date.now();
-      session.lastActivityAt = Date.now();
-      session.status = "active";
+      session2.currentTurn.lastTranscriptAt = Date.now();
+      session2.lastActivityAt = Date.now();
+      session2.status = "active";
     });
+    if (silenceTimer && pendingCommitReason === "vendor") {
+      scheduleTurnCommit(getVendorCommitDelayMs(), "vendor");
+    }
     await send({
       transcript,
       type: "final"
@@ -1286,6 +2510,8 @@ var createVoiceSession = (options) => {
     }
     const openedSession = await options.stt.open({
       format: DEFAULT_FORMAT,
+      languageStrategy: options.languageStrategy,
+      lexicon,
       phraseHints,
       sessionId: options.id
     });
@@ -1320,13 +2546,93 @@ var createVoiceSession = (options) => {
     });
     return openedSession;
   };
+  const ensureTTSSession = async () => {
+    const ttsAdapter = options.tts;
+    if (!ttsAdapter) {
+      return null;
+    }
+    if (ttsSession) {
+      return ttsSession;
+    }
+    if (ttsSessionPromise) {
+      return ttsSessionPromise;
+    }
+    ttsSessionPromise = (async () => {
+      const openedSession = await ttsAdapter.open({
+        lexicon,
+        sessionId: options.id
+      });
+      ttsSession = openedSession;
+      openedSession.on("audio", ({ chunk, format, receivedAt }) => {
+        runSerial("tts.audio", async () => {
+          if (ttsSession !== openedSession) {
+            return;
+          }
+          const normalizedChunk = chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk instanceof ArrayBuffer ? new Uint8Array(chunk.slice(0)) : new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
+          await send({
+            chunkBase64: encodeBase64(normalizedChunk),
+            format,
+            receivedAt,
+            turnId: activeTTSTurnId,
+            type: "audio"
+          });
+        });
+      });
+      openedSession.on("error", (event) => {
+        runSerial("tts.error", async () => {
+          if (ttsSession !== openedSession) {
+            return;
+          }
+          await send({
+            message: toError(event.error).message,
+            recoverable: event.recoverable,
+            type: "error"
+          });
+        });
+      });
+      openedSession.on("close", () => {
+        runSerial("tts.close", async () => {
+          if (ttsSession === openedSession) {
+            ttsSession = null;
+            ttsSessionPromise = null;
+            activeTTSTurnId = undefined;
+          }
+        });
+      });
+      return openedSession;
+    })().catch((error) => {
+      ttsSessionPromise = null;
+      throw error;
+    });
+    return ttsSessionPromise;
+  };
+  const warmTTSSession = () => {
+    if (!options.tts || ttsSession || ttsSessionPromise) {
+      return;
+    }
+    ensureTTSSession().catch((error) => {
+      logger.warn("voice tts prewarm failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    });
+  };
   const completeTurn = async (session, turn) => {
-    const output = await options.route.onTurn({
+    const committedOutput = await options.route.onTurn({
       api,
       context: options.context,
       session,
       turn
     });
+    const output = {
+      assistantText: committedOutput?.assistantText,
+      complete: committedOutput?.complete,
+      escalate: committedOutput?.escalate,
+      noAnswer: committedOutput?.noAnswer,
+      result: committedOutput?.result,
+      transfer: committedOutput?.transfer,
+      voicemail: committedOutput?.voicemail
+    };
     if (output?.assistantText) {
       await writeSession((currentSession) => {
         setTurnResult(currentSession, turn.id, {
@@ -1338,6 +2644,19 @@ var createVoiceSession = (options) => {
         turnId: turn.id,
         type: "assistant"
       });
+      try {
+        const activeTTSSession = await ensureTTSSession();
+        if (activeTTSSession) {
+          activeTTSTurnId = turn.id;
+          await activeTTSSession.send(output.assistantText);
+        }
+      } catch (error) {
+        logger.warn("voice tts send failed", {
+          error: toError(error).message,
+          sessionId: options.id,
+          turnId: turn.id
+        });
+      }
     }
     if (output?.result !== undefined) {
       await writeSession((currentSession) => {
@@ -1346,6 +2665,37 @@ var createVoiceSession = (options) => {
         });
       });
     }
+    if (output?.transfer) {
+      await transferInternal({
+        metadata: output.transfer.metadata,
+        reason: output.transfer.reason,
+        result: output.result,
+        target: output.transfer.target
+      });
+      return;
+    }
+    if (output?.escalate) {
+      await escalateInternal({
+        metadata: output.escalate.metadata,
+        reason: output.escalate.reason,
+        result: output.result
+      });
+      return;
+    }
+    if (output?.voicemail) {
+      await markVoicemailInternal({
+        metadata: output.voicemail.metadata,
+        result: output.result
+      });
+      return;
+    }
+    if (output?.noAnswer) {
+      await markNoAnswerInternal({
+        metadata: output.noAnswer.metadata,
+        result: output.result
+      });
+      return;
+    }
     if (output?.complete) {
       await completeInternal(output.result);
     }
@@ -1410,11 +2760,18 @@ var createVoiceSession = (options) => {
       scheduleTurnCommit(turnDetection.transcriptStabilityMs - transcriptStabilityAge, reason, false);
       return;
     }
+    const costEstimate = createTurnCostEstimate({
+      fallbackAttemptCount: fallbackAttemptsForCurrentTurn,
+      fallbackPassCostUnit: options.costTelemetry?.fallbackPassCostUnit,
+      fallbackReplayAudioMs: fallbackReplayAudioMsForCurrentTurn,
+      primaryAudioMs: getBufferedAudioDurationMs(currentTurnAudio.map((audio) => audio.chunk)),
+      primaryPassCostUnit: options.costTelemetry?.primaryPassCostUnit
+    });
     const turn = {
       committedAt: Date.now(),
       id: createId(),
       text: finalText,
-      quality: createTurnQuality(transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics),
+      quality: createTurnQuality(transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics, costEstimate),
       transcripts: transcripts.length > 0 ? transcripts : [
         {
           id: createId(),
@@ -1441,6 +2798,13 @@ var createVoiceSession = (options) => {
       sessionId: options.id,
       turnId: turn.id
     });
+    await options.costTelemetry?.onTurnCost?.({
+      api,
+      context: options.context,
+      estimate: costEstimate,
+      session: updatedSession,
+      turn
+    });
     await send({
       turn,
       type: "turn"
@@ -1486,6 +2850,11 @@ var createVoiceSession = (options) => {
         };
       }
     }
+    if (shouldFireOnSession) {
+      pushCallLifecycleEvent(session, {
+        type: "start"
+      });
+    }
     await options.store.set(options.id, session);
     await send({
       sessionId: options.id,
@@ -1494,6 +2863,11 @@ var createVoiceSession = (options) => {
       type: "session"
     });
     if (shouldFireOnSession) {
+      await options.route.onCallStart?.({
+        api,
+        context: options.context,
+        session
+      });
       await options.route.onSession?.({
         api,
         context: options.context,
@@ -1509,9 +2883,11 @@ var createVoiceSession = (options) => {
     }
     resumePendingTurnCommit(session);
     await ensureAdapter();
+    warmTTSSession();
   };
   const disconnectInternal = async (event) => {
     clearSilenceTimer();
+    await closeTTSSession(event?.reason);
     await closeAdapter(event?.reason);
     rewindFallbackTurnAudio();
     if (reconnect.strategy === "fail") {
@@ -1570,9 +2946,30 @@ var createVoiceSession = (options) => {
     id: options.id,
     close: async (reason) => {
       await runSerial("api.close", async () => {
+        const session = await writeSession((currentSession) => {
+          if (currentSession.status !== "completed" && currentSession.status !== "failed" && !currentSession.call?.endedAt) {
+            currentSession.lastActivityAt = Date.now();
+            currentSession.status = "completed";
+            pushCallLifecycleEvent(currentSession, {
+              disposition: "closed",
+              reason,
+              type: "end"
+            });
+          }
+        });
         clearSilenceTimer();
+        await closeTTSSession(reason);
         await closeAdapter(reason);
         await Promise.resolve(socket.close(1000, reason));
+        if (session.call?.endedAt && session.call.disposition === "closed") {
+          await options.route.onCallEnd?.({
+            api,
+            context: options.context,
+            disposition: "closed",
+            reason,
+            session
+          });
+        }
       });
     },
     commitTurn: async (reason = "manual") => runSerial("api.commitTurn", async () => {
@@ -1590,9 +2987,21 @@ var createVoiceSession = (options) => {
     fail: async (error) => runSerial("api.fail", async () => {
       await failInternal(error);
     }),
+    escalate: async (input) => runSerial("api.escalate", async () => {
+      await escalateInternal(input);
+    }),
+    markNoAnswer: async (input) => runSerial("api.markNoAnswer", async () => {
+      await markNoAnswerInternal(input);
+    }),
+    markVoicemail: async (input) => runSerial("api.markVoicemail", async () => {
+      await markVoicemailInternal(input);
+    }),
     receiveAudio: async (audio) => runSerial("api.receiveAudio", async () => {
       await receiveAudioInternal(audio);
     }),
+    transfer: async (input) => runSerial("api.transfer", async () => {
+      await transferInternal(input);
+    }),
     snapshot: async () => runSerial("api.snapshot", async () => readSession())
   };
   return api;
@@ -1740,6 +3149,7 @@ var resolveSessionOptions = (config) => {
   const preset = resolveVoiceRuntimePreset(config.preset);
   return {
     audioConditioning: config.audioConditioning !== undefined ? resolveAudioConditioningConfig(config.audioConditioning) : preset.audioConditioning,
+    costTelemetry: config.costTelemetry,
     sttFallback: resolveSTTFallbackConfig(config.sttFallback),
     logger: config.logger,
     reconnect: {
@@ -1759,6 +3169,13 @@ var normalizePhraseHints = (hints) => (hints ?? []).map((hint) => ({
   aliases: hint.aliases?.filter((value) => typeof value === "string" && value.trim().length > 0),
   text: hint.text.trim()
 })).filter((hint) => hint.text.length > 0);
+var normalizeLexicon = (entries) => (entries ?? []).map((entry) => ({
+  ...entry,
+  aliases: entry.aliases?.filter((value) => typeof value === "string" && value.trim().length > 0),
+  language: typeof entry.language === "string" && entry.language.trim().length > 0 ? entry.language.trim() : undefined,
+  pronunciation: typeof entry.pronunciation === "string" && entry.pronunciation.trim().length > 0 ? entry.pronunciation.trim() : undefined,
+  text: entry.text.trim()
+})).filter((entry) => entry.text.length > 0);
 var resolvePhraseHints = async (config, input) => {
   if (!config.phraseHints) {
     return [];
@@ -1768,6 +3185,15 @@ var resolvePhraseHints = async (config, input) => {
   }
   return normalizePhraseHints(config.phraseHints);
 };
+var resolveLexicon = async (config, input) => {
+  if (!config.lexicon) {
+    return [];
+  }
+  if (typeof config.lexicon === "function") {
+    return normalizeLexicon(await config.lexicon(input));
+  }
+  return normalizeLexicon(config.lexicon);
+};
 var voice = (config) => {
   const runtime = {
     activeSessions: new Map,
@@ -1788,19 +3214,55 @@ var voice = (config) => {
       scenarioId,
       sessionId
     });
+    const lexicon = await resolveLexicon(config, {
+      context,
+      scenarioId,
+      sessionId
+    });
     return createVoiceSession({
       audioConditioning: sessionOptions.audioConditioning,
       context,
       id: sessionId,
+      languageStrategy: config.languageStrategy,
+      lexicon,
       logger: sessionOptions.logger,
       phraseHints,
       reconnect: sessionOptions.reconnect,
       route: {
         correctTurn: config.correctTurn,
+        onCallEnd: async (input) => {
+          let hookError;
+          try {
+            await config.onCallEnd?.(input);
+          } catch (error) {
+            hookError = error;
+          }
+          try {
+            await recordVoiceRuntimeOps({
+              api: input.api,
+              config: config.ops,
+              context: input.context,
+              disposition: input.disposition,
+              metadata: input.metadata,
+              reason: input.reason,
+              session: input.session,
+              target: input.target
+            });
+          } finally {
+            if (hookError) {
+              throw hookError;
+            }
+          }
+        },
+        onCallStart: config.onCallStart,
         onComplete: config.onComplete,
+        onEscalation: config.onEscalation,
         onError: config.onError,
+        onNoAnswer: config.onNoAnswer,
         onSession: config.onSession,
-        onTurn
+        onTransfer: config.onTransfer,
+        onTurn,
+        onVoicemail: config.onVoicemail
       },
       scenarioId,
       socket: createSocketAdapter(ws),
@@ -1808,6 +3270,7 @@ var voice = (config) => {
       stt: config.stt,
       sttFallback: sessionOptions.sttFallback,
       sttLifecycle: sessionOptions.sttLifecycle,
+      tts: config.tts,
       turnDetection: sessionOptions.turnDetection
     });
   };
@@ -1916,6 +3379,171 @@ var voice = (config) => {
     }
   }).use(htmxRoutes());
 };
+// src/fileStore.ts
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { join } from "path";
+var listJsonFiles = async (directory) => {
+  try {
+    const entries = await readdir(directory, {
+      withFileTypes: true
+    });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join(directory, entry.name));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+var encodeStoreId = (id) => `${encodeURIComponent(id)}.json`;
+var resolveFilePath = (directory, id) => join(directory, encodeStoreId(id));
+var readJsonFile = async (path) => JSON.parse(await readFile(path, "utf8"));
+var writeJsonFile = async (path, value, options) => {
+  await mkdir(options.directory, {
+    recursive: true
+  });
+  const tempPath = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile(tempPath, JSON.stringify(value, null, options.pretty === false ? undefined : 2));
+  await rename(tempPath, path);
+};
+var createVoiceFileSessionStore = (options) => {
+  const get = async (id) => {
+    const path = resolveFilePath(options.directory, id);
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const getOrCreate = async (id) => {
+    const existing = await get(id);
+    if (existing) {
+      return existing;
+    }
+    const session = createVoiceSessionRecord(id);
+    await writeJsonFile(resolveFilePath(options.directory, id), session, options);
+    return session;
+  };
+  const set = async (id, value) => {
+    await writeJsonFile(resolveFilePath(options.directory, id), value, options);
+  };
+  const list = async () => {
+    const files = await listJsonFiles(options.directory);
+    const sessions = await Promise.all(files.map((file) => readJsonFile(file)));
+    return sessions.map((session) => toVoiceSessionSummary(session)).sort((first, second) => (second.lastActivityAt ?? second.createdAt) - (first.lastActivityAt ?? first.createdAt));
+  };
+  const remove = async (id) => {
+    await rm(resolveFilePath(options.directory, id), {
+      force: true
+    });
+  };
+  return { get, getOrCreate, list, remove, set };
+};
+var createVoiceFileReviewStore = (options) => {
+  const get = async (id) => {
+    const path = resolveFilePath(options.directory, id);
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async () => {
+    const files = await listJsonFiles(options.directory);
+    const reviews = await Promise.all(files.map((file) => readJsonFile(file)));
+    return reviews.sort((left, right) => (right.generatedAt ?? 0) - (left.generatedAt ?? 0));
+  };
+  const set = async (id, artifact) => {
+    await writeJsonFile(resolveFilePath(options.directory, id), withVoiceCallReviewId(id, artifact), options);
+  };
+  const remove = async (id) => {
+    await rm(resolveFilePath(options.directory, id), {
+      force: true
+    });
+  };
+  return { get, list, remove, set };
+};
+var createVoiceFileTaskStore = (options) => {
+  const get = async (id) => {
+    const path = resolveFilePath(options.directory, id);
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async () => {
+    const files = await listJsonFiles(options.directory);
+    const tasks = await Promise.all(files.map((file) => readJsonFile(file)));
+    return tasks.sort((left, right) => right.createdAt - left.createdAt);
+  };
+  const set = async (id, task) => {
+    await writeJsonFile(resolveFilePath(options.directory, id), withVoiceOpsTaskId(id, task), options);
+  };
+  const remove = async (id) => {
+    await rm(resolveFilePath(options.directory, id), {
+      force: true
+    });
+  };
+  return { get, list, remove, set };
+};
+var createVoiceFileIntegrationEventStore = (options) => {
+  const get = async (id) => {
+    const path = resolveFilePath(options.directory, id);
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async () => {
+    const files = await listJsonFiles(options.directory);
+    const events = await Promise.all(files.map((file) => readJsonFile(file)));
+    return events.sort((left, right) => right.createdAt - left.createdAt);
+  };
+  const set = async (id, event) => {
+    await writeJsonFile(resolveFilePath(options.directory, id), withVoiceIntegrationEventId(id, event), options);
+  };
+  const remove = async (id) => {
+    await rm(resolveFilePath(options.directory, id), {
+      force: true
+    });
+  };
+  return { get, list, remove, set };
+};
+var createVoiceFileRuntimeStorage = (options) => ({
+  events: createVoiceFileIntegrationEventStore({
+    ...options,
+    directory: join(options.directory, "events")
+  }),
+  reviews: createVoiceFileReviewStore({
+    ...options,
+    directory: join(options.directory, "reviews")
+  }),
+  session: createVoiceFileSessionStore({
+    ...options,
+    directory: join(options.directory, "sessions")
+  }),
+  tasks: createVoiceFileTaskStore({
+    ...options,
+    directory: join(options.directory, "tasks")
+  })
+});
+var createStoredVoiceCallReviewArtifact = (id, artifact) => withVoiceCallReviewId(id, artifact);
+var createStoredVoiceOpsTask = (id, task) => withVoiceOpsTaskId(id, task);
+var createStoredVoiceIntegrationEvent = (id, event) => withVoiceIntegrationEventId(id, event);
 // src/memoryStore.ts
 var createVoiceMemoryStore = () => {
   const sessions = new Map;
@@ -1939,21 +3567,146 @@ var createVoiceMemoryStore = () => {
 };
 // src/correction.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var buildAliasMatcher = (alias) => new RegExp(`(?<![\\p{L}\\p{N}'])${escapeRegExp(alias)}(?![\\p{L}\\p{N}'])`, "giu");
+var WORD_PATTERN = /[\p{L}\p{N}']+/gu;
+var normalizeComparableText = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
+var normalizeDomainTerm = (value) => normalizeComparableText(value);
+var tokenizeWithIndices = (value) => {
+  const matches = value.matchAll(WORD_PATTERN);
+  const tokens = [];
+  for (const match of matches) {
+    const token = match[0];
+    const start = match.index ?? -1;
+    if (start < 0) {
+      continue;
+    }
+    tokens.push({
+      end: start + token.length,
+      start,
+      text: token
+    });
+  }
+  return tokens;
+};
+var levenshteinDistance = (left, right) => {
+  if (left === right) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return right.length;
+  }
+  if (right.length === 0) {
+    return left.length;
+  }
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  const current = new Array(right.length + 1);
+  for (let leftIndex = 1;leftIndex <= left.length; leftIndex += 1) {
+    current[0] = leftIndex;
+    for (let rightIndex = 1;rightIndex <= right.length; rightIndex += 1) {
+      const cost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+      current[rightIndex] = Math.min(current[rightIndex - 1] + 1, previous[rightIndex] + 1, previous[rightIndex - 1] + cost);
+    }
+    for (let rightIndex = 0;rightIndex <= right.length; rightIndex += 1) {
+      previous[rightIndex] = current[rightIndex];
+    }
+  }
+  return previous[right.length];
+};
+var resolveFuzzyThreshold = (riskTier) => {
+  switch (riskTier) {
+    case "safe":
+      return -1;
+    case "balanced":
+      return 0.14;
+    case "risky":
+      return 0.2;
+  }
+};
+var canUseTieredFuzzyAlias = (alias, riskTier) => {
+  if (riskTier === "safe") {
+    return false;
+  }
+  const tokenCount = normalizeComparableText(alias).split(" ").filter((token) => token.length > 0).length;
+  return riskTier === "balanced" ? tokenCount >= 3 : tokenCount >= 2;
+};
+var findFuzzyAliasMatch = (text, alias, riskTier) => {
+  const tokens = tokenizeWithIndices(text);
+  const aliasTokens = normalizeComparableText(alias).split(" ").filter((token) => token.length > 0);
+  if (tokens.length === 0 || aliasTokens.length < 2) {
+    return;
+  }
+  const minWindowLength = Math.max(1, aliasTokens.length - 1);
+  const maxWindowLength = Math.min(tokens.length, aliasTokens.length + 1);
+  const normalizedAlias = aliasTokens.join(" ");
+  const normalizedAliasFirstToken = aliasTokens[0] ?? "";
+  let bestMatch;
+  for (let startIndex = 0;startIndex < tokens.length; startIndex += 1) {
+    for (let windowLength = minWindowLength;windowLength <= maxWindowLength; windowLength += 1) {
+      const endIndex = startIndex + windowLength - 1;
+      if (endIndex >= tokens.length) {
+        break;
+      }
+      const windowTokens = tokens.slice(startIndex, endIndex + 1);
+      const normalizedWindow = normalizeComparableText(windowTokens.map((token) => token.text).join(" "));
+      if (!normalizedWindow) {
+        continue;
+      }
+      const [windowFirstToken] = normalizedWindow.split(" ");
+      if (windowFirstToken !== normalizedAliasFirstToken) {
+        continue;
+      }
+      const distance = levenshteinDistance(normalizedWindow, normalizedAlias);
+      const denominator = Math.max(normalizedWindow.length, normalizedAlias.length);
+      const score = denominator > 0 ? distance / denominator : 0;
+      if (score > resolveFuzzyThreshold(riskTier)) {
+        continue;
+      }
+      const candidate = {
+        end: windowTokens[windowTokens.length - 1].end,
+        score,
+        start: windowTokens[0].start
+      };
+      if (!bestMatch || candidate.score < bestMatch.score || candidate.score === bestMatch.score && candidate.end - candidate.start > bestMatch.end - bestMatch.start) {
+        bestMatch = candidate;
+      }
+    }
+  }
+  return bestMatch;
+};
 var normalizeHintAliases = (hint) => (hint.aliases ?? []).map((alias) => alias.trim()).filter((alias) => alias.length > 0).sort((left, right) => right.length - left.length);
 var applyPhraseHintCorrections = (text, phraseHints) => {
+  return applyRiskTieredPhraseHintCorrections(text, phraseHints, {
+    riskTier: "risky"
+  });
+};
+var applyRiskTieredPhraseHintCorrections = (text, phraseHints, options = {}) => {
+  const riskTier = options.riskTier ?? "safe";
   let corrected = text;
   const matches = [];
   for (const hint of phraseHints) {
     for (const alias of normalizeHintAliases(hint)) {
-      const matcher = new RegExp(`\\b${escapeRegExp(alias)}\\b`, "gi");
+      const matcher = buildAliasMatcher(alias);
       if (!matcher.test(corrected)) {
-        continue;
+        if (!canUseTieredFuzzyAlias(alias, riskTier)) {
+          continue;
+        }
+        const fuzzyMatch = findFuzzyAliasMatch(corrected, alias, riskTier);
+        if (!fuzzyMatch) {
+          continue;
+        }
+        corrected = `${corrected.slice(0, fuzzyMatch.start)}${hint.text}${corrected.slice(fuzzyMatch.end)}`;
+        matches.push({
+          alias,
+          hint
+        });
+        break;
       }
       corrected = corrected.replace(matcher, hint.text);
       matches.push({
         alias,
         hint
       });
+      break;
     }
   }
   return {
@@ -1962,6 +3715,79 @@ var applyPhraseHintCorrections = (text, phraseHints) => {
     text: corrected
   };
 };
+var dedupeAliases = (aliases) => {
+  const seen = new Set;
+  const deduped = [];
+  for (const alias of aliases) {
+    const normalized = normalizeDomainTerm(alias);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    deduped.push(alias);
+  }
+  return deduped;
+};
+var isSafeAlias = (alias) => {
+  const normalized = normalizeDomainTerm(alias);
+  if (normalized.length < 4) {
+    return false;
+  }
+  const tokens = normalized.split(" ").filter((token) => token.length > 0);
+  return tokens.length >= 2 || normalized.length >= 7;
+};
+var createDomainPhraseHints = (terms, options = {}) => {
+  const riskTier = options.riskTier ?? "safe";
+  const hints = [];
+  const seen = new Set;
+  for (const term of terms) {
+    const normalizedText = normalizeDomainTerm(term.text);
+    if (!normalizedText || seen.has(normalizedText)) {
+      continue;
+    }
+    const candidateAliases = dedupeAliases(term.aliases ?? []);
+    const aliases = candidateAliases.filter((alias) => {
+      if (riskTier === "risky") {
+        return true;
+      }
+      if (riskTier === "balanced") {
+        return isSafeAlias(alias) || normalizeDomainTerm(alias) === normalizedText;
+      }
+      return isSafeAlias(alias);
+    });
+    hints.push({
+      aliases: aliases.length > 0 ? aliases : undefined,
+      boost: term.boost,
+      metadata: term.metadata,
+      text: term.text
+    });
+    seen.add(normalizedText);
+  }
+  return hints;
+};
+var createDomainLexicon = (terms) => {
+  const entries = [];
+  const seen = new Set;
+  for (const term of terms) {
+    const normalizedText = normalizeDomainTerm(term.text);
+    if (!normalizedText || seen.has(normalizedText)) {
+      continue;
+    }
+    entries.push({
+      aliases: dedupeAliases(term.aliases ?? []),
+      language: term.language,
+      metadata: term.metadata,
+      pronunciation: term.pronunciation,
+      text: term.text
+    });
+    seen.add(normalizedText);
+  }
+  return entries;
+};
+var averageTranscriptConfidence = (transcripts) => {
+  const confidences = transcripts.map((transcript) => transcript.confidence).filter((value) => typeof value === "number");
+  return confidences.length > 0 ? confidences.reduce((sum, value) => sum + value, 0) / confidences.length : undefined;
+};
 var createPhraseHintCorrectionHandler = (options = {}) => {
   const provider = options.provider ?? "@absolutejs/voice";
   const reason = options.reason ?? "phrase-hint-correction";
@@ -1981,17 +3807,583 @@ var createPhraseHintCorrectionHandler = (options = {}) => {
     };
   };
 };
+var lexiconToPhraseHints = (lexicon) => lexicon.map((entry) => ({
+  aliases: entry.aliases,
+  metadata: entry.metadata,
+  text: entry.text
+}));
+var applyLexiconCorrections = (text, lexicon) => applyPhraseHintCorrections(text, lexiconToPhraseHints(lexicon));
+var createLexiconCorrectionHandler = (options = {}) => {
+  const provider = options.provider ?? "@absolutejs/voice";
+  const reason = options.reason ?? "lexicon-correction";
+  return async ({ lexicon, text }) => {
+    const result = applyLexiconCorrections(text, lexicon);
+    if (!result.changed) {
+      return;
+    }
+    return {
+      metadata: result.matches.length > 0 ? {
+        matchedAliases: result.matches.map((match) => match.alias),
+        matchedHints: result.matches.map((match) => match.hint.text)
+      } : undefined,
+      provider,
+      reason,
+      text: result.text
+    };
+  };
+};
+var createRiskyTurnCorrectionHandler = (options = {}) => {
+  const provider = options.provider ?? "@absolutejs/voice";
+  const reason = options.reason ?? "risky-turn-correction";
+  const riskTier = options.riskTier ?? "balanced";
+  const maxAverageConfidence = options.maxAverageConfidence ?? 0.92;
+  return async ({ lexicon, phraseHints, text, transcripts }) => {
+    const averageConfidence = averageTranscriptConfidence(transcripts);
+    if (averageConfidence !== undefined && averageConfidence > maxAverageConfidence) {
+      return;
+    }
+    const result = applyRiskTieredPhraseHintCorrections(text, [
+      ...phraseHints,
+      ...lexiconToPhraseHints(lexicon)
+    ], { riskTier });
+    if (!result.changed) {
+      return;
+    }
+    return {
+      metadata: {
+        averageConfidence,
+        matchedAliases: result.matches.map((match) => match.alias),
+        matchedHints: result.matches.map((match) => match.hint.text),
+        riskTier
+      },
+      provider,
+      reason,
+      text: result.text
+    };
+  };
+};
+
+// src/routing.ts
+var resolveVoiceSTTRoutingStrategy = (goal = "best") => {
+  if (goal === "low-cost") {
+    return {
+      benchmarkSessionTarget: "deepgram-flux",
+      correctionMode: "none",
+      goal,
+      notes: [
+        "Uses the cheapest in-package path: one primary STT pass with no correction hook.",
+        "Good for baseline throughput and lower post-processing overhead."
+      ],
+      preset: "default",
+      sttLifecycle: "turn-scoped"
+    };
+  }
+  return {
+    benchmarkSessionTarget: "deepgram-corrected",
+    correctionMode: "generic",
+    goal,
+    notes: [
+      "Uses the current best in-package path: Deepgram Flux with generic deterministic correction.",
+      "Optimized for accuracy and robustness rather than minimum processing cost."
+    ],
+    preset: "reliability",
+    sttLifecycle: "continuous"
+  };
+};
+var createVoiceSTTRoutingCorrectionHandler = (mode = "generic") => {
+  if (mode === "none") {
+    return;
+  }
+  if (mode === "risky-turn") {
+    return createRiskyTurnCorrectionHandler();
+  }
+  return createPhraseHintCorrectionHandler();
+};
+// src/telephony/twilio.ts
+import { Buffer as Buffer2 } from "buffer";
+var TWILIO_MULAW_SAMPLE_RATE = 8000;
+var VOICE_PCM_SAMPLE_RATE = 16000;
+var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var normalizeOnTurn2 = (handler) => {
+  if (handler.length > 1) {
+    const directHandler = handler;
+    return async ({ context, session, turn, api }) => directHandler(session, turn, api, context);
+  }
+  return handler;
+};
+var resolveSTTFallbackConfig2 = (config) => {
+  if (!config) {
+    return;
+  }
+  return {
+    adapter: config.adapter,
+    completionTimeoutMs: config.completionTimeoutMs ?? 2500,
+    confidenceThreshold: config.confidenceThreshold ?? 0.6,
+    maxAttemptsPerTurn: config.maxAttemptsPerTurn ?? 1,
+    minTextLength: config.minTextLength ?? 2,
+    replayWindowMs: config.replayWindowMs ?? 8000,
+    settleMs: config.settleMs ?? 220,
+    trigger: config.trigger ?? "empty-or-low-confidence"
+  };
+};
+var normalizePhraseHints2 = (hints) => (hints ?? []).map((hint) => ({
+  ...hint,
+  aliases: hint.aliases?.filter((value) => typeof value === "string" && value.trim().length > 0),
+  text: hint.text.trim()
+})).filter((hint) => hint.text.length > 0);
+var normalizeLexicon2 = (entries) => (entries ?? []).map((entry) => ({
+  ...entry,
+  aliases: entry.aliases?.filter((value) => typeof value === "string" && value.trim().length > 0),
+  language: typeof entry.language === "string" && entry.language.trim().length > 0 ? entry.language.trim() : undefined,
+  pronunciation: typeof entry.pronunciation === "string" && entry.pronunciation.trim().length > 0 ? entry.pronunciation.trim() : undefined,
+  text: entry.text.trim()
+})).filter((entry) => entry.text.length > 0);
+var clamp16 = (value) => Math.max(-32768, Math.min(32767, Math.round(value)));
+var linearResample = (input, inputRate, outputRate) => {
+  if (input.length === 0) {
+    return new Int16Array(0);
+  }
+  if (inputRate === outputRate) {
+    return new Int16Array(input);
+  }
+  const outputLength = Math.max(1, Math.round(input.length * outputRate / inputRate));
+  const output = new Int16Array(outputLength);
+  const ratio = inputRate / outputRate;
+  for (let index = 0;index < outputLength; index += 1) {
+    const sourcePosition = index * ratio;
+    const leftIndex = Math.floor(sourcePosition);
+    const rightIndex = Math.min(input.length - 1, leftIndex + 1);
+    const blend = sourcePosition - leftIndex;
+    const left = input[Math.min(leftIndex, input.length - 1)] ?? 0;
+    const right = input[rightIndex] ?? left;
+    output[index] = clamp16(left + (right - left) * blend);
+  }
+  return output;
+};
+var MULAW_BIAS = 132;
+var MULAW_CLIP = 32635;
+var encodeMulawSample = (sample) => {
+  let value = clamp16(sample);
+  let sign = 0;
+  if (value < 0) {
+    sign = 128;
+    value = -value;
+  }
+  value = Math.min(MULAW_CLIP, value);
+  value += MULAW_BIAS;
+  let exponent = 7;
+  for (let bit = 16384;(value & bit) === 0 && exponent > 0; bit >>= 1) {
+    exponent -= 1;
+  }
+  const mantissa = value >> exponent + 3 & 15;
+  return ~(sign | exponent << 4 | mantissa) & 255;
+};
+var decodeMulawSample = (value) => {
+  const normalized = ~value & 255;
+  const sign = normalized & 128;
+  const exponent = normalized >> 4 & 7;
+  const mantissa = normalized & 15;
+  let sample = (mantissa << 3) + MULAW_BIAS << exponent;
+  sample -= MULAW_BIAS;
+  return sign ? -sample : sample;
+};
+var int16ArrayToBytes = (samples) => {
+  const output = new Uint8Array(samples.length * 2);
+  const view = new DataView(output.buffer);
+  for (let index = 0;index < samples.length; index += 1) {
+    view.setInt16(index * 2, samples[index] ?? 0, true);
+  }
+  return output;
+};
+var bytesToInt16Array = (bytes) => {
+  const sampleCount = Math.floor(bytes.byteLength / 2);
+  const output = new Int16Array(sampleCount);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let index = 0;index < sampleCount; index += 1) {
+    output[index] = view.getInt16(index * 2, true);
+  }
+  return output;
+};
+var decodeTwilioMulawBase64 = (payload) => {
+  const bytes = Uint8Array.from(Buffer2.from(payload, "base64"));
+  const samples = new Int16Array(bytes.length);
+  for (let index = 0;index < bytes.length; index += 1) {
+    samples[index] = decodeMulawSample(bytes[index] ?? 0);
+  }
+  return samples;
+};
+var encodeTwilioMulawBase64 = (samples) => {
+  const bytes = new Uint8Array(samples.length);
+  for (let index = 0;index < samples.length; index += 1) {
+    bytes[index] = encodeMulawSample(samples[index] ?? 0);
+  }
+  return Buffer2.from(bytes).toString("base64");
+};
+var transcodeTwilioInboundPayloadToPCM16 = (payload) => {
+  const narrowband = decodeTwilioMulawBase64(payload);
+  const wideband = linearResample(narrowband, TWILIO_MULAW_SAMPLE_RATE, VOICE_PCM_SAMPLE_RATE);
+  return int16ArrayToBytes(wideband);
+};
+var transcodePCMToTwilioOutboundPayload = (chunk, format) => {
+  if (format.container === "raw" && format.encoding === "mulaw" && format.channels === 1 && format.sampleRateHz === TWILIO_MULAW_SAMPLE_RATE) {
+    return Buffer2.from(chunk).toString("base64");
+  }
+  if (format.encoding !== "pcm_s16le") {
+    throw new Error(`Unsupported outbound telephony audio format: ${format.container}/${format.encoding}`);
+  }
+  const pcm = bytesToInt16Array(chunk);
+  const mono = format.channels === 1 ? pcm : new Int16Array(Array.from({ length: Math.floor(pcm.length / 2) }, (_, frameIndex) => {
+    const left = pcm[frameIndex * 2] ?? 0;
+    const right = pcm[frameIndex * 2 + 1] ?? 0;
+    return clamp16((left + right) / 2);
+  }));
+  const telephony = linearResample(mono, format.sampleRateHz, TWILIO_MULAW_SAMPLE_RATE);
+  return encodeTwilioMulawBase64(telephony);
+};
+var parseTwilioMessage = (raw) => {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  return JSON.parse(raw);
+};
+var createTwilioSocketAdapter = (socket, getState) => ({
+  close: async (code, reason) => {
+    await Promise.resolve(socket.close(code, reason));
+  },
+  send: async (data) => {
+    if (typeof data !== "string") {
+      return;
+    }
+    const state = getState();
+    const message = JSON.parse(data);
+    state.reviewRecorder?.recordVoiceMessage(message);
+    await Promise.resolve(state.onVoiceMessage?.({
+      callSid: state.callSid ?? undefined,
+      message,
+      sessionId: state.sessionId ?? "",
+      streamSid: state.streamSid ?? undefined
+    }));
+    if (!state.streamSid) {
+      return;
+    }
+    if (message.type === "audio") {
+      const payload = transcodePCMToTwilioOutboundPayload(Uint8Array.from(Buffer2.from(message.chunkBase64, "base64")), message.format);
+      state.hasOutboundAudioSinceLastInbound = true;
+      state.reviewRecorder?.recordTwilioOutbound({
+        bytes: payload.length,
+        event: "media",
+        track: "outbound"
+      });
+      await Promise.resolve(socket.send(JSON.stringify({
+        event: "media",
+        media: {
+          payload
+        },
+        streamSid: state.streamSid
+      })));
+      return;
+    }
+    if (message.type === "assistant" && message.turnId) {
+      state.reviewRecorder?.recordTwilioOutbound({
+        event: "mark",
+        name: `assistant:${message.turnId}`
+      });
+      await Promise.resolve(socket.send(JSON.stringify({
+        event: "mark",
+        mark: {
+          name: `assistant:${message.turnId}`
+        },
+        streamSid: state.streamSid
+      })));
+    }
+  }
+});
+var createTwilioVoiceResponse = (options) => {
+  const parameters = Object.entries(options.parameters ?? {}).filter((entry) => entry[1] !== undefined).map(([name, value]) => `<Parameter name="${escapeXml(name)}" value="${escapeXml(String(value))}" />`).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapeXml(options.streamUrl)}"${options.track ? ` track="${escapeXml(options.track)}"` : ""}${options.streamName ? ` name="${escapeXml(options.streamName)}"` : ""}>${parameters}</Stream></Connect></Response>`;
+};
+var createTwilioMediaStreamBridge = (socket, options) => {
+  const runtimePreset = resolveVoiceRuntimePreset(options.preset);
+  const turnDetection = resolveTurnDetectionConfig({
+    ...runtimePreset.turnDetection,
+    ...options.turnDetection
+  });
+  const audioConditioning = options.audioConditioning !== undefined ? resolveAudioConditioningConfig(options.audioConditioning) : runtimePreset.audioConditioning;
+  const logger = resolveLogger(options.logger);
+  const reconnect = {
+    maxAttempts: options.reconnect?.maxAttempts ?? 10,
+    strategy: options.reconnect?.strategy ?? "resume-last-turn",
+    timeout: options.reconnect?.timeout ?? 30000
+  };
+  const bridgeState = {
+    callSid: null,
+    hasOutboundAudioSinceLastInbound: false,
+    onVoiceMessage: options.onVoiceMessage,
+    reviewRecorder: options.review ? createVoiceCallReviewRecorder({
+      config: options.review.config ?? {
+        preset: options.preset,
+        stt: {
+          kind: options.stt.kind
+        },
+        tts: options.tts ? {
+          kind: options.tts.kind
+        } : undefined,
+        turnDetection
+      },
+      fixtureId: options.review.fixtureId,
+      path: options.review.path,
+      title: options.review.title
+    }) : undefined,
+    scenarioId: options.scenarioId ?? null,
+    sessionId: options.sessionId ?? null,
+    streamSid: null
+  };
+  let sessionHandle = null;
+  let reviewArtifactDelivered = false;
+  const resolveLexicon2 = async () => {
+    if (typeof options.lexicon === "function") {
+      return normalizeLexicon2(await options.lexicon({
+        context: options.context,
+        scenarioId: bridgeState.scenarioId ?? undefined,
+        sessionId: bridgeState.sessionId ?? ""
+      }) ?? []);
+    }
+    return normalizeLexicon2(options.lexicon);
+  };
+  const resolvePhraseHints2 = async () => {
+    if (typeof options.phraseHints === "function") {
+      return normalizePhraseHints2(await options.phraseHints({
+        context: options.context,
+        scenarioId: bridgeState.scenarioId ?? undefined,
+        sessionId: bridgeState.sessionId ?? ""
+      }) ?? []);
+    }
+    return normalizePhraseHints2(options.phraseHints);
+  };
+  const ensureSession = async () => {
+    if (sessionHandle) {
+      return sessionHandle;
+    }
+    bridgeState.sessionId ??= `phone-${Date.now().toString(36)}`;
+    const lexicon = await resolveLexicon2();
+    const phraseHints = await resolvePhraseHints2();
+    const normalizedOnTurn = normalizeOnTurn2(options.onTurn);
+    const route = {
+      correctTurn: options.correctTurn,
+      onComplete: options.onComplete,
+      onError: options.onError,
+      onSession: options.onSession,
+      onTurn: async (input) => {
+        bridgeState.reviewRecorder?.recordVoiceMessage({
+          type: "turn",
+          turn: input.turn
+        });
+        const result = await normalizedOnTurn(input);
+        if (result?.assistantText) {
+          bridgeState.reviewRecorder?.recordVoiceMessage({
+            type: "assistant",
+            text: result.assistantText,
+            turnId: input.turn.id
+          });
+        }
+        return result;
+      }
+    };
+    const voiceSocket = createTwilioSocketAdapter(socket, () => bridgeState);
+    sessionHandle = createVoiceSession({
+      audioConditioning,
+      context: options.context,
+      costTelemetry: options.costTelemetry,
+      id: bridgeState.sessionId,
+      languageStrategy: options.languageStrategy,
+      lexicon,
+      logger,
+      phraseHints,
+      reconnect,
+      route,
+      scenarioId: bridgeState.scenarioId ?? undefined,
+      socket: voiceSocket,
+      store: options.session,
+      stt: options.stt,
+      sttFallback: resolveSTTFallbackConfig2(options.sttFallback),
+      sttLifecycle: options.sttLifecycle ?? runtimePreset.sttLifecycle,
+      tts: options.tts,
+      turnDetection
+    });
+    return sessionHandle;
+  };
+  return {
+    close: async (reason) => {
+      await sessionHandle?.close(reason);
+      if (bridgeState.reviewRecorder && options.review?.onArtifact && !reviewArtifactDelivered) {
+        reviewArtifactDelivered = true;
+        await Promise.resolve(options.review.onArtifact(bridgeState.reviewRecorder.finalize()));
+      }
+    },
+    getSessionId: () => bridgeState.sessionId,
+    getStreamSid: () => bridgeState.streamSid,
+    handleMessage: async (raw) => {
+      const message = parseTwilioMessage(raw);
+      switch (message.event) {
+        case "connected":
+          bridgeState.reviewRecorder?.recordTwilioInbound({
+            event: "connected"
+          });
+          return;
+        case "start": {
+          bridgeState.streamSid = message.start.streamSid;
+          bridgeState.callSid = message.start.callSid ?? null;
+          bridgeState.sessionId = message.start.customParameters?.sessionId?.trim() || bridgeState.sessionId;
+          bridgeState.scenarioId = message.start.customParameters?.scenarioId?.trim() || bridgeState.scenarioId;
+          bridgeState.reviewRecorder?.recordTwilioInbound({
+            event: "start",
+            reason: message.start.callSid,
+            text: bridgeState.sessionId ?? undefined
+          });
+          await ensureSession();
+          return;
+        }
+        case "media": {
+          const activeSession = await ensureSession();
+          bridgeState.reviewRecorder?.recordTwilioInbound({
+            bytes: message.media.payload.length,
+            event: "media",
+            track: message.media.track
+          });
+          if (options.clearOnInboundMedia !== false && bridgeState.hasOutboundAudioSinceLastInbound && bridgeState.streamSid) {
+            bridgeState.reviewRecorder?.recordTwilioOutbound({
+              event: "clear"
+            });
+            await Promise.resolve(socket.send(JSON.stringify({
+              event: "clear",
+              streamSid: bridgeState.streamSid
+            })));
+          }
+          bridgeState.hasOutboundAudioSinceLastInbound = false;
+          await activeSession.receiveAudio(transcodeTwilioInboundPayloadToPCM16(message.media.payload));
+          return;
+        }
+        case "mark":
+          bridgeState.reviewRecorder?.recordTwilioInbound({
+            event: "mark",
+            name: message.mark?.name
+          });
+          return;
+        case "stop":
+          bridgeState.reviewRecorder?.recordTwilioInbound({
+            event: "stop",
+            reason: message.stop?.callSid
+          });
+          await sessionHandle?.close("twilio-stop");
+          return;
+      }
+    }
+  };
+};
+// src/telephony/response.ts
+var normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
+var DEFAULT_MAX_WORDS = 12;
+var CLAUSE_BOUNDARY_PATTERN = /(?<=[,.;!?])\s+/u;
+var clampWords = (text, maxWords) => {
+  if (!Number.isFinite(maxWords) || maxWords <= 0) {
+    return text;
+  }
+  const words = text.split(/\s+/u).filter(Boolean);
+  if (words.length <= maxWords) {
+    return text;
+  }
+  return words.slice(0, maxWords).join(" ");
+};
+var clampChars = (text, maxChars) => {
+  if (!Number.isFinite(maxChars) || !maxChars || maxChars <= 0) {
+    return text;
+  }
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return text.slice(0, maxChars).trim();
+};
+var ensureTerminalPunctuation = (text) => {
+  if (!text) {
+    return text;
+  }
+  return /[.!?]$/u.test(text) ? text : `${text}.`;
+};
+var extractLeadClause = (text) => {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return normalized;
+  }
+  const colonIndex = normalized.indexOf(":");
+  const body = colonIndex >= 0 && colonIndex < 24 && colonIndex < normalized.length - 1 ? normalizeWhitespace(normalized.slice(colonIndex + 1)) : normalized;
+  const clauses = body.split(CLAUSE_BOUNDARY_PATTERN).filter(Boolean);
+  return clauses[0] ?? body;
+};
+var shapeTelephonyAssistantText = (text, options = {}) => {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return normalized;
+  }
+  if ((options.mode ?? "lead-clause") === "full") {
+    return clampChars(normalized, options.maxChars);
+  }
+  const lead = extractLeadClause(normalized);
+  const limitedWords = clampWords(lead, options.maxWords ?? DEFAULT_MAX_WORDS);
+  const limitedChars = clampChars(limitedWords, options.maxChars);
+  return ensureTerminalPunctuation(normalizeWhitespace(limitedChars));
+};
 export {
+  withVoiceOpsTaskId,
+  withVoiceIntegrationEventId,
   voice,
+  transcodeTwilioInboundPayloadToPCM16,
+  transcodePCMToTwilioOutboundPayload,
+  summarizeVoiceOpsTasks,
+  startVoiceOpsTask,
+  shapeTelephonyAssistantText,
+  resolveVoiceSTTRoutingStrategy,
   resolveVoiceRuntimePreset,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
+  reopenVoiceOpsTask,
+  renderVoiceCallReviewMarkdown,
+  renderVoiceCallReviewHTML,
+  recordVoiceRuntimeOps,
+  listVoiceOpsTasks,
+  encodeTwilioMulawBase64,
+  decodeTwilioMulawBase64,
+  createVoiceTaskUpdatedEvent,
+  createVoiceTaskCreatedEvent,
   createVoiceSessionRecord,
   createVoiceSession,
+  createVoiceSTTRoutingCorrectionHandler,
+  createVoiceReviewSavedEvent,
   createVoiceMemoryStore,
+  createVoiceIntegrationEvent,
+  createVoiceFileTaskStore,
+  createVoiceFileSessionStore,
+  createVoiceFileRuntimeStorage,
+  createVoiceFileReviewStore,
+  createVoiceFileIntegrationEventStore,
+  createVoiceCallReviewRecorder,
+  createVoiceCallReviewFromSession,
+  createVoiceCallReviewFromLiveTelephonyReport,
+  createVoiceCallCompletedEvent,
+  createTwilioVoiceResponse,
+  createTwilioMediaStreamBridge,
+  createStoredVoiceOpsTask,
+  createStoredVoiceIntegrationEvent,
+  createStoredVoiceCallReviewArtifact,
+  createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
   createId,
+  createDomainPhraseHints,
+  createDomainLexicon,
   conditionAudioChunk,
+  completeVoiceOpsTask,
+  buildVoiceOpsTaskFromReview,
+  assignVoiceOpsTask,
+  applyRiskTieredPhraseHintCorrections,
   applyPhraseHintCorrections,
   TURN_PROFILE_DEFAULTS
 };