@absolutejs/voice 0.0.20 → 0.0.22-beta.0

package/dist/index.js

@@ -69,6 +69,61 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
+// src/audioConditioning.ts
+var DEFAULT_TARGET_LEVEL = 0.08;
+var DEFAULT_MAX_GAIN = 3;
+var DEFAULT_NOISE_GATE_THRESHOLD = 0.006;
+var DEFAULT_NOISE_GATE_ATTENUATION = 0.15;
+var toInt16Array = (audio) => {
+  if (audio instanceof ArrayBuffer) {
+    return new Int16Array(audio, 0, Math.floor(audio.byteLength / 2));
+  }
+  return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
+};
+var computeRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sumSquares = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sumSquares += normalized * normalized;
+  }
+  return Math.sqrt(sumSquares / samples.length);
+};
+var resolveAudioConditioningConfig = (config) => {
+  if (!config || config.enabled === false) {
+    return;
+  }
+  return {
+    enabled: true,
+    maxGain: config.maxGain ?? DEFAULT_MAX_GAIN,
+    noiseGateAttenuation: config.noiseGateAttenuation ?? DEFAULT_NOISE_GATE_ATTENUATION,
+    noiseGateThreshold: config.noiseGateThreshold ?? DEFAULT_NOISE_GATE_THRESHOLD,
+    targetLevel: config.targetLevel ?? DEFAULT_TARGET_LEVEL
+  };
+};
+var conditionAudioChunk = (audio, config) => {
+  if (!config) {
+    return audio;
+  }
+  const source = toInt16Array(audio);
+  if (source.length === 0) {
+    return audio;
+  }
+  const rms = computeRms(source);
+  const output = new Int16Array(source.length);
+  const gateFactor = rms < config.noiseGateThreshold ? config.noiseGateAttenuation : 1;
+  const baseLevel = Math.max(rms * gateFactor, 0.000001);
+  const gain = Math.min(config.maxGain, config.targetLevel / baseLevel);
+  const appliedGain = Math.max(0.25, gain) * gateFactor;
+  for (let index = 0;index < source.length; index += 1) {
+    const next = Math.round(source[index] * appliedGain);
+    output[index] = Math.max(-32768, Math.min(32767, next));
+  }
+  return new Uint8Array(output.buffer);
+};
+
 // src/plugin.ts
 import { Elysia } from "elysia";
 import { resolve } from "path";
@@ -118,6 +173,10 @@ var defaultMetrics = (input) => {
     '<span class="voice-metric-label">Session</span>',
     `<span class="voice-metric-value">${escapeHtml(input.sessionId)}</span>`,
     "</div>",
+    input.session?.scenarioId ? `<div class="voice-metric">
+				<span class="voice-metric-label">Scenario</span>
+				<span class="voice-metric-value">${escapeHtml(input.session.scenarioId)}</span>
+			</div>` : "",
     '<div class="voice-metric">',
     '<span class="voice-metric-label">Status</span>',
     `<span class="voice-metric-value">${escapeHtml(input.status)}</span>`,
@@ -207,24 +266,1224 @@ var resolveLogger = (logger) => ({
   ...logger
 });
 
+// src/turnProfiles.ts
+var TURN_PROFILE_DEFAULTS = {
+  balanced: {
+    qualityProfile: "general",
+    silenceMs: 1400,
+    speechThreshold: 0.012,
+    transcriptStabilityMs: 1000
+  },
+  fast: {
+    qualityProfile: "general",
+    silenceMs: 700,
+    speechThreshold: 0.015,
+    transcriptStabilityMs: 450
+  },
+  "long-form": {
+    qualityProfile: "general",
+    silenceMs: 2200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1500
+  }
+};
+var QUALITY_PROFILE_DEFAULTS = {
+  general: {},
+  "accent-heavy": {
+    silenceMs: 1200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1200
+  },
+  "noisy-room": {
+    silenceMs: 2000,
+    speechThreshold: 0.02,
+    transcriptStabilityMs: 1600
+  },
+  "short-command": {
+    silenceMs: 500,
+    speechThreshold: 0.016,
+    transcriptStabilityMs: 420
+  }
+};
+var DEFAULT_TURN_PROFILE = "fast";
+var DEFAULT_QUALITY_PROFILE = "general";
+var resolveTurnDetectionConfig = (config) => {
+  const profile = config?.profile ?? DEFAULT_TURN_PROFILE;
+  const qualityProfile = config?.qualityProfile ?? DEFAULT_QUALITY_PROFILE;
+  const preset = TURN_PROFILE_DEFAULTS[profile];
+  const quality = QUALITY_PROFILE_DEFAULTS[qualityProfile];
+  return {
+    profile,
+    qualityProfile,
+    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
+    speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
+    transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
+  };
+};
+
+// src/presets.ts
+var PRESET_INPUTS = {
+  chat: {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.5,
+      noiseGateAttenuation: 0,
+      noiseGateThreshold: 0.004,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 10,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "short-command",
+      profile: "balanced"
+    }
+  },
+  default: {
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 10,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "general",
+      profile: "fast"
+    }
+  },
+  dictation: {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.25,
+      noiseGateAttenuation: 0.05,
+      noiseGateThreshold: 0.003,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 12,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "accent-heavy",
+      profile: "long-form"
+    }
+  },
+  "guided-intake": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.5,
+      noiseGateAttenuation: 0,
+      noiseGateThreshold: 0.004,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 12,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "turn-scoped",
+    turnDetection: {
+      qualityProfile: "accent-heavy",
+      profile: "long-form"
+    }
+  },
+  "noisy-room": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 3,
+      noiseGateAttenuation: 0.12,
+      noiseGateThreshold: 0.006,
+      targetLevel: 0.085
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 2100,
+      speechThreshold: 0.02,
+      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,
+      maxGain: 2.9,
+      noiseGateAttenuation: 0.08,
+      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"
+    }
+  }
+};
+var resolveVoiceRuntimePreset = (name = "default") => {
+  const preset = PRESET_INPUTS[name];
+  return {
+    audioConditioning: resolveAudioConditioningConfig(preset.audioConditioning),
+    capture: {
+      channelCount: preset.capture?.channelCount ?? 1,
+      sampleRateHz: preset.capture?.sampleRateHz ?? 16000
+    },
+    connection: {
+      ...preset.connection
+    },
+    name,
+    sttLifecycle: preset.sttLifecycle ?? "continuous",
+    turnDetection: resolveTurnDetectionConfig(preset.turnDetection)
+  };
+};
+
+// 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) => ({
+var createVoiceSessionRecord = (id, scenarioId) => ({
   committedTurnIds: [],
   createdAt: Date.now(),
   currentTurn: {
     finalText: "",
+    lastSpeechAt: undefined,
+    lastTranscriptAt: undefined,
+    partialEndedAt: undefined,
+    partialStartedAt: undefined,
     partialText: "",
+    silenceStartedAt: undefined,
     transcripts: []
   },
   id,
+  scenarioId,
   reconnect: { attempts: 0 },
   status: "active",
   transcripts: [],
-  turns: []
+  turns: [],
+  lastCommittedTurn: {
+    committedAt: 0,
+    signature: "",
+    text: "",
+    transcriptIds: []
+  }
 });
-var resetVoiceSessionRecord = (id, existing) => ({
-  ...createVoiceSessionRecord(id),
+var resetVoiceSessionRecord = (id, existing, scenarioId) => ({
+  ...createVoiceSessionRecord(id, scenarioId),
   metadata: existing?.metadata
 });
 var toVoiceSessionSummary = (session) => ({
@@ -235,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;
@@ -261,6 +1523,64 @@ var measureAudioLevel = (audio) => {
   return Math.sqrt(sumSquares / samples.length);
 };
 var normalizeText = (value) => value.trim().replace(/\s+/g, " ");
+var countWords = (value) => value.length > 0 ? value.split(" ").length : 0;
+var selectPreferredTranscriptText = (currentText, nextText) => {
+  const current = normalizeText(currentText);
+  const next = normalizeText(nextText);
+  if (!current) {
+    return next;
+  }
+  if (!next) {
+    return current;
+  }
+  if (current === next || current.includes(next)) {
+    return current;
+  }
+  if (next.includes(current)) {
+    return next;
+  }
+  if (countWords(next) > countWords(current)) {
+    return next;
+  }
+  if (countWords(next) === countWords(current) && next.length > current.length) {
+    return next;
+  }
+  return current;
+};
+var mergeSequentialTranscriptText = (currentText, nextText) => {
+  const current = normalizeText(currentText);
+  const next = normalizeText(nextText);
+  if (!current) {
+    return next;
+  }
+  if (!next) {
+    return current;
+  }
+  const currentWords = current.split(" ");
+  const nextWords = next.split(" ");
+  const maxOverlap = Math.min(currentWords.length, nextWords.length);
+  for (let overlap = maxOverlap;overlap > 0; overlap -= 1) {
+    const currentSuffix = currentWords.slice(-overlap).join(" ");
+    const nextPrefix = nextWords.slice(0, overlap).join(" ");
+    if (currentSuffix === nextPrefix) {
+      return [...currentWords, ...nextWords.slice(overlap)].join(" ");
+    }
+  }
+  return `${current} ${next}`.trim();
+};
+var countCommonPrefixWords = (currentText, nextText) => {
+  const currentWords = normalizeText(currentText).split(" ").filter(Boolean);
+  const nextWords = normalizeText(nextText).split(" ").filter(Boolean);
+  const maxWords = Math.min(currentWords.length, nextWords.length);
+  let count = 0;
+  for (let index = 0;index < maxWords; index += 1) {
+    if (currentWords[index] !== nextWords[index]) {
+      break;
+    }
+    count += 1;
+  }
+  return count;
+};
 var mergeTranscriptTexts = (transcripts) => {
   const merged = [];
   for (const transcript of transcripts) {
@@ -284,31 +1604,195 @@ var mergeTranscriptTexts = (transcripts) => {
   }
   return merged.join(" ").trim();
 };
-var buildTurnText = (transcripts, partialText) => {
+var buildTurnText = (transcripts, partialText, options = {}) => {
   const finalText = mergeTranscriptTexts(transcripts);
-  if (finalText) {
-    return finalText;
+  const nextPartial = normalizeText(partialText);
+  const lastFinalEndedAtMs = [...transcripts].reverse().find((transcript) => typeof transcript.endedAtMs === "number")?.endedAtMs;
+  if (finalText && nextPartial && typeof lastFinalEndedAtMs === "number" && typeof options.partialStartedAtMs === "number" && options.partialStartedAtMs - lastFinalEndedAtMs >= 250 && countCommonPrefixWords(finalText, nextPartial) === 0) {
+    return mergeSequentialTranscriptText(finalText, nextPartial);
   }
-  return normalizeText(partialText);
+  return selectPreferredTranscriptText(finalText, nextPartial);
 };
 
 // src/session.ts
 var DEFAULT_RECONNECT_TIMEOUT = 30000;
 var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_TRANSCRIPT_STABILITY_MS = 450;
+var DEFAULT_FALLBACK_REPLAY_MS = 8000;
+var DEFAULT_FALLBACK_SETTLE_MS = 220;
+var DEFAULT_FALLBACK_COMPLETION_TIMEOUT_MS = 2500;
+var DEFAULT_FALLBACK_CONFIDENCE_THRESHOLD = 0.6;
+var DEFAULT_FALLBACK_MIN_TEXT_LENGTH = 2;
+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",
+  encoding: "pcm_s16le",
+  sampleRateHz: 16000
+};
 var toError = (value) => value instanceof Error ? value : new Error(String(value));
 var createEmptyCurrentTurn = () => ({
   finalText: "",
+  lastSpeechAt: undefined,
+  lastTranscriptAt: undefined,
+  partialEndedAt: undefined,
+  partialStartedAt: undefined,
   partialText: "",
+  silenceStartedAt: undefined,
   transcripts: []
 });
 var cloneTranscript = (transcript) => ({ ...transcript });
-var setTurnResult = (session, turnId, input) => {
-  session.turns = session.turns.map((turn) => turn.id === turnId ? {
-    ...turn,
+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;
+var getBufferedAudioDurationMs = (chunks) => chunks.reduce((total, chunk) => total + getAudioChunkDurationMs(chunk), 0);
+var calculateMeanConfidence = (transcripts) => {
+  let sum = 0;
+  let total = 0;
+  for (const transcript of transcripts) {
+    if (typeof transcript.confidence === "number") {
+      sum += transcript.confidence;
+      total += 1;
+    }
+  }
+  if (total === 0) {
+    return 0;
+  }
+  return sum / total;
+};
+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,
+    partialTranscriptCount: transcripts.filter((transcript) => !transcript.isFinal).length,
+    selectedTranscriptCount: transcripts.length,
+    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);
+  const wordCount = countWords2(trimmed);
+  if (config.trigger === "always") {
+    return true;
+  }
+  if (config.trigger === "empty-turn") {
+    return wordCount < config.minTextLength;
+  }
+  const averageConfidence = calculateMeanConfidence(candidate.transcripts);
+  if (config.trigger === "low-confidence") {
+    return averageConfidence > 0 && averageConfidence < config.confidenceThreshold;
+  }
+  return averageConfidence > 0 && averageConfidence < config.confidenceThreshold || wordCount < config.minTextLength;
+};
+var selectBetterTurnText = (candidate, fallback) => {
+  if (!fallback.text) {
+    return {
+      reason: "fallback-empty",
+      winner: candidate
+    };
+  }
+  if (!candidate.text) {
+    return {
+      reason: "primary-empty",
+      winner: fallback
+    };
+  }
+  const largestWordCount = Math.max(candidate.wordCount, fallback.wordCount, 1);
+  const wordCountDelta = fallback.wordCount - candidate.wordCount;
+  const wordCountDeltaRatio = Math.abs(wordCountDelta) / largestWordCount;
+  if (wordCountDeltaRatio >= FALLBACK_WORD_COUNT_SELECTION_MARGIN_RATIO && wordCountDelta !== 0) {
+    return {
+      reason: "word-count-margin",
+      winner: wordCountDelta > 0 ? fallback : candidate
+    };
+  }
+  if (fallback.confidence > candidate.confidence + FALLBACK_CONFIDENCE_SELECTION_DELTA) {
+    return {
+      reason: "confidence-margin",
+      winner: fallback
+    };
+  }
+  if (candidate.confidence > fallback.confidence + FALLBACK_CONFIDENCE_SELECTION_DELTA) {
+    return {
+      reason: "kept-primary",
+      winner: candidate
+    };
+  }
+  if (fallback.wordCount > candidate.wordCount) {
+    return {
+      reason: "word-count-tiebreak",
+      winner: fallback
+    };
+  }
+  return {
+    reason: "kept-primary",
+    winner: candidate
+  };
+};
+var setTurnResult = (session, turnId, input) => {
+  session.turns = session.turns.map((turn) => turn.id === turnId ? {
+    ...turn,
     assistantText: input.assistantText ?? turn.assistantText,
     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 = {
@@ -318,18 +1802,74 @@ var createVoiceSession = (options) => {
   };
   const turnDetection = {
     silenceMs: options.turnDetection.silenceMs ?? DEFAULT_SILENCE_MS,
-    speechThreshold: options.turnDetection.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD
+    speechThreshold: options.turnDetection.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD,
+    transcriptStabilityMs: options.turnDetection.transcriptStabilityMs ?? DEFAULT_TRANSCRIPT_STABILITY_MS
   };
+  const sttFallback = options.sttFallback ? {
+    adapter: options.sttFallback.adapter,
+    completionTimeoutMs: options.sttFallback.completionTimeoutMs ?? DEFAULT_FALLBACK_COMPLETION_TIMEOUT_MS,
+    confidenceThreshold: options.sttFallback.confidenceThreshold ?? DEFAULT_FALLBACK_CONFIDENCE_THRESHOLD,
+    maxAttemptsPerTurn: options.sttFallback.maxAttemptsPerTurn ?? DEFAULT_FALLBACK_MAX_ATTEMPTS_PER_TURN,
+    minTextLength: options.sttFallback.minTextLength ?? DEFAULT_FALLBACK_MIN_TEXT_LENGTH,
+    replayWindowMs: options.sttFallback.replayWindowMs ?? DEFAULT_FALLBACK_REPLAY_MS,
+    settleMs: options.sttFallback.settleMs ?? DEFAULT_FALLBACK_SETTLE_MS,
+    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;
+    let index = 0;
+    while (index < currentTurnAudio.length && currentTurnAudio[index].recordedAt < cutoffAt) {
+      index += 1;
+    }
+    if (index > 0) {
+      currentTurnAudio.splice(0, index);
+    }
+  };
+  const pushTurnAudio = (audio) => {
+    const chunk = audio instanceof ArrayBuffer ? new Uint8Array(audio.slice(0)) : new Uint8Array(audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength));
+    currentTurnAudio.push({
+      chunk,
+      recordedAt: Date.now()
+    });
+    pruneTurnAudio();
+  };
+  const getFallbackWindowAudio = () => {
+    if (!sttFallback?.adapter) {
+      return [];
+    }
+    pruneTurnAudio();
+    return currentTurnAudio.map((audio) => audio.chunk);
+  };
   const clearSilenceTimer = () => {
     if (!silenceTimer) {
       return;
     }
     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 {
@@ -349,12 +1889,28 @@ var createVoiceSession = (options) => {
     await options.store.set(options.id, session);
     return session;
   };
+  const runSerial = (phase, operation) => {
+    const result = operationQueue.then(async () => {
+      logger.debug("voice session operation", {
+        phase,
+        sessionId: options.id
+      });
+      return await operation();
+    });
+    operationQueue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
   const closeAdapter = async (reason) => {
     if (!sttSession) {
       return;
     }
     const activeSession = sttSession;
     sttSession = null;
+    activeAdapterGeneration = 0;
     try {
       await activeSession.close(reason);
     } catch (error) {
@@ -364,13 +1920,255 @@ var createVoiceSession = (options) => {
       });
     }
   };
-  const scheduleSilenceCommit = () => {
-    if (silenceTimer) {
+  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;
     }
+    if (reset) {
+      clearSilenceTimer();
+    }
+    pendingCommitReason = reason;
     silenceTimer = setTimeout(() => {
-      api.commitTurn("silence");
-    }, turnDetection.silenceMs);
+      silenceTimer = null;
+      pendingCommitReason = null;
+      api.commitTurn(reason);
+    }, delayMs);
+  };
+  const scheduleSilenceCommit = (delayMs = turnDetection.silenceMs, reset = true) => scheduleTurnCommit(delayMs, "silence", reset);
+  const requestTurnCommit = async (reason) => {
+    const session = await readSession();
+    const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    if (!text) {
+      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;
+    }
+    await commitTurnInternal(reason);
+  };
+  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"
+        });
+      }
+    });
+    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();
+    await options.route.onError?.({
+      api,
+      context: options.context,
+      error: resolvedError,
+      session,
+      sessionId: options.id
+    });
+    await options.route.onCallEnd?.({
+      api,
+      context: options.context,
+      disposition: "failed",
+      reason: resolvedError.message,
+      session
+    });
+  };
+  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" || currentSession.status === "failed") {
+        return;
+      }
+      didComplete = true;
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "completed";
+      if (result !== undefined && currentSession.turns.length > 0) {
+        const lastTurn = currentSession.turns.at(-1);
+        if (lastTurn) {
+          setTurnResult(currentSession, lastTurn.id, {
+            result
+          });
+        }
+      }
+      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();
+    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,
+      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) => {
     await send({
@@ -379,87 +2177,462 @@ var createVoiceSession = (options) => {
       type: "error"
     });
     if (!event.recoverable) {
-      await api.fail(event.error);
+      await failInternal(event.error);
     }
   };
   const handleClose = async (event) => {
     if (event.recoverable === false) {
-      await api.fail(new Error(event.reason ?? "Speech-to-text session closed"));
+      await failInternal(new Error(event.reason ?? "Speech-to-text session closed"));
+      return;
+    }
+    if (!event.reason) {
+      await closeAdapter("provider stream closed");
+      return;
+    }
+    await closeAdapter(event.reason);
+  };
+  const rewindFallbackTurnAudio = () => {
+    fallbackAttemptsForCurrentTurn = 0;
+    fallbackReplayAudioMsForCurrentTurn = 0;
+    currentTurnAudio.length = 0;
+  };
+  const runFallbackTranscription = async (primaryText, primaryTranscripts) => {
+    if (!sttFallback?.adapter || fallbackAttemptsForCurrentTurn >= sttFallback.maxAttemptsPerTurn) {
+      return null;
+    }
+    const candidate = {
+      text: primaryText,
+      transcripts: primaryTranscripts
+    };
+    if (!isFallbackNeeded(candidate, sttFallback)) {
+      return null;
+    }
+    fallbackAttemptsForCurrentTurn += 1;
+    const replayAudio = getFallbackWindowAudio();
+    if (replayAudio.length === 0) {
+      return null;
+    }
+    let fallbackSession = null;
+    const fallbackTranscripts = [];
+    let fallbackClosed = false;
+    let fallbackEndOfTurnReceived = false;
+    let fallbackFinalReceived = false;
+    let lastFallbackTranscriptAt = 0;
+    try {
+      fallbackSession = await sttFallback.adapter.open({
+        format: DEFAULT_FORMAT,
+        languageStrategy: options.languageStrategy,
+        lexicon,
+        phraseHints,
+        sessionId: `${options.id}:fallback:${fallbackAttemptsForCurrentTurn}`
+      });
+    } catch (error) {
+      logger.warn("voice stt fallback open failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+      return null;
+    }
+    const unsubscribers = [
+      fallbackSession.on("final", ({ transcript }) => {
+        fallbackFinalReceived = true;
+        lastFallbackTranscriptAt = Date.now();
+        fallbackTranscripts.push(cloneTranscript(transcript));
+      }),
+      fallbackSession.on("partial", ({ transcript }) => {
+        lastFallbackTranscriptAt = Date.now();
+        fallbackTranscripts.push(cloneTranscript(transcript));
+      }),
+      fallbackSession.on("endOfTurn", () => {
+        fallbackEndOfTurnReceived = true;
+      }),
+      fallbackSession.on("error", (event) => {
+        logger.warn("voice stt fallback error", {
+          error: toError(event.error).message,
+          sessionId: options.id
+        });
+      }),
+      fallbackSession.on("close", () => {
+        fallbackClosed = true;
+      })
+    ];
+    const closeFallback = async (reason) => {
+      if (!fallbackSession) {
+        return;
+      }
+      try {
+        await fallbackSession.close(reason);
+      } catch (error) {
+        logger.warn("voice stt fallback close failed", {
+          error: toError(error).message,
+          sessionId: options.id
+        });
+      } finally {
+        fallbackSession = null;
+      }
+    };
+    try {
+      for (const chunk of replayAudio) {
+        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) {
+        const idleMs = lastFallbackTranscriptAt > 0 ? Date.now() - lastFallbackTranscriptAt : Date.now() - waitStartedAt;
+        if (fallbackEndOfTurnReceived && idleMs >= sttFallback.settleMs) {
+          break;
+        }
+        if (fallbackFinalReceived && idleMs >= sttFallback.settleMs) {
+          break;
+        }
+        if (fallbackClosed && (lastFallbackTranscriptAt === 0 || idleMs >= sttFallback.settleMs)) {
+          break;
+        }
+        await Bun.sleep(Math.min(75, Math.max(25, sttFallback.settleMs / 2)));
+      }
+    } catch (error) {
+      logger.warn("voice stt fallback failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    } finally {
+      await closeFallback("fallback-complete");
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+      }
+    }
+    if (fallbackTranscripts.length === 0) {
+      return null;
+    }
+    const fallbackText = buildTurnText(fallbackTranscripts, "", {});
+    const fallbackConfidence = calculateMeanConfidence(fallbackTranscripts);
+    const fallbackCandidate = {
+      confidence: fallbackConfidence,
+      text: fallbackText,
+      wordCount: countWords2(normalizeText2(fallbackText))
+    };
+    const primaryCandidate = {
+      confidence: calculateMeanConfidence(primaryTranscripts),
+      text: primaryText,
+      wordCount: countWords2(normalizeText2(primaryText))
+    };
+    const selection = selectBetterTurnText(primaryCandidate, fallbackCandidate);
+    const diagnostics = {
+      attempted: true,
+      fallbackConfidence: fallbackCandidate.confidence,
+      fallbackText: fallbackCandidate.text,
+      fallbackWordCount: fallbackCandidate.wordCount,
+      primaryConfidence: primaryCandidate.confidence,
+      primaryText,
+      primaryWordCount: primaryCandidate.wordCount,
+      selected: selection.winner.text === fallbackCandidate.text,
+      selectionReason: selection.reason,
+      trigger: sttFallback.trigger
+    };
+    if (selection.winner.text === primaryCandidate.text) {
+      return {
+        diagnostics,
+        fallbackUsed: false,
+        source: "primary",
+        text: primaryText,
+        transcripts: primaryTranscripts.map((transcript) => ({
+          ...transcript,
+          isFinal: true
+        }))
+      };
+    }
+    const candidateTranscripts = fallbackText === fallbackCandidate.text ? fallbackTranscripts : [];
+    return {
+      diagnostics,
+      fallbackUsed: true,
+      source: "fallback",
+      text: selection.winner.text,
+      transcripts: candidateTranscripts.length > 0 ? candidateTranscripts.map((transcript) => ({
+        ...transcript,
+        isFinal: true
+      })) : [{ id: createId(), isFinal: false, text: selection.winner.text }]
+    };
+  };
+  const getFinalTranscriptIds = (transcripts) => {
+    const finalTranscriptIds = transcripts.filter((transcript) => transcript.isFinal).map((transcript) => transcript.id);
+    const fallbackIds = transcripts.map((transcript) => transcript.id);
+    return finalTranscriptIds.length > 0 ? finalTranscriptIds : fallbackIds;
+  };
+  const runTurnCorrection = async (input) => {
+    if (!options.route.correctTurn) {
+      return;
+    }
+    const originalText = input.text;
+    const result = await options.route.correctTurn({
+      api,
+      context: options.context,
+      fallback: input.fallbackDiagnostics,
+      lexicon,
+      phraseHints,
+      session: input.session,
+      text: originalText,
+      transcripts: input.transcripts.map(cloneTranscript)
+    });
+    const nextText = typeof result === "string" ? result : typeof result?.text === "string" ? result.text : originalText;
+    const correctedText = normalizeCorrectionText(nextText);
+    const normalizedOriginal = normalizeCorrectionText(originalText);
+    return {
+      diagnostics: {
+        attempted: true,
+        changed: correctedText.length > 0 && correctedText !== normalizedOriginal,
+        correctedText: correctedText.length > 0 ? correctedText : normalizedOriginal,
+        metadata: typeof result === "object" ? result.metadata : undefined,
+        originalText,
+        provider: typeof result === "object" ? result.provider : undefined,
+        reason: typeof result === "object" ? result.reason : undefined
+      },
+      text: correctedText.length > 0 ? correctedText : originalText
+    };
+  };
+  const ensureCommittedTurnGuard = (session) => {
+    if (!session.lastCommittedTurn) {
+      session.lastCommittedTurn = {
+        committedAt: 0,
+        signature: "",
+        text: "",
+        transcriptIds: []
+      };
+    }
+    return session;
+  };
+  const buildTurnSignature = (session, finalText, transcriptIdsOverride) => {
+    const finalTranscriptIds = transcriptIdsOverride ?? getFinalTranscriptIds(session.currentTurn.transcripts);
+    return `${normalizeText2(finalText)}|${finalTranscriptIds.join(",")}`;
+  };
+  const isDuplicateTurnCommit = (session, finalText) => {
+    const signature = buildTurnSignature(session, finalText);
+    const committedTurn = session.lastCommittedTurn;
+    const isRecent = committedTurn && committedTurn.committedAt > 0 && Date.now() - committedTurn.committedAt < DEFAULT_DUPLICATE_TURN_WINDOW_MS;
+    const committedSignature = committedTurn?.signature ?? "";
+    const committedTranscriptIds = committedTurn?.transcriptIds ?? [];
+    const committedText = normalizeText2(committedTurn?.text ?? "");
+    const isSameText = normalizeText2(finalText) === committedText;
+    const hasNoNewAudioSinceCommit = (session.currentTurn.lastAudioAt ?? 0) <= (committedTurn?.committedAt ?? 0);
+    if (!isRecent) {
+      return false;
+    }
+    if (isSameText && hasNoNewAudioSinceCommit) {
+      return true;
+    }
+    if (signature !== committedSignature) {
+      return false;
     }
+    const lastSignatureIds = new Set(committedTranscriptIds);
+    const hasNoNewFinalIds = session.currentTurn.transcripts.every((transcript) => !transcript.isFinal || lastSignatureIds.has(transcript.id));
+    return isRecent && hasNoNewFinalIds;
+  };
+  const markTurnCommitted = (session, finalText, committedTranscripts) => {
+    session.lastCommittedTurn = {
+      ...session.lastCommittedTurn ?? {},
+      committedAt: Date.now(),
+      signature: buildTurnSignature(session, finalText, getFinalTranscriptIds(committedTranscripts)),
+      text: normalizeText2(finalText),
+      transcriptIds: getFinalTranscriptIds(committedTranscripts)
+    };
   };
   const handlePartial = async (transcript) => {
-    await writeSession((session) => {
-      session.currentTurn.lastAudioAt = Date.now();
-      session.currentTurn.partialText = buildTurnText(session.currentTurn.transcripts, transcript.text);
-      session.lastActivityAt = Date.now();
-      session.status = "active";
+    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
+      });
+      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);
-      session.currentTurn.lastAudioAt = Date.now();
-      session.lastActivityAt = Date.now();
-      session.status = "active";
+      session2.currentTurn.finalText = buildTurnText(session2.currentTurn.transcripts, session2.currentTurn.partialText, {
+        partialEndedAtMs: session2.currentTurn.partialEndedAt,
+        partialStartedAtMs: session2.currentTurn.partialStartedAt
+      });
+      session2.currentTurn.lastTranscriptAt = Date.now();
+      session2.lastActivityAt = Date.now();
+      session2.status = "active";
     });
+    if (silenceTimer && pendingCommitReason === "vendor") {
+      scheduleTurnCommit(getVendorCommitDelayMs(), "vendor");
+    }
     await send({
       transcript,
       type: "final"
     });
   };
+  const resumePendingTurnCommit = (session) => {
+    const pendingText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    if (!pendingText) {
+      speechDetected = false;
+      return;
+    }
+    speechDetected = true;
+    const audioAge = session.currentTurn.silenceStartedAt !== undefined ? Date.now() - session.currentTurn.silenceStartedAt : session.currentTurn.lastSpeechAt !== undefined ? Date.now() - session.currentTurn.lastSpeechAt : 0;
+    const transcriptAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : turnDetection.transcriptStabilityMs;
+    const delayMs = Math.max(0, turnDetection.silenceMs - audioAge, turnDetection.transcriptStabilityMs - transcriptAge);
+    scheduleSilenceCommit(delayMs);
+  };
   const ensureAdapter = async () => {
     if (sttSession) {
       return sttSession;
     }
-    sttSession = await options.stt.open({
-      format: {
-        channels: 1,
-        container: "raw",
-        encoding: "pcm_s16le",
-        sampleRateHz: 16000
-      },
+    const openedSession = await options.stt.open({
+      format: DEFAULT_FORMAT,
+      languageStrategy: options.languageStrategy,
+      lexicon,
+      phraseHints,
       sessionId: options.id
     });
-    sttSession.on("partial", ({ transcript }) => {
-      handlePartial(transcript);
+    const generation = ++adapterGenerationCounter;
+    sttSession = openedSession;
+    activeAdapterGeneration = generation;
+    const runAdapterEvent = (phase, handler) => {
+      runSerial(phase, async () => {
+        if (activeAdapterGeneration !== generation) {
+          return;
+        }
+        await handler();
+      });
+    };
+    openedSession.on("partial", ({ transcript }) => {
+      runAdapterEvent("adapter.partial", () => handlePartial(transcript));
     });
-    sttSession.on("final", ({ transcript }) => {
-      handleFinal(transcript);
+    openedSession.on("final", ({ transcript }) => {
+      runAdapterEvent("adapter.final", () => handleFinal(transcript));
     });
-    sttSession.on("endOfTurn", ({ reason }) => {
-      clearSilenceTimer();
-      api.commitTurn(reason);
+    openedSession.on("endOfTurn", ({ reason }) => {
+      runAdapterEvent("adapter.endOfTurn", async () => {
+        clearSilenceTimer();
+        await requestTurnCommit(reason);
+      });
+    });
+    openedSession.on("error", (event) => {
+      runAdapterEvent("adapter.error", () => handleError(event));
     });
-    sttSession.on("error", (event) => {
-      handleError(event);
+    openedSession.on("close", (event) => {
+      runAdapterEvent("adapter.close", () => handleClose(event));
+    });
+    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;
     });
-    sttSession.on("close", (event) => {
-      handleClose(event);
+    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
+      });
     });
-    return sttSession;
   };
   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, {
@@ -471,7 +2644,20 @@ 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) => {
         setTurnResult(currentSession, turn.id, {
@@ -479,208 +2665,358 @@ 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 api.complete(output.result);
+      await completeInternal(output.result);
     }
   };
-  const api = {
-    id: options.id,
-    close: async (reason) => {
-      clearSilenceTimer();
-      await closeAdapter(reason);
-      await Promise.resolve(socket.close(1000, reason));
-    },
-    commitTurn: async (reason = "manual") => {
-      clearSilenceTimer();
-      const session = await readSession();
-      if (session.status === "completed" || session.status === "failed") {
-        return;
-      }
-      const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText);
-      if (!text) {
-        return;
+  const commitTurnInternal = async (reason = "manual") => {
+    clearSilenceTimer();
+    const session = await readSession();
+    if (session.status === "completed" || session.status === "failed") {
+      return;
+    }
+    const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    let transcripts = session.currentTurn.transcripts.length ? session.currentTurn.transcripts.map(cloneTranscript) : [];
+    let finalText = text;
+    const transcriptStabilityAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : undefined;
+    const fallbackSelection = await runFallbackTranscription(text, session.currentTurn.transcripts);
+    const source = fallbackSelection?.source ?? "primary";
+    const fallbackUsed = fallbackSelection?.fallbackUsed ?? false;
+    const fallbackDiagnostics = fallbackSelection?.diagnostics;
+    if (fallbackSelection) {
+      finalText = fallbackSelection.text;
+      transcripts = fallbackSelection.transcripts.length ? fallbackSelection.transcripts.map(cloneTranscript) : transcripts.length ? transcripts : [
+        {
+          id: createId(),
+          isFinal: false,
+          text: finalText
+        }
+      ];
+      if (fallbackSelection.fallbackUsed) {
+        logger.info("voice fallback turn selected", {
+          reason,
+          sessionId: options.id,
+          text: finalText
+        });
       }
-      const turn = {
-        committedAt: Date.now(),
-        id: createId(),
-        text,
-        transcripts: session.currentTurn.transcripts.length > 0 ? session.currentTurn.transcripts.map(cloneTranscript) : [
-          {
-            id: createId(),
-            isFinal: false,
-            text
-          }
-        ]
-      };
-      const updatedSession = await writeSession((currentSession) => {
-        currentSession.committedTurnIds = [
-          ...currentSession.committedTurnIds,
-          turn.id
-        ];
-        currentSession.currentTurn = createEmptyCurrentTurn();
-        currentSession.lastActivityAt = Date.now();
-        currentSession.status = "active";
-        currentSession.turns = [...currentSession.turns, turn];
-      });
-      speechDetected = false;
-      logger.info("voice turn committed", {
+    }
+    const correctionSelection = await runTurnCorrection({
+      fallbackDiagnostics,
+      fallbackUsed,
+      session,
+      source,
+      text: finalText,
+      transcripts
+    });
+    const correctionDiagnostics = correctionSelection?.diagnostics;
+    if (correctionSelection) {
+      finalText = correctionSelection.text;
+    }
+    if (!finalText) {
+      return;
+    }
+    if (isDuplicateTurnCommit(session, finalText)) {
+      logger.debug("voice turn commit deduped", {
         reason,
-        sessionId: options.id,
-        turnId: turn.id
-      });
-      await send({
-        turn,
-        type: "turn"
+        sessionId: options.id
       });
-      await completeTurn(updatedSession, turn);
-    },
-    complete: async (result) => {
-      clearSilenceTimer();
-      const session = await writeSession((currentSession) => {
-        if (currentSession.status === "completed") {
-          return;
-        }
-        currentSession.lastActivityAt = Date.now();
-        currentSession.status = "completed";
-        if (result !== undefined && currentSession.turns.length > 0) {
-          const lastTurn = currentSession.turns.at(-1);
-          if (lastTurn) {
-            setTurnResult(currentSession, lastTurn.id, {
-              result
-            });
-          }
+      return;
+    }
+    if (typeof transcriptStabilityAge === "number" && transcriptStabilityAge < turnDetection.transcriptStabilityMs && reason !== "manual") {
+      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, costEstimate),
+      transcripts: transcripts.length > 0 ? transcripts : [
+        {
+          id: createId(),
+          isFinal: false,
+          text: finalText
         }
+      ]
+    };
+    const updatedSession = await writeSession((currentSession) => {
+      currentSession.committedTurnIds = [
+        ...currentSession.committedTurnIds,
+        turn.id
+      ];
+      currentSession.currentTurn = createEmptyCurrentTurn();
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "active";
+      currentSession.turns = [...currentSession.turns, turn];
+      markTurnCommitted(currentSession, finalText, transcripts);
+    });
+    speechDetected = false;
+    rewindFallbackTurnAudio();
+    logger.info("voice turn committed", {
+      reason,
+      sessionId: options.id,
+      turnId: turn.id
+    });
+    await options.costTelemetry?.onTurnCost?.({
+      api,
+      context: options.context,
+      estimate: costEstimate,
+      session: updatedSession,
+      turn
+    });
+    await send({
+      turn,
+      type: "turn"
+    });
+    if (options.sttLifecycle === "turn-scoped") {
+      await closeAdapter("turn-commit");
+    }
+    await completeTurn(updatedSession, turn);
+  };
+  const connectInternal = async (nextSocket) => {
+    socket = nextSocket;
+    const existingSession = await options.store.get(options.id);
+    let session = existingSession ?? createVoiceSessionRecord(options.id, options.scenarioId);
+    if (options.scenarioId && session.scenarioId !== options.scenarioId) {
+      session.scenarioId = options.scenarioId;
+    }
+    ensureCommittedTurnGuard(session);
+    let shouldFireOnSession = !existingSession;
+    if (existingSession?.scenarioId && options.scenarioId && existingSession.scenarioId !== options.scenarioId) {
+      session = resetVoiceSessionRecord(options.id, existingSession, options.scenarioId);
+      shouldFireOnSession = true;
+    }
+    rewindFallbackTurnAudio();
+    if (existingSession?.status === "reconnecting") {
+      const nextAttempts = existingSession.reconnect.attempts + 1;
+      const reconnectExpired = existingSession.reconnect.lastDisconnectAt !== undefined && Date.now() - existingSession.reconnect.lastDisconnectAt > reconnect.timeout;
+      const tooManyAttempts = nextAttempts > reconnect.maxAttempts;
+      if (reconnect.strategy === "fail" && (reconnectExpired || tooManyAttempts)) {
+        await failInternal(new Error("Voice session reconnect policy exhausted"));
+        return;
+      }
+      if (reconnect.strategy === "restart" && (reconnectExpired || tooManyAttempts)) {
+        session = resetVoiceSessionRecord(options.id, existingSession, options.scenarioId);
+        shouldFireOnSession = true;
+      } else {
+        session = {
+          ...existingSession,
+          reconnect: {
+            ...existingSession.reconnect,
+            attempts: nextAttempts
+          },
+          status: "active"
+        };
+      }
+    }
+    if (shouldFireOnSession) {
+      pushCallLifecycleEvent(session, {
+        type: "start"
       });
-      await send({
-        sessionId: options.id,
-        type: "complete"
+    }
+    await options.store.set(options.id, session);
+    await send({
+      sessionId: options.id,
+      status: session.status,
+      scenarioId: session.scenarioId,
+      type: "session"
+    });
+    if (shouldFireOnSession) {
+      await options.route.onCallStart?.({
+        api,
+        context: options.context,
+        session
       });
-      await closeAdapter("complete");
-      speechDetected = false;
-      await options.route.onComplete({
+      await options.route.onSession?.({
         api,
         context: options.context,
         session
       });
-    },
-    connect: async (nextSocket) => {
-      socket = nextSocket;
-      const existingSession = await options.store.get(options.id);
-      let session = existingSession ?? createVoiceSessionRecord(options.id);
-      let shouldFireOnSession = !existingSession;
-      if (existingSession?.status === "reconnecting") {
-        const nextAttempts = existingSession.reconnect.attempts + 1;
-        const reconnectExpired = existingSession.reconnect.lastDisconnectAt !== undefined && Date.now() - existingSession.reconnect.lastDisconnectAt > reconnect.timeout;
-        const tooManyAttempts = nextAttempts > reconnect.maxAttempts;
-        if (reconnect.strategy === "fail" && (reconnectExpired || tooManyAttempts)) {
-          await api.fail(new Error("Voice session reconnect policy exhausted"));
-          return;
-        }
-        if (reconnect.strategy === "restart" && (reconnectExpired || tooManyAttempts)) {
-          session = resetVoiceSessionRecord(options.id, existingSession);
-          shouldFireOnSession = true;
-        } else {
-          session = {
-            ...existingSession,
-            reconnect: {
-              ...existingSession.reconnect,
-              attempts: nextAttempts
-            },
-            status: "active"
-          };
-        }
-      }
-      await options.store.set(options.id, session);
+    }
+    if (session.status === "completed") {
       await send({
         sessionId: options.id,
-        status: session.status,
-        type: "session"
-      });
-      if (shouldFireOnSession) {
-        await options.route.onSession?.({
-          api,
-          context: options.context,
-          session
-        });
-      }
-      if (session.status === "completed") {
-        await send({
-          sessionId: options.id,
-          type: "complete"
-        });
-        return;
-      }
-      await ensureAdapter();
-    },
-    disconnect: async (event) => {
-      clearSilenceTimer();
-      await closeAdapter(event?.reason);
-      if (reconnect.strategy === "fail") {
-        await api.fail(new Error(event?.reason ?? "Voice socket disconnected"));
-        return;
-      }
-      await writeSession((session) => {
-        if (session.status === "completed" || session.status === "failed") {
-          return;
-        }
-        session.lastActivityAt = Date.now();
-        session.reconnect.lastDisconnectAt = Date.now();
-        session.status = "reconnecting";
-      });
-      speechDetected = false;
-    },
-    fail: async (error) => {
-      clearSilenceTimer();
-      const session = await writeSession((currentSession) => {
-        currentSession.lastActivityAt = Date.now();
-        currentSession.status = "failed";
-      });
-      const resolvedError = toError(error);
-      await send({
-        message: resolvedError.message,
-        recoverable: false,
-        type: "error"
-      });
-      await closeAdapter("failed");
-      speechDetected = false;
-      await options.route.onError?.({
-        api,
-        context: options.context,
-        error: resolvedError,
-        session,
-        sessionId: options.id
+        type: "complete"
       });
-    },
-    receiveAudio: async (audio) => {
-      const session = await readSession();
+      return;
+    }
+    resumePendingTurnCommit(session);
+    await ensureAdapter();
+    warmTTSSession();
+  };
+  const disconnectInternal = async (event) => {
+    clearSilenceTimer();
+    await closeTTSSession(event?.reason);
+    await closeAdapter(event?.reason);
+    rewindFallbackTurnAudio();
+    if (reconnect.strategy === "fail") {
+      await failInternal(new Error(event?.reason ?? "Voice socket disconnected"));
+      return;
+    }
+    await writeSession((session) => {
       if (session.status === "completed" || session.status === "failed") {
         return;
       }
-      const adapter = await ensureAdapter();
-      const audioLevel = measureAudioLevel(audio);
-      await writeSession((currentSession) => {
-        currentSession.currentTurn.lastAudioAt = Date.now();
-        currentSession.lastActivityAt = Date.now();
-        currentSession.status = "active";
-      });
+      session.lastActivityAt = Date.now();
+      session.reconnect.lastDisconnectAt = Date.now();
+      session.status = "reconnecting";
+    });
+    speechDetected = false;
+  };
+  const receiveAudioInternal = async (audio) => {
+    const session = await readSession();
+    if (session.status === "completed" || session.status === "failed") {
+      return;
+    }
+    const adapter = await ensureAdapter();
+    const conditionedAudio = conditionAudioChunk(audio, options.audioConditioning);
+    const audioLevel = measureAudioLevel(conditionedAudio);
+    const shouldStoreAudio = speechDetected || audioLevel >= turnDetection.speechThreshold;
+    await writeSession((currentSession) => {
+      currentSession.currentTurn.lastAudioAt = Date.now();
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "active";
       if (audioLevel >= turnDetection.speechThreshold) {
-        speechDetected = true;
+        currentSession.currentTurn.lastSpeechAt = Date.now();
+        currentSession.currentTurn.silenceStartedAt = undefined;
+      } else if (speechDetected && currentSession.currentTurn.silenceStartedAt === undefined) {
+        currentSession.currentTurn.silenceStartedAt = Date.now();
+      }
+    });
+    if (shouldStoreAudio) {
+      pushTurnAudio(conditionedAudio);
+    }
+    if (audioLevel >= turnDetection.speechThreshold) {
+      speechDetected = true;
+      clearSilenceTimer();
+    } else if (speechDetected) {
+      const currentSession = await readSession();
+      const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText, {
+        partialEndedAtMs: currentSession.currentTurn.partialEndedAt,
+        partialStartedAtMs: currentSession.currentTurn.partialStartedAt
+      }));
+      if (hasTurnText) {
+        scheduleSilenceCommit(turnDetection.silenceMs, false);
+      }
+    }
+    await adapter.send(conditionedAudio);
+  };
+  const api = {
+    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();
-      } else if (speechDetected) {
-        const currentSession = await readSession();
-        const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText));
-        if (hasTurnText) {
-          scheduleSilenceCommit();
+        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
+          });
         }
-      }
-      await adapter.send(audio);
+      });
     },
-    snapshot: async () => readSession()
+    commitTurn: async (reason = "manual") => runSerial("api.commitTurn", async () => {
+      await commitTurnInternal(reason);
+    }),
+    complete: async (result) => runSerial("api.complete", async () => {
+      await completeInternal(result);
+    }),
+    connect: async (nextSocket) => runSerial("api.connect", async () => {
+      await connectInternal(nextSocket);
+    }),
+    disconnect: async (event) => runSerial("api.disconnect", async () => {
+      await disconnectInternal(event);
+    }),
+    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;
 };
 
 // src/plugin.ts
+var resolveQueryScenario = (query) => {
+  if (typeof query?.scenarioId === "string" && query.scenarioId.trim()) {
+    return query.scenarioId.trim();
+  }
+  if (typeof query?.mode === "string" && query.mode.trim()) {
+    return query.mode.trim();
+  }
+  return null;
+};
 var HTMX_BOOTSTRAP_DIST_CANDIDATES = [
   resolve(import.meta.dir, "client", "htmxBootstrap.js"),
   resolve(import.meta.dir, "..", "dist", "client", "htmxBootstrap.js")
@@ -727,6 +3063,21 @@ ${log}` : ""}`);
   };
 })();
 var isArrayBufferView = (value) => typeof value === "object" && value !== null && ArrayBuffer.isView(value);
+var resolveSTTFallbackConfig = (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 isVoiceClientMessage = (value) => {
   if (!value || typeof value !== "object" || !("type" in value)) {
     return false;
@@ -739,7 +3090,7 @@ var isVoiceClientMessage = (value) => {
     case "ping":
       return true;
     case "start":
-      return !("sessionId" in value) || typeof value.sessionId === "string";
+      return (!("sessionId" in value) || typeof value.sessionId === "string") && (!("scenarioId" in value) || typeof value.scenarioId === "string");
     default:
       return false;
   }
@@ -759,14 +3110,16 @@ var parseClientMessage = (raw) => {
   return null;
 };
 var resolveSessionId = (runtime, ws) => {
-  const existing = runtime.socketSessions.get(ws);
-  if (existing) {
-    return existing;
-  }
   const query = ws.data && typeof ws.data === "object" && "query" in ws.data ? ws.data.query : undefined;
-  const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : createId();
-  runtime.socketSessions.set(ws, providedSessionId);
-  return providedSessionId;
+  const existing = runtime.socketSessions.get(ws);
+  const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : existing?.sessionId ?? createId();
+  const scenarioId = resolveQueryScenario(query) ?? existing?.scenarioId ?? null;
+  const resolved = {
+    sessionId: providedSessionId,
+    scenarioId
+  };
+  runtime.socketSessions.set(ws, resolved);
+  return resolved;
 };
 var toAudioChunk = (raw) => {
   if (raw instanceof ArrayBuffer) {
@@ -792,6 +3145,55 @@ var normalizeOnTurn = (handler) => {
   }
   return handler;
 };
+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: {
+      maxAttempts: config.reconnect?.maxAttempts ?? 10,
+      strategy: config.reconnect?.strategy ?? "resume-last-turn",
+      timeout: config.reconnect?.timeout ?? 30000
+    },
+    sttLifecycle: config.sttLifecycle ?? preset.sttLifecycle,
+    turnDetection: resolveTurnDetectionConfig({
+      ...preset.turnDetection,
+      ...config.turnDetection
+    })
+  };
+};
+var normalizePhraseHints = (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 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 [];
+  }
+  if (typeof config.phraseHints === "function") {
+    return normalizePhraseHints(await config.phraseHints(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,
@@ -799,11 +3201,79 @@ var voice = (config) => {
     socketSessions: new WeakMap
   };
   const onTurn = normalizeOnTurn(config.onTurn);
+  const sessionOptions = resolveSessionOptions(config);
   const htmxOptions = config.htmx && typeof config.htmx === "object" ? config.htmx : undefined;
   const htmxRoute = htmxOptions?.route ?? `${config.path}/htmx/session`;
   const htmxBootstrapRoute = htmxOptions?.bootstrapRoute ?? `${config.path}/htmx/bootstrap.js`;
   const htmxRenderers = resolveVoiceHTMXRenderers(config.htmx && config.htmx !== true ? config.htmx : undefined);
   const htmxTargets = resolveVoiceHTMXTargets(htmxOptions?.targets);
+  const createManagedSession = async (ws, sessionId, scenarioId) => {
+    const context = ws.data;
+    const phraseHints = await resolvePhraseHints(config, {
+      context,
+      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,
+        onTransfer: config.onTransfer,
+        onTurn,
+        onVoicemail: config.onVoicemail
+      },
+      scenarioId,
+      socket: createSocketAdapter(ws),
+      store: config.session,
+      stt: config.stt,
+      sttFallback: sessionOptions.sttFallback,
+      sttLifecycle: sessionOptions.sttLifecycle,
+      tts: config.tts,
+      turnDetection: sessionOptions.turnDetection
+    });
+  };
   const htmxRoutes = () => {
     if (!config.htmx) {
       return new Elysia;
@@ -833,12 +3303,12 @@ var voice = (config) => {
   };
   return new Elysia({ name: "absolutejs-voice" }).ws(config.path, {
     close: async (ws, code, reason) => {
-      const sessionId = runtime.socketSessions.get(ws);
-      if (!sessionId) {
+      const socketState = runtime.socketSessions.get(ws);
+      if (!socketState) {
         return;
       }
-      const session = runtime.activeSessions.get(sessionId);
-      runtime.activeSessions.delete(sessionId);
+      const session = runtime.activeSessions.get(socketState.sessionId);
+      runtime.activeSessions.delete(socketState.sessionId);
       if (session) {
         await session.disconnect({
           code,
@@ -849,8 +3319,8 @@ var voice = (config) => {
       }
     },
     message: async (ws, raw) => {
-      const sessionId = resolveSessionId(runtime, ws);
-      const current = runtime.activeSessions.get(sessionId);
+      const sessionState = resolveSessionId(runtime, ws);
+      const current = runtime.activeSessions.get(sessionState.sessionId);
       const message = parseClientMessage(raw);
       if (message) {
         if (message.type === "ping") {
@@ -861,10 +3331,27 @@ var voice = (config) => {
         }
         if (message.type === "close" && current) {
           await current.close(message.reason);
-          runtime.activeSessions.delete(sessionId);
+          runtime.activeSessions.delete(sessionState.sessionId);
         }
-        if (message.type === "start" && message.sessionId && message.sessionId !== sessionId) {
-          runtime.socketSessions.set(ws, message.sessionId);
+        if (message.type === "start" && message.sessionId && message.sessionId !== sessionState.sessionId) {
+          const currentSession = runtime.activeSessions.get(sessionState.sessionId);
+          if (currentSession) {
+            await currentSession.close("session-switch");
+            runtime.activeSessions.delete(sessionState.sessionId);
+          }
+          sessionState.sessionId = message.sessionId;
+          runtime.socketSessions.set(ws, {
+            ...sessionState,
+            sessionId: message.sessionId,
+            scenarioId: sessionState.scenarioId
+          });
+        }
+        if (message.type === "start" && message.scenarioId) {
+          sessionState.scenarioId = message.scenarioId;
+          runtime.socketSessions.set(ws, {
+            ...sessionState,
+            scenarioId: message.scenarioId
+          });
         }
         return;
       }
@@ -872,70 +3359,191 @@ var voice = (config) => {
       if (!audio) {
         return;
       }
-      const session = current ?? createVoiceSession({
-        context: ws.data,
-        id: sessionId,
-        logger: config.logger,
-        reconnect: {
-          maxAttempts: config.reconnect?.maxAttempts ?? 10,
-          strategy: config.reconnect?.strategy ?? "resume-last-turn",
-          timeout: config.reconnect?.timeout ?? 30000
-        },
-        route: {
-          onComplete: config.onComplete,
-          onError: config.onError,
-          onSession: config.onSession,
-          onTurn
-        },
-        socket: createSocketAdapter(ws),
-        store: config.session,
-        stt: config.stt,
-        turnDetection: {
-          silenceMs: config.turnDetection?.silenceMs ?? 700,
-          speechThreshold: config.turnDetection?.speechThreshold ?? 0.015
-        }
-      });
+      const session = current ?? await createManagedSession(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined);
       if (!current) {
-        runtime.activeSessions.set(sessionId, session);
+        runtime.activeSessions.set(sessionState.sessionId, session);
         await session.connect(createSocketAdapter(ws));
       }
       await session.receiveAudio(audio);
     },
     open: async (ws) => {
-      const sessionId = resolveSessionId(runtime, ws);
-      const existing = runtime.activeSessions.get(sessionId);
+      const sessionState = resolveSessionId(runtime, ws);
+      const existing = runtime.activeSessions.get(sessionState.sessionId);
       if (existing) {
         await existing.close("superseded");
-        runtime.activeSessions.delete(sessionId);
-      }
-      const session = createVoiceSession({
-        context: ws.data,
-        id: sessionId,
-        logger: config.logger,
-        reconnect: {
-          maxAttempts: config.reconnect?.maxAttempts ?? 10,
-          strategy: config.reconnect?.strategy ?? "resume-last-turn",
-          timeout: config.reconnect?.timeout ?? 30000
-        },
-        route: {
-          onComplete: config.onComplete,
-          onError: config.onError,
-          onSession: config.onSession,
-          onTurn
-        },
-        socket: createSocketAdapter(ws),
-        store: config.session,
-        stt: config.stt,
-        turnDetection: {
-          silenceMs: config.turnDetection?.silenceMs ?? 700,
-          speechThreshold: config.turnDetection?.speechThreshold ?? 0.015
-        }
-      });
-      runtime.activeSessions.set(sessionId, session);
+        runtime.activeSessions.delete(sessionState.sessionId);
+      }
+      const session = await createManagedSession(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined);
+      runtime.activeSessions.set(sessionState.sessionId, session);
       await session.connect(createSocketAdapter(ws));
     }
   }).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;
@@ -957,10 +3565,825 @@ var createVoiceMemoryStore = () => {
   };
   return { get, getOrCreate, list, remove, set };
 };
+// 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 = buildAliasMatcher(alias);
+      if (!matcher.test(corrected)) {
+        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 {
+    changed: corrected !== text,
+    matches,
+    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";
+  return async ({ phraseHints, text }) => {
+    const result = applyPhraseHintCorrections(text, phraseHints);
+    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 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,
-  createId
+  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
 };