@absolutejs/voice 0.0.22-beta.6 → 0.0.22-beta.60

package/dist/index.js

@@ -2992,6 +2992,289 @@ var toVoiceSessionSummary = (session) => ({
 // src/session.ts
 import { Buffer } from "buffer";
 
+// src/handoff.ts
+var toHex3 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signHandoffBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  return `sha256=${toHex3(new Uint8Array(signature))}`;
+};
+var toErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var createSkippedDelivery = (adapter) => ({
+  adapterId: adapter.id,
+  adapterKind: adapter.kind,
+  status: "skipped"
+});
+var aggregateHandoffStatus = (deliveries) => {
+  const statuses = Object.values(deliveries).map((delivery) => delivery.status);
+  if (statuses.some((status) => status === "failed")) {
+    return "failed";
+  }
+  if (statuses.some((status) => status === "delivered")) {
+    return "delivered";
+  }
+  return "skipped";
+};
+var createHandoffDeliveryId = (input) => [
+  "voice-handoff",
+  input.sessionId,
+  input.action,
+  Date.now(),
+  crypto.randomUUID()
+].join(":");
+var resolveHandoffDeliveryError = (deliveries) => Object.values(deliveries).map((delivery) => delivery.error).find(Boolean);
+var defaultWebhookBody = (input) => ({
+  action: input.action,
+  metadata: input.metadata,
+  reason: input.reason,
+  result: input.result,
+  session: {
+    id: input.session.id,
+    scenarioId: input.session.scenarioId,
+    status: input.session.status
+  },
+  source: "absolutejs-voice",
+  target: input.target
+});
+var deliverVoiceHandoff = async (input) => {
+  if (!input.config || input.config.adapters.length === 0) {
+    return;
+  }
+  const deliveries = {};
+  for (const adapter of input.config.adapters) {
+    if (adapter.actions && !adapter.actions.includes(input.handoff.action)) {
+      deliveries[adapter.id] = createSkippedDelivery(adapter);
+      continue;
+    }
+    try {
+      const result = await adapter.handoff(input.handoff);
+      deliveries[adapter.id] = {
+        ...result,
+        adapterId: adapter.id,
+        adapterKind: adapter.kind
+      };
+    } catch (error) {
+      deliveries[adapter.id] = {
+        adapterId: adapter.id,
+        adapterKind: adapter.kind,
+        error: toErrorMessage2(error),
+        status: "failed"
+      };
+      if (input.config.failMode === "throw") {
+        throw error;
+      }
+    }
+  }
+  return {
+    action: input.handoff.action,
+    deliveries,
+    status: aggregateHandoffStatus(deliveries)
+  };
+};
+var createVoiceHandoffDeliveryRecord = (input) => {
+  const now = Date.now();
+  return {
+    action: input.action,
+    context: input.context,
+    createdAt: now,
+    deliveryAttempts: 0,
+    deliveryStatus: "pending",
+    id: input.id ?? createHandoffDeliveryId({
+      action: input.action,
+      sessionId: input.session.id
+    }),
+    metadata: input.metadata,
+    reason: input.reason,
+    result: input.result,
+    session: input.session,
+    sessionId: input.session.id,
+    target: input.target,
+    updatedAt: now
+  };
+};
+var applyVoiceHandoffDeliveryResult = (delivery, result) => ({
+  ...delivery,
+  deliveredAt: result.status === "delivered" || result.status === "skipped" ? Date.now() : delivery.deliveredAt,
+  deliveries: result.deliveries,
+  deliveryAttempts: (delivery.deliveryAttempts ?? 0) + 1,
+  deliveryError: result.status === "failed" ? resolveHandoffDeliveryError(result.deliveries) : undefined,
+  deliveryStatus: result.status,
+  updatedAt: Date.now()
+});
+var deliverVoiceHandoffDelivery = async (options) => {
+  const result = await deliverVoiceHandoff({
+    config: {
+      adapters: options.adapters,
+      failMode: options.failMode
+    },
+    handoff: {
+      action: options.delivery.action,
+      api: options.api,
+      context: options.delivery.context,
+      metadata: options.delivery.metadata,
+      reason: options.delivery.reason,
+      result: options.delivery.result,
+      session: options.delivery.session,
+      target: options.delivery.target
+    }
+  });
+  return result ? applyVoiceHandoffDeliveryResult(options.delivery, result) : {
+    ...options.delivery,
+    deliveryAttempts: (options.delivery.deliveryAttempts ?? 0) + 1,
+    deliveryStatus: "skipped",
+    updatedAt: Date.now()
+  };
+};
+var createVoiceMemoryHandoffDeliveryStore = () => {
+  const deliveries = new Map;
+  return {
+    get: async (id) => deliveries.get(id),
+    list: async () => [...deliveries.values()].sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)),
+    remove: async (id) => {
+      deliveries.delete(id);
+    },
+    set: async (id, delivery) => {
+      deliveries.set(id, delivery);
+    }
+  };
+};
+var createVoiceWebhookHandoffAdapter = (options) => ({
+  actions: options.actions,
+  handoff: async (input) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      return {
+        deliveredTo: options.url,
+        error: "Handoff delivery failed: fetch is not available in this runtime.",
+        status: "failed"
+      };
+    }
+    const body = JSON.stringify(await options.body?.(input) ?? defaultWebhookBody(input));
+    const headers = {
+      "content-type": "application/json",
+      ...options.headers
+    };
+    if (options.signingSecret) {
+      const timestamp = String(Date.now());
+      headers["x-absolutejs-timestamp"] = timestamp;
+      headers["x-absolutejs-signature"] = await signHandoffBody({
+        body,
+        secret: options.signingSecret,
+        timestamp
+      });
+    }
+    const controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController : undefined;
+    const timeout = controller && options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : undefined;
+    try {
+      const response = await fetchImpl(options.url, {
+        body,
+        headers,
+        method: options.method ?? "POST",
+        signal: controller?.signal
+      });
+      if (!response.ok) {
+        return {
+          deliveredTo: options.url,
+          error: `Handoff delivery failed with response ${response.status}.`,
+          status: "failed"
+        };
+      }
+      return {
+        deliveredAt: Date.now(),
+        deliveredTo: options.url,
+        status: "delivered"
+      };
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  },
+  id: options.id,
+  kind: options.kind ?? "webhook"
+});
+var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var defaultTwilioTransferTwiML = (input) => {
+  if (!input.target) {
+    return "<Response><Hangup /></Response>";
+  }
+  return `<Response><Dial>${escapeXml(input.target)}</Dial></Response>`;
+};
+var resolveTwilioCallSid = async (resolver, input) => {
+  if (typeof resolver === "function") {
+    return resolver(input);
+  }
+  if (typeof resolver === "string" && resolver.length > 0) {
+    return resolver;
+  }
+  const metadataSid = typeof input.metadata?.callSid === "string" ? input.metadata.callSid : undefined;
+  const sessionMetadata = input.session.metadata && typeof input.session.metadata === "object" ? input.session.metadata : undefined;
+  const sessionSid = typeof sessionMetadata?.callSid === "string" ? sessionMetadata.callSid : undefined;
+  return metadataSid ?? sessionSid;
+};
+var createVoiceTwilioRedirectHandoffAdapter = (options) => ({
+  actions: options.actions ?? ["transfer"],
+  handoff: async (input) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const callSid = await resolveTwilioCallSid(options.callSid, input);
+    if (!callSid) {
+      return {
+        error: "Twilio handoff requires a callSid.",
+        status: "failed"
+      };
+    }
+    if (typeof fetchImpl !== "function") {
+      return {
+        error: "Twilio handoff failed: fetch is not available in this runtime.",
+        status: "failed"
+      };
+    }
+    const url = `https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(options.accountSid)}/Calls/${encodeURIComponent(callSid)}.json`;
+    const body = new URLSearchParams({
+      Twiml: await (options.buildTwiML?.(input) ?? defaultTwilioTransferTwiML(input))
+    });
+    const auth = btoa(`${options.accountSid}:${options.authToken}`);
+    const controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController : undefined;
+    const timeout = controller && options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : undefined;
+    try {
+      const response = await fetchImpl(url, {
+        body,
+        headers: {
+          authorization: `Basic ${auth}`,
+          "content-type": "application/x-www-form-urlencoded"
+        },
+        method: "POST",
+        signal: controller?.signal
+      });
+      if (!response.ok) {
+        return {
+          deliveredTo: url,
+          error: `Twilio handoff failed with response ${response.status}.`,
+          status: "failed"
+        };
+      }
+      return {
+        deliveredAt: Date.now(),
+        deliveredTo: url,
+        metadata: {
+          callSid
+        },
+        status: "delivered"
+      };
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  },
+  id: options.id ?? "twilio-redirect",
+  kind: "twilio-redirect"
+});
+
 // src/turnDetection.ts
 var DEFAULT_SILENCE_MS = 700;
 var DEFAULT_SPEECH_THRESHOLD = 0.015;
@@ -3288,6 +3571,7 @@ var pushCallLifecycleEvent = (session, input) => {
   }
   return lifecycle;
 };
+var getLatestCallLifecycleEvent = (session) => session.call?.events.at(-1);
 var createVoiceSession = (options) => {
   const logger = resolveLogger(options.logger);
   const reconnect = {
@@ -3388,6 +3672,64 @@ var createVoiceSession = (options) => {
       });
     }
   };
+  const sendCallLifecycle = async (session) => {
+    const event = getLatestCallLifecycleEvent(session);
+    if (!event) {
+      return;
+    }
+    await send({
+      event,
+      sessionId: options.id,
+      type: "call_lifecycle"
+    });
+  };
+  const runHandoff = async (input) => {
+    const queuedDelivery = options.handoff?.deliveryQueue ? createVoiceHandoffDeliveryRecord({
+      action: input.action,
+      context: options.context,
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session: input.session,
+      target: input.target
+    }) : undefined;
+    if (queuedDelivery) {
+      await options.handoff?.deliveryQueue?.set(queuedDelivery.id, queuedDelivery);
+    }
+    if (options.handoff?.enqueueOnly) {
+      return;
+    }
+    const result = await deliverVoiceHandoff({
+      config: options.handoff,
+      handoff: {
+        action: input.action,
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        reason: input.reason,
+        result: input.result,
+        session: input.session,
+        target: input.target
+      }
+    });
+    if (!result) {
+      return;
+    }
+    if (queuedDelivery) {
+      const updatedDelivery = applyVoiceHandoffDeliveryResult(queuedDelivery, result);
+      await options.handoff?.deliveryQueue?.set(updatedDelivery.id, updatedDelivery);
+    }
+    await appendTrace({
+      metadata: input.metadata,
+      payload: {
+        ...result,
+        reason: input.reason,
+        target: input.target
+      },
+      session: input.session,
+      type: "call.handoff"
+    });
+  };
   const readSession = async () => options.store.getOrCreate(options.id);
   const writeSession = async (mutate) => {
     const session = await options.store.getOrCreate(options.id);
@@ -3578,6 +3920,7 @@ var createVoiceSession = (options) => {
     await appendTrace({
       payload: {
         disposition,
+        metadata: input.metadata,
         reason: input.reason,
         target: input.target,
         type: "end"
@@ -3585,6 +3928,7 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
     await send({
       sessionId: options.id,
       type: "complete"
@@ -3664,6 +4008,15 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "transfer",
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session,
+      target: input.target
+    });
     await completeInternal(input.result, {
       disposition: "transferred",
       invokeOnComplete: false,
@@ -3689,6 +4042,14 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "escalate",
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session
+    });
     await completeInternal(input.result, {
       disposition: "escalated",
       invokeOnComplete: false,
@@ -3711,6 +4072,13 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "no-answer",
+      metadata: input?.metadata,
+      result: input?.result,
+      session
+    });
     await completeInternal(input?.result, {
       disposition: "no-answer",
       invokeOnComplete: false,
@@ -3732,6 +4100,13 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "voicemail",
+      metadata: input?.metadata,
+      result: input?.result,
+      session
+    });
     await completeInternal(input?.result, {
       disposition: "voicemail",
       invokeOnComplete: false,
@@ -4518,6 +4893,7 @@ var createVoiceSession = (options) => {
         session,
         type: "call.lifecycle"
       });
+      await sendCallLifecycle(session);
     }
     await send({
       sessionId: options.id,
@@ -4755,6 +5131,14 @@ var isVoiceClientMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "call_control":
+      if (!("action" in value)) {
+        return false;
+      }
+      if (value.action !== "complete" && value.action !== "escalate" && value.action !== "no-answer" && value.action !== "transfer" && value.action !== "voicemail") {
+        return false;
+      }
+      return (!("metadata" in value) || value.metadata === undefined || value.metadata !== null && typeof value.metadata === "object") && (!("reason" in value) || value.reason === undefined || typeof value.reason === "string") && (!("target" in value) || value.target === undefined || typeof value.target === "string");
     case "close":
       return true;
     case "end_turn":
@@ -4895,6 +5279,7 @@ var voice = (config) => {
       audioConditioning: sessionOptions.audioConditioning,
       context,
       id: sessionId,
+      handoff: config.handoff,
       languageStrategy: config.languageStrategy,
       lexicon,
       logger: sessionOptions.logger,
@@ -5006,6 +5391,42 @@ var voice = (config) => {
           await current.close(message.reason);
           runtime.activeSessions.delete(sessionState.sessionId);
         }
+        if (message.type === "call_control" && current) {
+          if (message.action === "transfer") {
+            if (message.target) {
+              await current.transfer({
+                metadata: message.metadata,
+                reason: message.reason,
+                target: message.target
+              });
+            } else {
+              ws.send(JSON.stringify({
+                message: "call_control transfer requires target",
+                recoverable: true,
+                type: "error"
+              }));
+            }
+          }
+          if (message.action === "escalate") {
+            await current.escalate({
+              metadata: message.metadata,
+              reason: message.reason ?? "client-requested-escalation"
+            });
+          }
+          if (message.action === "voicemail") {
+            await current.markVoicemail({
+              metadata: message.metadata
+            });
+          }
+          if (message.action === "no-answer") {
+            await current.markNoAnswer({
+              metadata: message.metadata
+            });
+          }
+          if (message.action === "complete") {
+            await current.complete();
+          }
+        }
         if (message.type === "start" && message.sessionId && message.sessionId !== sessionState.sessionId) {
           const currentSession = runtime.activeSessions.get(sessionState.sessionId);
           if (currentSession) {
@@ -5052,9 +5473,15 @@ var voice = (config) => {
     }
   }).use(htmxRoutes());
 };
+// src/appKit.ts
+import { Elysia as Elysia11 } from "elysia";
+
+// src/assistantHealth.ts
+import { Elysia as Elysia3 } from "elysia";
+
 // src/agent.ts
 var normalizeText3 = (value) => typeof value === "string" ? value.trim() : "";
-var toErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var toErrorMessage3 = (error) => error instanceof Error ? error.message : String(error);
 var createHistoryMessages = (session, turn) => {
   const messages = [];
   for (const previousTurn of session.turns) {
@@ -5235,7 +5662,7 @@ var createVoiceAgent = (options) => {
             toolCallId: toolCall.id
           });
         } catch (error) {
-          const errorMessage = toErrorMessage2(error);
+          const errorMessage = toErrorMessage3(error);
           toolResults.push({
             error: errorMessage,
             status: "error",
@@ -6101,52 +6528,350 @@ var summarizeVoiceAssistantRuns = async (input) => {
     totalRuns: assistantRuns.length
   };
 };
-// src/fileStore.ts
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
-import { join } from "path";
 
-// src/trace.ts
-var createVoiceTraceEventId = (event) => [
-  event.sessionId,
-  event.turnId ?? "session",
-  event.type,
-  String(event.at ?? Date.now()),
-  crypto.randomUUID()
-].map(encodeURIComponent).join(":");
-var createVoiceTraceEvent = (event) => ({
-  ...event,
-  at: event.at,
-  id: event.id ?? createVoiceTraceEventId({
-    at: event.at,
-    sessionId: event.sessionId,
-    turnId: event.turnId,
-    type: event.type
-  })
-});
-var createVoiceTraceSinkDeliveryId = (events) => {
-  const firstEvent = events[0];
-  return [
-    firstEvent?.sessionId ?? "trace",
-    firstEvent?.traceId ?? "sink",
-    String(firstEvent?.at ?? Date.now()),
-    crypto.randomUUID()
-  ].map(encodeURIComponent).join(":");
-};
-var createVoiceTraceSinkDeliveryRecord = (input) => {
-  const createdAt = input.createdAt ?? Date.now();
-  return {
-    createdAt,
-    deliveredAt: input.deliveredAt,
-    deliveryAttempts: input.deliveryAttempts,
-    deliveryError: input.deliveryError,
-    deliveryStatus: input.deliveryStatus ?? "pending",
-    events: input.events,
-    id: input.id ?? createVoiceTraceSinkDeliveryId(input.events),
-    sinkDeliveries: input.sinkDeliveries,
-    updatedAt: input.updatedAt ?? createdAt
+// src/providerHealth.ts
+import { Elysia as Elysia2 } from "elysia";
+var getString = (value) => typeof value === "string" ? value : undefined;
+var getNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var isProviderStatus = (value) => value === "success" || value === "fallback" || value === "error";
+var summarizeVoiceProviderHealth = async (input) => {
+  const options = Array.isArray(input) ? { events: input } : input;
+  const events = options.events ?? await options.store?.list() ?? [];
+  const providers = options.providers ?? [];
+  const providerSet = new Set(providers);
+  const now = options.now ?? Date.now();
+  const entries = new Map;
+  const isAllowedProvider = (value) => typeof value === "string" && (providerSet.size === 0 || providerSet.has(value));
+  const getEntry = (provider) => {
+    const existing = entries.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      elapsedCount: 0,
+      elapsedTotal: 0,
+      errorCount: 0,
+      fallbackCount: 0,
+      provider,
+      rateLimited: false,
+      recommended: false,
+      runCount: 0,
+      status: "idle",
+      timeoutCount: 0
+    };
+    entries.set(provider, entry);
+    return entry;
   };
-};
-var matchesTraceFilter = (event, filter) => {
+  for (const provider of providers) {
+    getEntry(provider);
+  }
+  const hasProviderRouterEvents = events.some((event) => event.type === "session.error" && isAllowedProvider(event.payload.provider) && isProviderStatus(event.payload.providerStatus));
+  for (const event of events) {
+    if (event.type === "assistant.run") {
+      if (hasProviderRouterEvents) {
+        continue;
+      }
+      const provider2 = event.payload.variantId;
+      if (!isAllowedProvider(provider2)) {
+        continue;
+      }
+      const entry2 = getEntry(provider2);
+      entry2.runCount += 1;
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      continue;
+    }
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = event.payload.provider;
+    if (!isAllowedProvider(provider)) {
+      continue;
+    }
+    const providerStatus = isProviderStatus(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    const applyProviderHealth = () => {
+      const entry2 = getEntry(provider);
+      const providerHealth = event.payload.providerHealth;
+      if (providerHealth && typeof providerHealth === "object") {
+        const suppressedUntil2 = getNumber(providerHealth.suppressedUntil);
+        if (suppressedUntil2 !== undefined) {
+          entry2.suppressedUntil = suppressedUntil2;
+        }
+      }
+      const suppressedUntil = getNumber(event.payload.suppressedUntil);
+      if (suppressedUntil !== undefined) {
+        entry2.suppressedUntil = suppressedUntil;
+      }
+      const suppressionRemainingMs = getNumber(event.payload.suppressionRemainingMs);
+      if (suppressionRemainingMs !== undefined) {
+        entry2.suppressionRemainingMs = suppressionRemainingMs;
+      }
+      return entry2;
+    };
+    if (providerStatus === "success" || providerStatus === "fallback") {
+      const entry2 = applyProviderHealth();
+      entry2.runCount += 1;
+      entry2.lastSuccessAt = event.at;
+      if (providerStatus === "success") {
+        entry2.lastError = undefined;
+        entry2.rateLimited = false;
+        entry2.suppressedUntil = undefined;
+        entry2.suppressionRemainingMs = undefined;
+      }
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      const selectedProvider = event.payload.selectedProvider;
+      if (providerStatus === "fallback" && isAllowedProvider(selectedProvider) && selectedProvider !== provider) {
+        getEntry(selectedProvider).fallbackCount += 1;
+      }
+      continue;
+    }
+    const entry = applyProviderHealth();
+    entry.errorCount += 1;
+    if (event.payload.timedOut === true) {
+      entry.timeoutCount += 1;
+    }
+    entry.lastError = getString(event.payload.error);
+    entry.lastErrorAt = event.at;
+    entry.rateLimited ||= event.payload.rateLimited === true;
+  }
+  const summaries = [...entries.values()].map((entry) => {
+    const hadSuppression = typeof entry.suppressedUntil === "number" || typeof entry.suppressionRemainingMs === "number";
+    const suppressionRemainingMs = typeof entry.suppressedUntil === "number" ? Math.max(0, entry.suppressedUntil - now) : entry.suppressionRemainingMs;
+    const activeSuppression = typeof suppressionRemainingMs === "number" && suppressionRemainingMs > 0;
+    const recoverable = hadSuppression && !activeSuppression;
+    const averageElapsedMs = entry.elapsedCount > 0 ? Math.round(entry.elapsedTotal / entry.elapsedCount) : undefined;
+    const status = activeSuppression ? "suppressed" : recoverable ? "recoverable" : entry.rateLimited ? "rate-limited" : entry.errorCount > 0 && (!entry.lastSuccessAt || !entry.lastErrorAt || entry.lastErrorAt > entry.lastSuccessAt) ? "degraded" : entry.runCount > 0 ? "healthy" : "idle";
+    return {
+      averageElapsedMs,
+      errorCount: entry.errorCount,
+      fallbackCount: entry.fallbackCount,
+      lastError: entry.lastError,
+      lastErrorAt: entry.lastErrorAt,
+      lastSuccessAt: entry.lastSuccessAt,
+      provider: entry.provider,
+      rateLimited: entry.rateLimited,
+      recommended: false,
+      runCount: entry.runCount,
+      status,
+      suppressionRemainingMs: activeSuppression ? suppressionRemainingMs : undefined,
+      suppressedUntil: entry.suppressedUntil,
+      timeoutCount: entry.timeoutCount
+    };
+  });
+  const recommended = summaries.filter((entry) => entry.status === "healthy").sort((left, right) => (left.averageElapsedMs ?? Number.MAX_SAFE_INTEGER) - (right.averageElapsedMs ?? Number.MAX_SAFE_INTEGER))[0];
+  if (recommended) {
+    recommended.recommended = true;
+  }
+  return summaries;
+};
+var escapeHtml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderVoiceProviderHealthHTML = (providers) => providers.length === 0 ? '<p class="voice-provider-empty">No provider status yet.</p>' : [
+  '<div class="voice-provider-health">',
+  ...providers.map((provider) => {
+    const suppressionSeconds = typeof provider.suppressionRemainingMs === "number" ? Math.ceil(provider.suppressionRemainingMs / 1000) : undefined;
+    return [
+      `<article class="voice-provider-card ${escapeHtml3(provider.status)}">`,
+      '<div class="voice-provider-card-header">',
+      `<strong>${escapeHtml3(provider.provider)}</strong>`,
+      `<span>${escapeHtml3(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>`,
+      "</div>",
+      "<dl>",
+      `<div><dt>Runs</dt><dd>${String(provider.runCount)}</dd></div>`,
+      `<div><dt>Avg latency</dt><dd>${String(provider.averageElapsedMs ?? 0)}ms</dd></div>`,
+      `<div><dt>Errors</dt><dd>${String(provider.errorCount)}</dd></div>`,
+      `<div><dt>Timeouts</dt><dd>${String(provider.timeoutCount)}</dd></div>`,
+      `<div><dt>Fallbacks</dt><dd>${String(provider.fallbackCount)}</dd></div>`,
+      "</dl>",
+      suppressionSeconds ? `<p>Temporarily suppressed for ${String(suppressionSeconds)}s.</p>` : "",
+      provider.lastError ? `<p>${escapeHtml3(provider.lastError)}</p>` : "",
+      "</article>"
+    ].join("");
+  }),
+  "</div>"
+].join("");
+var createVoiceProviderHealthJSONHandler = (options) => async () => summarizeVoiceProviderHealth(options);
+var createVoiceProviderHealthHTMLHandler = (options) => async () => {
+  const providers = await summarizeVoiceProviderHealth(options);
+  const render = options.render ?? renderVoiceProviderHealthHTML;
+  const body = await render(providers);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceProviderHealthRoutes = (options) => {
+  const path = options.path ?? "/api/provider-status";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia2({
+    name: options.name ?? "absolutejs-voice-provider-health"
+  }).get(path, createVoiceProviderHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceProviderHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/assistantHealth.ts
+var escapeHtml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderCountMap = (values) => {
+  const entries = Object.entries(values).sort((left, right) => right[1] - left[1]);
+  if (entries.length === 0) {
+    return '<p class="voice-assistant-health-empty">No data yet.</p>';
+  }
+  return [
+    '<div class="voice-assistant-health-metrics">',
+    ...entries.map(([label, value]) => `<div><span>${escapeHtml4(label)}</span><strong>${String(value)}</strong></div>`),
+    "</div>"
+  ].join("");
+};
+var getString2 = (value) => typeof value === "string" ? value : undefined;
+var getRecentFailures = (events, maxFailures, replayHref) => events.filter((event) => event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string") || event.type === "assistant.guardrail" && event.payload.action === "blocked").toReversed().slice(0, maxFailures).map((event) => {
+  const failure = {
+    at: event.at,
+    assistantId: getString2(event.payload.assistantId),
+    error: getString2(event.payload.error),
+    provider: getString2(event.payload.provider),
+    rateLimited: event.payload.rateLimited === true ? true : undefined,
+    sessionId: event.sessionId,
+    status: getString2(event.payload.providerStatus),
+    turnId: event.turnId,
+    type: event.type
+  };
+  const href = replayHref === false ? undefined : typeof replayHref === "function" ? replayHref(failure) : `${replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(event.sessionId)}/replay/htmx`;
+  return {
+    ...failure,
+    replayHref: href
+  };
+});
+var summarizeVoiceAssistantHealth = async (options) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  return {
+    assistantRuns: await summarizeVoiceAssistantRuns({ events }),
+    providerHealth: await summarizeVoiceProviderHealth({
+      events,
+      providers: options.providers
+    }),
+    recentFailures: getRecentFailures(events, options.maxFailures ?? 8, options.replayHref)
+  };
+};
+var renderVoiceAssistantHealthHTML = (summary) => {
+  const assistant = summary.assistantRuns.assistants[0];
+  const failures = summary.recentFailures;
+  return [
+    '<div class="voice-assistant-health">',
+    '<section class="voice-assistant-health-grid">',
+    `<article><span>Runs</span><strong>${String(assistant?.runCount ?? 0)}</strong></article>`,
+    `<article><span>Sessions</span><strong>${String(assistant?.sessions ?? 0)}</strong></article>`,
+    `<article><span>Guardrails</span><strong>${String(assistant?.guardrailCount ?? 0)}</strong></article>`,
+    `<article><span>Avg latency</span><strong>${String(assistant?.averageElapsedMs ?? 0)}ms</strong></article>`,
+    "</section>",
+    "<section>",
+    "<h3>Provider Health</h3>",
+    renderVoiceProviderHealthHTML(summary.providerHealth),
+    "</section>",
+    '<section class="voice-assistant-health-columns">',
+    `<article><h3>Outcomes</h3>${renderCountMap(assistant?.outcomes ?? {})}</article>`,
+    `<article><h3>Variants</h3>${renderCountMap(assistant?.variants ?? {})}</article>`,
+    `<article><h3>Tools</h3>${renderCountMap(assistant?.toolCalls ?? {})}</article>`,
+    `<article><h3>Artifact Plans</h3>${renderCountMap(assistant?.artifactPlans ?? {})}</article>`,
+    "</section>",
+    "<section>",
+    "<h3>Recent Failures</h3>",
+    failures.length === 0 ? '<p class="voice-assistant-health-empty">No failures yet.</p>' : [
+      '<div class="voice-assistant-health-failures">',
+      ...failures.map((failure) => [
+        "<article>",
+        `<strong>${escapeHtml4(failure.provider ?? failure.assistantId ?? failure.type)}</strong>`,
+        `<span>${escapeHtml4(failure.status ?? (failure.rateLimited ? "rate-limited" : "error"))}</span>`,
+        failure.error ? `<p>${escapeHtml4(failure.error)}</p>` : "",
+        `<small>${escapeHtml4(failure.sessionId)}${failure.turnId ? ` / ${escapeHtml4(failure.turnId)}` : ""}</small>`,
+        failure.replayHref ? `<p><a href="${escapeHtml4(failure.replayHref)}">Open replay</a></p>` : "",
+        "</article>"
+      ].join("")),
+      "</div>"
+    ].join(""),
+    "</section>",
+    "</div>"
+  ].join("");
+};
+var createVoiceAssistantHealthJSONHandler = (options) => async () => summarizeVoiceAssistantHealth(options);
+var createVoiceAssistantHealthHTMLHandler = (options) => async () => {
+  const summary = await summarizeVoiceAssistantHealth(options);
+  const render = options.render ?? renderVoiceAssistantHealthHTML;
+  const body = await render(summary);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceAssistantHealthRoutes = (options) => {
+  const path = options.path ?? "/api/assistant-health";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia3({
+    name: options.name ?? "absolutejs-voice-assistant-health"
+  }).get(path, createVoiceAssistantHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceAssistantHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/diagnosticsRoutes.ts
+import { Elysia as Elysia4 } from "elysia";
+
+// src/trace.ts
+var createVoiceTraceEventId = (event) => [
+  event.sessionId,
+  event.turnId ?? "session",
+  event.type,
+  String(event.at ?? Date.now()),
+  crypto.randomUUID()
+].map(encodeURIComponent).join(":");
+var createVoiceTraceEvent = (event) => ({
+  ...event,
+  at: event.at,
+  id: event.id ?? createVoiceTraceEventId({
+    at: event.at,
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    type: event.type
+  })
+});
+var createVoiceTraceSinkDeliveryId = (events) => {
+  const firstEvent = events[0];
+  return [
+    firstEvent?.sessionId ?? "trace",
+    firstEvent?.traceId ?? "sink",
+    String(firstEvent?.at ?? Date.now()),
+    crypto.randomUUID()
+  ].map(encodeURIComponent).join(":");
+};
+var createVoiceTraceSinkDeliveryRecord = (input) => {
+  const createdAt = input.createdAt ?? Date.now();
+  return {
+    createdAt,
+    deliveredAt: input.deliveredAt,
+    deliveryAttempts: input.deliveryAttempts,
+    deliveryError: input.deliveryError,
+    deliveryStatus: input.deliveryStatus ?? "pending",
+    events: input.events,
+    id: input.id ?? createVoiceTraceSinkDeliveryId(input.events),
+    sinkDeliveries: input.sinkDeliveries,
+    updatedAt: input.updatedAt ?? createdAt
+  };
+};
+var matchesTraceFilter = (event, filter) => {
   if (filter.sessionId !== undefined && event.sessionId !== filter.sessionId) {
     return false;
   }
@@ -6207,7 +6932,7 @@ var sleep3 = async (delayMs) => {
   }
   await new Promise((resolve2) => setTimeout(resolve2, delayMs));
 };
-var toHex3 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var toHex4 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceTraceSinkBody = async (input) => {
   const encoder = new TextEncoder;
   const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
@@ -6216,7 +6941,7 @@ var signVoiceTraceSinkBody = async (input) => {
   }, false, ["sign"]);
   const payload = encoder.encode(`${input.timestamp}.${input.body}`);
   const signature = await crypto.subtle.sign("HMAC", key, payload);
-  return `sha256=${toHex3(new Uint8Array(signature))}`;
+  return `sha256=${toHex4(new Uint8Array(signature))}`;
 };
 var createVoiceTraceSinkDeliveryError = (input) => {
   if (input.response) {
@@ -6437,7 +7162,7 @@ var exportVoiceTrace = async (input) => {
   };
 };
 var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
-var escapeHtml3 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var formatTraceValue = (value) => {
   if (value === undefined || value === null) {
     return "";
@@ -6715,10 +7440,10 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     const offset = summary.startedAt === undefined ? event.at : Math.max(0, event.at - summary.startedAt);
     return [
       "<tr>",
-      `<td>${escapeHtml3(String(offset))}</td>`,
-      `<td>${escapeHtml3(event.type)}</td>`,
-      `<td>${escapeHtml3(event.turnId ?? "")}</td>`,
-      `<td><code>${escapeHtml3(JSON.stringify(event.payload))}</code></td>`,
+      `<td>${escapeHtml5(String(offset))}</td>`,
+      `<td>${escapeHtml5(event.type)}</td>`,
+      `<td>${escapeHtml5(event.turnId ?? "")}</td>`,
+      `<td><code>${escapeHtml5(JSON.stringify(event.payload))}</code></td>`,
       "</tr>"
     ].join("");
   }).join(`
@@ -6729,7 +7454,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     "<head>",
     '<meta charset="utf-8" />',
     '<meta name="viewport" content="width=device-width, initial-scale=1" />',
-    `<title>${escapeHtml3(options.title ?? "Voice Trace")}</title>`,
+    `<title>${escapeHtml5(options.title ?? "Voice Trace")}</title>`,
     "<style>",
     "body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;line-height:1.45;background:#f8f7f2;color:#181713}",
     "main{max-width:1100px;margin:auto}",
@@ -6743,7 +7468,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     "</style>",
     "</head>",
     "<body><main>",
-    `<h1>${escapeHtml3(options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim())}</h1>`,
+    `<h1>${escapeHtml5(options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim())}</h1>`,
     `<p class="${evaluation.pass ? "pass" : "fail"}">QA: ${evaluation.pass ? "pass" : "fail"}</p>`,
     '<section class="summary">',
     `<div class="card"><strong>Events</strong><br>${summary.eventCount}</div>`,
@@ -6757,19 +7482,2255 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     eventRows,
     "</tbody></table>",
     "<h2>Markdown Export</h2>",
-    `<pre>${escapeHtml3(markdown)}</pre>`,
+    `<pre>${escapeHtml5(markdown)}</pre>`,
     "</main></body></html>"
   ].join(`
 `);
 };
-var buildVoiceTraceReplay = (events, options = {}) => ({
-  evaluation: evaluateVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events, options.evaluation),
-  html: renderVoiceTraceHTML(events, options),
-  markdown: renderVoiceTraceMarkdown(events, options),
-  summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
+var buildVoiceTraceReplay = (events, options = {}) => ({
+  evaluation: evaluateVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events, options.evaluation),
+  html: renderVoiceTraceHTML(events, options),
+  markdown: renderVoiceTraceMarkdown(events, options),
+  summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
+});
+
+// src/diagnosticsRoutes.ts
+var escapeHtml6 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString3 = (value) => typeof value === "string" && value.trim() ? value : undefined;
+var getNumber2 = (value) => {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : undefined;
+  return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : undefined;
+};
+var getBoolean = (value) => value === true || value === "true" || value === "1";
+var parseTraceTypeFilter = (value) => {
+  if (typeof value !== "string" || !value.trim()) {
+    return;
+  }
+  const types = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return types.length <= 1 ? types[0] : types;
+};
+var resolveVoiceDiagnosticsTraceFilter = (query) => ({
+  limit: getNumber2(query.limit),
+  scenarioId: getString3(query.scenarioId),
+  sessionId: getString3(query.sessionId),
+  traceId: getString3(query.traceId),
+  turnId: getString3(query.turnId),
+  type: parseTraceTypeFilter(query.type)
+});
+var filterByDiagnosticsQuery = (events, query) => {
+  const provider = getString3(query.provider);
+  const status = getString3(query.status);
+  const since = getNumber2(query.since);
+  const until = getNumber2(query.until);
+  return filterVoiceTraceEvents(events, resolveVoiceDiagnosticsTraceFilter(query)).filter((event) => (!provider || event.payload.provider === provider) && (!status || event.payload.providerStatus === status || event.payload.status === status) && (since === undefined || event.at >= since) && (until === undefined || event.at <= until));
+};
+var buildVoiceDiagnosticsMarkdown = (events, options = {}) => {
+  const summary = summarizeVoiceTrace(events);
+  const evaluation = evaluateVoiceTrace(events, options.evaluation);
+  const trace = renderVoiceTraceMarkdown(events, {
+    evaluation: options.evaluation,
+    title: options.title ?? `Voice Diagnostics ${summary.sessionId ?? ""}`.trim()
+  });
+  return [
+    `# ${options.title ?? "Voice Diagnostics Bug Report"}`,
+    "",
+    `Session: ${summary.sessionId ?? "unknown"}`,
+    `Pass: ${evaluation.pass ? "yes" : "no"}`,
+    `Events: ${summary.eventCount}`,
+    `Turns: ${summary.turnCount}`,
+    `Errors: ${summary.errorCount}`,
+    `Tool errors: ${summary.toolErrorCount}`,
+    `Estimated cost units: ${summary.cost.estimatedRelativeCostUnits}`,
+    "",
+    "## Issues",
+    "",
+    evaluation.issues.length ? evaluation.issues.map((issue) => `- [${issue.severity}] ${issue.code}: ${issue.message}`).join(`
+`) : "- none",
+    "",
+    "## Trace",
+    "",
+    trace
+  ].join(`
+`);
+};
+var renderDiagnosticsIndex = (input) => {
+  const sessions = new Map;
+  for (const event of input.events) {
+    sessions.set(event.sessionId, [...sessions.get(event.sessionId) ?? [], event]);
+  }
+  const rows = [...sessions.entries()].sort(([, left], [, right]) => (right.at(-1)?.at ?? 0) - (left.at(-1)?.at ?? 0)).slice(0, 50).map(([sessionId, events]) => {
+    const summary = summarizeVoiceTrace(events);
+    const encoded = encodeURIComponent(sessionId);
+    return `<tr><td>${escapeHtml6(sessionId)}</td><td>${summary.eventCount}</td><td>${summary.turnCount}</td><td>${summary.errorCount}</td><td><a href="${input.basePath}/html?sessionId=${encoded}&redact=true">HTML</a> \xB7 <a href="${input.basePath}/markdown?sessionId=${encoded}&redact=true">Markdown</a> \xB7 <a href="${input.basePath}/json?sessionId=${encoded}&redact=true">JSON</a></td></tr>`;
+  }).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml6(input.title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1100px;margin:auto}table{width:100%;border-collapse:collapse;background:white}td,th{border-bottom:1px solid #eee;padding:.7rem;text-align:left}a{color:#9a3412}</style></head><body><main><h1>${escapeHtml6(input.title)}</h1><p>Recent voice trace diagnostics. Exports support filters: sessionId, traceId, turnId, scenarioId, type, provider, status, since, until, limit, redact.</p><table><thead><tr><th>Session</th><th>Events</th><th>Turns</th><th>Errors</th><th>Exports</th></tr></thead><tbody>${rows}</tbody></table></main></body></html>`;
+};
+var withRedaction = (events, query, defaultRedact) => {
+  const shouldRedact = query.redact === undefined ? defaultRedact : getBoolean(query.redact);
+  return shouldRedact ? redactVoiceTraceEvents(events, shouldRedact) : events;
+};
+var createVoiceDiagnosticsRoutes = (options) => {
+  const path = options.path ?? "/diagnostics";
+  const title = options.title ?? "AbsoluteJS Voice Diagnostics";
+  const routes = new Elysia4({
+    name: options.name ?? "absolutejs-voice-diagnostics"
+  });
+  routes.get(path, async () => {
+    const events = await options.store.list();
+    return new Response(renderDiagnosticsIndex({ basePath: path, events, title }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async ({ query }) => {
+    const events = filterByDiagnosticsQuery(await options.store.list(), query);
+    const redacted = withRedaction(events, query, options.redact);
+    return Response.json({
+      ...await exportVoiceTrace({
+        filter: resolveVoiceDiagnosticsTraceFilter(query),
+        redact: false,
+        store: {
+          ...options.store,
+          list: async () => redacted
+        }
+      }),
+      filteredCount: events.length,
+      redacted: redacted !== events
+    });
+  });
+  routes.get(`${path}/markdown`, async ({ query }) => {
+    const events = withRedaction(filterByDiagnosticsQuery(await options.store.list(), query), query, options.redact ?? true);
+    const body = buildVoiceDiagnosticsMarkdown(events, {
+      evaluation: options.evaluation,
+      title
+    });
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/html`, async ({ query }) => {
+    const events = withRedaction(filterByDiagnosticsQuery(await options.store.list(), query), query, options.redact ?? true);
+    const body = renderVoiceTraceHTML(events, {
+      evaluation: options.evaluation,
+      title
+    });
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
+
+// src/evalRoutes.ts
+import { Elysia as Elysia7 } from "elysia";
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+
+// src/qualityRoutes.ts
+import { Elysia as Elysia6 } from "elysia";
+
+// src/handoffHealth.ts
+import { Elysia as Elysia5 } from "elysia";
+var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString4 = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var isStatus = (value) => value === "delivered" || value === "failed" || value === "skipped";
+var increment2 = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+var normalizeDelivery = (adapterId, value) => {
+  const record = value && typeof value === "object" ? value : {};
+  return {
+    adapterId: getString4(record.adapterId) ?? adapterId,
+    adapterKind: getString4(record.adapterKind),
+    deliveredAt: typeof record.deliveredAt === "number" ? record.deliveredAt : undefined,
+    deliveredTo: getString4(record.deliveredTo),
+    error: getString4(record.error),
+    status: isStatus(record.status) ? record.status : "failed"
+  };
+};
+var normalizeDeliveries = (payload) => {
+  const deliveries = payload.deliveries;
+  if (!deliveries || typeof deliveries !== "object") {
+    return [];
+  }
+  return Object.entries(deliveries).map(([adapterId, value]) => normalizeDelivery(adapterId, value));
+};
+var resolveReplayHref = (event, replayHref) => {
+  if (replayHref === false) {
+    return;
+  }
+  if (typeof replayHref === "function") {
+    return replayHref(event);
+  }
+  return `${replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(event.sessionId)}/replay/htmx`;
+};
+var summarizeVoiceHandoffHealth = async (options = {}) => {
+  const sourceEvents = options.events ?? await options.store?.list() ?? [];
+  const search = options.q?.trim().toLowerCase();
+  const byAction = {};
+  const byAdapter = {};
+  const byStatus = {
+    delivered: 0,
+    failed: 0,
+    skipped: 0
+  };
+  const events = sourceEvents.filter((event) => event.type === "call.handoff").map((event) => {
+    const status = isStatus(event.payload.status) ? event.payload.status : "failed";
+    const deliveries = normalizeDeliveries(event.payload);
+    const item = {
+      action: getString4(event.payload.action),
+      at: event.at,
+      deliveries,
+      reason: getString4(event.payload.reason),
+      sessionId: event.sessionId,
+      status,
+      target: getString4(event.payload.target)
+    };
+    return {
+      ...item,
+      replayHref: resolveReplayHref(item, options.replayHref)
+    };
+  }).filter((event) => {
+    if (options.status && options.status !== "all" && event.status !== options.status) {
+      return false;
+    }
+    if (!search) {
+      return true;
+    }
+    return [
+      event.action,
+      event.reason,
+      event.sessionId,
+      event.status,
+      event.target,
+      ...event.deliveries.flatMap((delivery) => [
+        delivery.adapterId,
+        delivery.adapterKind,
+        delivery.deliveredTo,
+        delivery.error,
+        delivery.status
+      ])
+    ].some((value) => value?.toLowerCase().includes(search));
+  }).sort((left, right) => right.at - left.at).slice(0, options.limit ?? 50);
+  for (const event of events) {
+    byStatus[event.status] += 1;
+    if (event.action) {
+      increment2(byAction, event.action);
+    }
+    for (const delivery of event.deliveries) {
+      byAdapter[delivery.adapterId] ??= {
+        delivered: 0,
+        failed: 0,
+        skipped: 0
+      };
+      byAdapter[delivery.adapterId][delivery.status] += 1;
+    }
+  }
+  return {
+    byAction,
+    byAdapter,
+    byStatus,
+    events,
+    failed: byStatus.failed,
+    total: events.length
+  };
+};
+var renderMetricGrid = (summary) => [
+  '<section class="voice-handoff-health-grid">',
+  `<article><span>Total</span><strong>${String(summary.total)}</strong></article>`,
+  `<article><span>Delivered</span><strong>${String(summary.byStatus.delivered)}</strong></article>`,
+  `<article><span>Failed</span><strong>${String(summary.byStatus.failed)}</strong></article>`,
+  `<article><span>Skipped</span><strong>${String(summary.byStatus.skipped)}</strong></article>`,
+  "</section>"
+].join("");
+var renderActionSummary = (summary) => {
+  const actions = Object.entries(summary.byAction).sort((left, right) => right[1] - left[1]);
+  const adapters = Object.entries(summary.byAdapter).sort(([left], [right]) => left.localeCompare(right));
+  return [
+    '<section class="voice-handoff-health-columns">',
+    "<article><h3>Actions</h3>",
+    actions.length === 0 ? "<p>No handoff actions yet.</p>" : `<ul>${actions.map(([action, count]) => `<li>${escapeHtml7(action)}: ${String(count)}</li>`).join("")}</ul>`,
+    "</article>",
+    "<article><h3>Adapters</h3>",
+    adapters.length === 0 ? "<p>No adapter deliveries yet.</p>" : `<ul>${adapters.map(([adapterId, counts]) => `<li>${escapeHtml7(adapterId)}: ${String(counts.delivered)} delivered / ${String(counts.failed)} failed / ${String(counts.skipped)} skipped</li>`).join("")}</ul>`,
+    "</article>",
+    "</section>"
+  ].join("");
+};
+var renderVoiceHandoffHealthHTML = (summary) => [
+  '<div class="voice-handoff-health">',
+  renderMetricGrid(summary),
+  renderActionSummary(summary),
+  "<section>",
+  "<h3>Recent Handoffs</h3>",
+  summary.events.length === 0 ? '<p class="voice-handoff-health-empty">No handoffs found.</p>' : [
+    '<div class="voice-handoff-health-events">',
+    ...summary.events.map((event) => [
+      `<article class="${escapeHtml7(event.status)}">`,
+      '<div class="voice-handoff-health-event-header">',
+      `<strong>${escapeHtml7(event.action ?? "handoff")}</strong>`,
+      `<span>${escapeHtml7(event.status)}</span>`,
+      "</div>",
+      `<p><small>${escapeHtml7(event.sessionId)}</small></p>`,
+      event.target ? `<p>Target: ${escapeHtml7(event.target)}</p>` : "",
+      event.reason ? `<p>Reason: ${escapeHtml7(event.reason)}</p>` : "",
+      event.deliveries.length ? `<ul>${event.deliveries.map((delivery) => [
+        "<li>",
+        `${escapeHtml7(delivery.adapterId)}: ${escapeHtml7(delivery.status)}`,
+        delivery.deliveredTo ? ` to ${escapeHtml7(delivery.deliveredTo)}` : "",
+        delivery.error ? ` (${escapeHtml7(delivery.error)})` : "",
+        "</li>"
+      ].join("")).join("")}</ul>` : "",
+      event.replayHref ? `<p><a href="${escapeHtml7(event.replayHref)}">Open replay</a></p>` : "",
+      "</article>"
+    ].join("")),
+    "</div>"
+  ].join(""),
+  "</section>",
+  "</div>"
+].join("");
+var createVoiceHandoffHealthJSONHandler = (options = {}) => async ({ query }) => summarizeVoiceHandoffHealth({
+  ...options,
+  limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+  q: query?.q ?? options.q,
+  status: query?.status === "delivered" || query?.status === "failed" || query?.status === "skipped" || query?.status === "all" ? query.status : options.status
+});
+var createVoiceHandoffHealthHTMLHandler = (options = {}) => async ({ query }) => {
+  const summary = await summarizeVoiceHandoffHealth({
+    ...options,
+    limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+    q: query?.q ?? options.q,
+    status: query?.status === "delivered" || query?.status === "failed" || query?.status === "skipped" || query?.status === "all" ? query.status : options.status
+  });
+  const body = await (options.render?.(summary) ?? renderVoiceHandoffHealthHTML(summary));
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceHandoffHealthRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-handoffs";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia5({
+    name: options.name ?? "absolutejs-voice-handoff-health"
+  }).get(path, createVoiceHandoffHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceHandoffHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/qualityRoutes.ts
+var DEFAULT_THRESHOLDS = {
+  maxDuplicateTurnRate: 0,
+  maxEmptyTurnRate: 0.02,
+  maxHandoffFailureRate: 0,
+  maxMissingAssistantReplyRate: 0.05,
+  maxProviderAverageLatencyMs: 3000,
+  maxProviderErrorRate: 0.05,
+  maxProviderFallbackRate: 0.25,
+  maxProviderTimeoutRate: 0.03
+};
+var getString5 = (value) => typeof value === "string" ? value : undefined;
+var getNumber3 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var rate = (count, total) => count / Math.max(1, total);
+var roundMetric2 = (value) => Math.round(value * 1e4) / 1e4;
+var createMetric = (input) => ({
+  ...input,
+  actual: roundMetric2(input.actual),
+  pass: input.actual <= input.threshold
+});
+var evaluateVoiceQuality = async (input) => {
+  const events = filterVoiceTraceEvents(input.events ?? await input.store?.list() ?? []);
+  const thresholds = {
+    ...DEFAULT_THRESHOLDS,
+    ...input.thresholds
+  };
+  const committedTurns = events.filter((event) => event.type === "turn.committed");
+  const assistantReplies = events.filter((event) => event.type === "turn.assistant");
+  const sessionIdsWithAssistantReply = new Set(assistantReplies.map((event) => event.sessionId));
+  const sessionsWithTurns = new Set(committedTurns.map((event) => event.sessionId));
+  const emptyTurns = committedTurns.filter((event) => !getString5(event.payload.text)?.trim());
+  const turnTextsBySession = new Map;
+  let duplicateTurns = 0;
+  for (const turn of committedTurns) {
+    const normalized = getString5(turn.payload.text)?.trim().toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    const seen = turnTextsBySession.get(turn.sessionId) ?? new Set;
+    if (seen.has(normalized)) {
+      duplicateTurns += 1;
+    }
+    seen.add(normalized);
+    turnTextsBySession.set(turn.sessionId, seen);
+  }
+  const missingAssistantReplySessions = [...sessionsWithTurns].filter((sessionId) => !sessionIdsWithAssistantReply.has(sessionId)).length;
+  const providerEvents = events.filter((event) => event.type === "session.error" && typeof event.payload.provider === "string" && typeof event.payload.providerStatus === "string");
+  const providerErrors = providerEvents.filter((event) => event.payload.providerStatus === "error");
+  const providerFallbacks = providerEvents.filter((event) => event.payload.providerStatus === "fallback");
+  const providerTimeouts = providerEvents.filter((event) => event.payload.timedOut === true);
+  const providerLatencies = providerEvents.map((event) => getNumber3(event.payload.elapsedMs)).filter((value) => value !== undefined);
+  const averageProviderLatencyMs = providerLatencies.length > 0 ? providerLatencies.reduce((sum, value) => sum + value, 0) / providerLatencies.length : 0;
+  const handoffHealth = await summarizeVoiceHandoffHealth({ events });
+  const metrics = {
+    duplicateTurnRate: createMetric({
+      actual: rate(duplicateTurns, committedTurns.length),
+      label: "Duplicate turn rate",
+      threshold: thresholds.maxDuplicateTurnRate,
+      unit: "rate"
+    }),
+    emptyTurnRate: createMetric({
+      actual: rate(emptyTurns.length, committedTurns.length),
+      label: "Empty turn rate",
+      threshold: thresholds.maxEmptyTurnRate,
+      unit: "rate"
+    }),
+    handoffFailureRate: createMetric({
+      actual: rate(handoffHealth.failed, handoffHealth.total),
+      label: "Handoff failure rate",
+      threshold: thresholds.maxHandoffFailureRate,
+      unit: "rate"
+    }),
+    missingAssistantReplyRate: createMetric({
+      actual: rate(missingAssistantReplySessions, sessionsWithTurns.size),
+      label: "Missing assistant reply rate",
+      threshold: thresholds.maxMissingAssistantReplyRate,
+      unit: "rate"
+    }),
+    providerAverageLatencyMs: createMetric({
+      actual: averageProviderLatencyMs,
+      label: "Average provider latency",
+      threshold: thresholds.maxProviderAverageLatencyMs,
+      unit: "ms"
+    }),
+    providerErrorRate: createMetric({
+      actual: rate(providerErrors.length, providerEvents.length),
+      label: "Provider error rate",
+      threshold: thresholds.maxProviderErrorRate,
+      unit: "rate"
+    }),
+    providerFallbackRate: createMetric({
+      actual: rate(providerFallbacks.length, providerEvents.length),
+      label: "Provider fallback rate",
+      threshold: thresholds.maxProviderFallbackRate,
+      unit: "rate"
+    }),
+    providerTimeoutRate: createMetric({
+      actual: rate(providerTimeouts.length, providerEvents.length),
+      label: "Provider timeout rate",
+      threshold: thresholds.maxProviderTimeoutRate,
+      unit: "rate"
+    })
+  };
+  const status = Object.values(metrics).every((metric) => metric.pass) ? "pass" : "fail";
+  return {
+    checkedAt: Date.now(),
+    eventCount: events.length,
+    metrics,
+    status,
+    thresholds
+  };
+};
+var escapeHtml8 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var formatMetricValue = (metric) => metric.unit === "rate" ? `${(metric.actual * 100).toFixed(2)}%` : metric.unit === "ms" ? `${Math.round(metric.actual)}ms` : String(metric.actual);
+var formatThreshold = (metric) => metric.unit === "rate" ? `${(metric.threshold * 100).toFixed(2)}%` : metric.unit === "ms" ? `${Math.round(metric.threshold)}ms` : String(metric.threshold);
+var renderVoiceQualityHTML = (report, options = {}) => {
+  const rows = Object.entries(report.metrics).map(([key, metric]) => `<tr class="${metric.pass ? "pass" : "fail"}"><td>${escapeHtml8(metric.label)}</td><td>${escapeHtml8(formatMetricValue(metric))}</td><td>${escapeHtml8(formatThreshold(metric))}</td><td>${metric.pass ? "pass" : "fail"}</td><td><code>${escapeHtml8(key)}</code></td></tr>`).join("");
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml8(link.href)}">${escapeHtml8(link.label)}</a>`).join("")}</nav>` : "";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>AbsoluteJS Voice Quality</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1100px;margin:auto}nav{display:flex;flex-wrap:wrap;gap:.5rem;margin:0 0 1.25rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;padding:.35rem .75rem;font-weight:800}.status.pass{background:#dcfce7;color:#166534}.status.fail{background:#fee2e2;color:#991b1b}table{border-collapse:collapse;width:100%;background:white;margin-top:1rem}td,th{border-bottom:1px solid #eee;padding:.75rem;text-align:left}.pass td{border-left:4px solid #16a34a}.fail td{border-left:4px solid #dc2626}code{background:#f3f4f6;padding:.15rem .3rem;border-radius:.3rem}</style></head><body><main>${links}<h1>Voice quality gates</h1><p class="status ${report.status}">${report.status}</p><p>${report.eventCount} event(s) checked.</p><table><thead><tr><th>Metric</th><th>Actual</th><th>Threshold</th><th>Status</th><th>Key</th></tr></thead><tbody>${rows}</tbody></table></main></body></html>`;
+};
+var createVoiceQualityRoutes = (options) => {
+  const path = options.path ?? "/quality";
+  const routes = new Elysia6({
+    name: options.name ?? "absolutejs-voice-quality"
+  });
+  const getReport = () => evaluateVoiceQuality({
+    events: options.events,
+    store: options.store,
+    thresholds: options.thresholds
+  });
+  routes.get(path, async () => {
+    const report = await getReport();
+    return new Response(renderVoiceQualityHTML(report, { links: options.links }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async () => getReport());
+  routes.get(`${path}/status`, async ({ set }) => {
+    const report = await getReport();
+    if (report.status === "fail") {
+      set.status = 503;
+    }
+    return report;
+  });
+  return routes;
+};
+
+// src/evalRoutes.ts
+var escapeHtml9 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var rate2 = (count, total) => count / Math.max(1, total);
+var normalizeSearchText = (value) => value.trim().toLowerCase();
+var getString6 = (value) => typeof value === "string" ? value : undefined;
+var getObject = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var getPathValue = (value, path) => {
+  let current = value;
+  for (const part of path.split(".").filter(Boolean)) {
+    const record = getObject(current);
+    if (!record || !(part in record)) {
+      return;
+    }
+    current = record[part];
+  }
+  return current;
+};
+var includesAll = (haystack, needles) => {
+  const normalized = normalizeSearchText(haystack);
+  return needles.filter((needle) => !normalized.includes(normalizeSearchText(needle)));
+};
+var sessionTime = (events) => {
+  const sorted = filterVoiceTraceEvents(events);
+  return {
+    endedAt: sorted.at(-1)?.at,
+    startedAt: sorted[0]?.at
+  };
+};
+var bucketKey = (timestamp) => new Date(timestamp).toISOString().slice(0, 10);
+var buildTrend = (sessions) => {
+  const buckets = new Map;
+  for (const session of sessions) {
+    const endedAt = session.endedAt ?? session.startedAt ?? session.quality.checkedAt;
+    const key = bucketKey(endedAt);
+    const bucket = buckets.get(key) ?? {
+      endedAt,
+      failed: 0,
+      key,
+      passed: 0,
+      total: 0
+    };
+    bucket.endedAt = Math.max(bucket.endedAt, endedAt);
+    bucket.total += 1;
+    if (session.status === "pass") {
+      bucket.passed += 1;
+    } else {
+      bucket.failed += 1;
+    }
+    buckets.set(key, bucket);
+  }
+  return [...buckets.values()].sort((left, right) => right.endedAt - left.endedAt);
+};
+var runVoiceSessionEvals = async (options = {}) => {
+  const events = filterVoiceTraceEvents(options.events ?? await options.store?.list() ?? []);
+  const grouped = new Map;
+  for (const event of events) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const sessions = await Promise.all([...grouped.entries()].map(async ([sessionId, sessionEvents]) => {
+    const sorted = filterVoiceTraceEvents(sessionEvents);
+    const quality = await evaluateVoiceQuality({
+      events: sorted,
+      thresholds: options.thresholds
+    });
+    const { endedAt, startedAt } = sessionTime(sorted);
+    const summary = summarizeVoiceTrace(sorted);
+    const scenarioId = sorted.find((event) => event.scenarioId)?.scenarioId;
+    return {
+      endedAt,
+      eventCount: sorted.length,
+      quality,
+      scenarioId,
+      sessionId,
+      startedAt,
+      status: quality.status,
+      summary
+    };
+  }));
+  const limitedSessions = sessions.sort((left, right) => (right.endedAt ?? right.startedAt ?? 0) - (left.endedAt ?? left.startedAt ?? 0)).slice(0, options.limit ?? 100);
+  const failed = limitedSessions.filter((session) => session.status === "fail").length;
+  const passed = limitedSessions.length - failed;
+  return {
+    checkedAt: Date.now(),
+    failed,
+    passed,
+    sessions: limitedSessions,
+    status: failed > 0 ? "fail" : "pass",
+    total: limitedSessions.length,
+    trend: buildTrend(limitedSessions)
+  };
+};
+var getSessionText = (events, type) => events.filter((event) => event.type === type).map((event) => getString6(event.payload.text)).filter((text) => Boolean(text?.trim())).join(`
+`);
+var countProviderErrors = (events) => events.filter((event) => event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.provider === "string")).length;
+var evaluateScenarioSession = (scenario, sessionId, events) => {
+  const issues = [];
+  const committedText = getSessionText(events, "turn.committed");
+  const assistantText = getSessionText(events, "turn.assistant");
+  const lifecycleTypes = events.filter((event) => event.type === "call.lifecycle").map((event) => getString6(event.payload.type)).filter((type) => Boolean(type));
+  const dispositions = events.filter((event) => event.type === "call.lifecycle").map((event) => getString6(event.payload.disposition)).filter((disposition) => Boolean(disposition));
+  const handoffActions = events.filter((event) => event.type === "call.handoff").map((event) => getString6(event.payload.action)).filter((action) => Boolean(action));
+  const turnCount = events.filter((event) => event.type === "turn.committed").length;
+  const sessionErrorCount = events.filter((event) => event.type === "session.error").length;
+  const providerErrorCount = countProviderErrors(events);
+  const workflowContractEvents = events.filter((event) => event.type === "workflow.contract");
+  for (const missing of includesAll(committedText, scenario.requiredTranscriptIncludes ?? [])) {
+    issues.push(`Missing transcript text: ${missing}`);
+  }
+  for (const missing of includesAll(assistantText, scenario.requiredAssistantIncludes ?? [])) {
+    issues.push(`Missing assistant text: ${missing}`);
+  }
+  for (const type of scenario.requiredLifecycleTypes ?? []) {
+    if (!lifecycleTypes.includes(type)) {
+      issues.push(`Missing lifecycle event: ${type}`);
+    }
+  }
+  for (const type of scenario.forbiddenLifecycleTypes ?? []) {
+    if (lifecycleTypes.includes(type)) {
+      issues.push(`Forbidden lifecycle event occurred: ${type}`);
+    }
+  }
+  for (const action of scenario.requiredHandoffActions ?? []) {
+    if (!handoffActions.includes(action)) {
+      issues.push(`Missing handoff action: ${action}`);
+    }
+  }
+  for (const action of scenario.forbiddenHandoffActions ?? []) {
+    if (handoffActions.includes(action)) {
+      issues.push(`Forbidden handoff action occurred: ${action}`);
+    }
+  }
+  if (scenario.requiredDisposition && !dispositions.includes(scenario.requiredDisposition)) {
+    issues.push(`Missing disposition: ${scenario.requiredDisposition}`);
+  }
+  if (scenario.minTurns !== undefined && turnCount < scenario.minTurns) {
+    issues.push(`Expected at least ${scenario.minTurns} turn(s), saw ${turnCount}.`);
+  }
+  if (scenario.maxSessionErrors !== undefined && sessionErrorCount > scenario.maxSessionErrors) {
+    issues.push(`Expected at most ${scenario.maxSessionErrors} session error(s), saw ${sessionErrorCount}.`);
+  }
+  if (scenario.maxProviderErrors !== undefined && providerErrorCount > scenario.maxProviderErrors) {
+    issues.push(`Expected at most ${scenario.maxProviderErrors} provider error(s), saw ${providerErrorCount}.`);
+  }
+  for (const path of scenario.requiredPayloadPaths ?? []) {
+    if (events.every((event) => getPathValue(event.payload, path) === undefined)) {
+      issues.push(`Missing payload path: ${path}`);
+    }
+  }
+  for (const contractId of scenario.requiredWorkflowContracts ?? []) {
+    const matching = workflowContractEvents.filter((event) => getString6(event.payload.contractId) === contractId);
+    if (matching.length === 0) {
+      issues.push(`Missing workflow contract: ${contractId}`);
+      continue;
+    }
+    if (matching.some((event) => getString6(event.payload.status) !== "pass")) {
+      issues.push(`Workflow contract failed: ${contractId}`);
+    }
+  }
+  return {
+    eventCount: events.length,
+    issues,
+    sessionId,
+    status: issues.length > 0 ? "fail" : "pass"
+  };
+};
+var runVoiceScenarioEvals = async (options = {}) => {
+  const scenarios = options.scenarios ?? [];
+  const events = filterVoiceTraceEvents(options.events ?? await options.store?.list() ?? []);
+  const grouped = new Map;
+  for (const event of events) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const results = scenarios.map((scenario) => {
+    const sessions = [...grouped.entries()].filter(([, sessionEvents]) => scenario.scenarioId ? sessionEvents.some((event) => event.scenarioId === scenario.scenarioId) : true).map(([sessionId, sessionEvents]) => evaluateScenarioSession(scenario, sessionId, filterVoiceTraceEvents(sessionEvents))).sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+    const issues = [];
+    const minSessions = scenario.minSessions ?? 1;
+    if (sessions.length < minSessions) {
+      issues.push(`Expected at least ${minSessions} matching session(s), saw ${sessions.length}.`);
+    }
+    const failed2 = sessions.filter((session) => session.status === "fail").length;
+    const passed2 = sessions.length - failed2;
+    return {
+      description: scenario.description,
+      failed: failed2,
+      id: scenario.id,
+      issues,
+      label: scenario.label ?? scenario.id,
+      matchedSessions: sessions.length,
+      passed: passed2,
+      sessions,
+      status: issues.length > 0 || failed2 > 0 ? "fail" : "pass"
+    };
+  });
+  const failed = results.filter((scenario) => scenario.status === "fail").length;
+  const passed = results.length - failed;
+  return {
+    checkedAt: Date.now(),
+    failed,
+    passed,
+    scenarios: results,
+    status: failed > 0 ? "fail" : "pass",
+    total: results.length
+  };
+};
+var resolveScenarioFixtures = async (options) => [...options.fixtures ?? [], ...await options.fixtureStore?.list() ?? []];
+var runVoiceScenarioFixtureEvals = async (options = {}) => {
+  const fixtures = await resolveScenarioFixtures(options);
+  const results = await Promise.all(fixtures.map(async (fixture) => {
+    const report = await runVoiceScenarioEvals({
+      events: fixture.events,
+      scenarios: options.scenarios
+    });
+    return {
+      description: fixture.description,
+      fixtureId: fixture.id,
+      label: fixture.label ?? fixture.id,
+      report,
+      status: report.status
+    };
+  }));
+  const failed = results.filter((fixture) => fixture.status === "fail").length;
+  const passed = results.length - failed;
+  return {
+    checkedAt: Date.now(),
+    failed,
+    fixtures: results,
+    passed,
+    status: failed > 0 ? "fail" : "pass",
+    total: results.length
+  };
+};
+var summarizeEvalBaseline = (report) => {
+  const failedSessionIds = report.sessions.filter((session) => session.status === "fail").map((session) => session.sessionId).sort();
+  return {
+    failed: report.failed,
+    failedSessionIds,
+    passRate: rate2(report.passed, report.total),
+    passed: report.passed,
+    total: report.total
+  };
+};
+var compareVoiceEvalBaseline = (currentReport, baselineReport, options = {}) => {
+  const baseline = summarizeEvalBaseline(baselineReport);
+  const current = summarizeEvalBaseline(currentReport);
+  const maxFailedDelta = options.maxFailedDelta ?? 0;
+  const maxPassRateDrop = options.maxPassRateDrop ?? 0;
+  const failOnNewFailedSessions = options.failOnNewFailedSessions ?? true;
+  const baselineFailed = new Set(baseline.failedSessionIds);
+  const currentFailed = new Set(current.failedSessionIds);
+  const newFailedSessionIds = current.failedSessionIds.filter((sessionId) => !baselineFailed.has(sessionId));
+  const recoveredSessionIds = baseline.failedSessionIds.filter((sessionId) => !currentFailed.has(sessionId));
+  const deltas = {
+    failed: current.failed - baseline.failed,
+    passRate: current.passRate - baseline.passRate,
+    passed: current.passed - baseline.passed,
+    total: current.total - baseline.total
+  };
+  const reasons = [];
+  if (deltas.failed > maxFailedDelta) {
+    reasons.push(`Failed sessions increased by ${deltas.failed}, above allowed delta ${maxFailedDelta}.`);
+  }
+  if (deltas.passRate < -maxPassRateDrop) {
+    reasons.push(`Pass rate dropped by ${Math.abs(deltas.passRate).toFixed(4)}, above allowed drop ${maxPassRateDrop}.`);
+  }
+  if (failOnNewFailedSessions && newFailedSessionIds.length > 0) {
+    reasons.push(`${newFailedSessionIds.length} session(s) failed that were not failing in the baseline.`);
+  }
+  return {
+    baseline,
+    checkedAt: Date.now(),
+    current,
+    deltas,
+    newFailedSessionIds,
+    recoveredSessionIds,
+    reasons,
+    status: reasons.length > 0 ? "fail" : "pass"
+  };
+};
+var createVoiceFileEvalBaselineStore = (filePath) => ({
+  get: async () => {
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      return;
+    }
+    const text = await file.text();
+    return text.trim() ? JSON.parse(text) : undefined;
+  },
+  set: async (report) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await Bun.write(filePath, JSON.stringify(report, null, 2));
+  }
+});
+var createVoiceFileScenarioFixtureStore = (filePath) => ({
+  list: async () => {
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      return [];
+    }
+    const text = await file.text();
+    if (!text.trim()) {
+      return [];
+    }
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : parsed.fixtures ?? [];
+  }
+});
+var formatTime = (value) => value === undefined ? "unknown" : new Date(value).toLocaleString();
+var formatPercent = (value) => `${(value * 100).toFixed(2)}%`;
+var renderVoiceEvalHTML = (report, options = {}) => {
+  const title = options.title ?? "AbsoluteJS Voice Evals";
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml9(link.href)}">${escapeHtml9(link.label)}</a>`).join("")}</nav>` : "";
+  const trend = report.trend.length ? report.trend.map((bucket) => `<tr><td>${escapeHtml9(bucket.key)}</td><td>${bucket.total}</td><td>${bucket.passed}</td><td>${bucket.failed}</td></tr>`).join("") : '<tr><td colspan="4">No eval buckets yet.</td></tr>';
+  const sessions = report.sessions.length ? report.sessions.map((session) => {
+    const failedMetrics = Object.entries(session.quality.metrics).filter(([, metric]) => !metric.pass).map(([, metric]) => metric.label).join(", ");
+    return `<tr class="${session.status}"><td>${escapeHtml9(session.sessionId)}</td><td>${escapeHtml9(session.status)}</td><td>${session.eventCount}</td><td>${session.summary.turnCount}</td><td>${session.summary.errorCount}</td><td>${escapeHtml9(formatTime(session.endedAt))}</td><td>${escapeHtml9(failedMetrics || "none")}</td></tr>`;
+  }).join("") : '<tr><td colspan="7">No sessions found.</td></tr>';
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml9(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1180px;margin:auto}nav{display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:1rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;font-weight:800;padding:.35rem .75rem}.pass{color:#166534}.fail{color:#991b1b}.status.pass{background:#dcfce7}.status.fail{background:#fee2e2}.grid{display:grid;gap:1rem;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));margin:1rem 0}.card{background:white;border:1px solid #e7e5e4;border-radius:1rem;padding:1rem}.card strong{display:block;font-size:2rem}table{border-collapse:collapse;background:white;width:100%;margin:1rem 0 2rem}td,th{border-bottom:1px solid #eee;padding:.75rem;text-align:left}tr.fail td{border-left:4px solid #dc2626}tr.pass td{border-left:4px solid #16a34a}</style></head><body><main>${links}<h1>${escapeHtml9(title)}</h1><p class="status ${report.status}">${report.status}</p><div class="grid"><article class="card"><span>Total</span><strong>${report.total}</strong></article><article class="card"><span>Passed</span><strong>${report.passed}</strong></article><article class="card"><span>Failed</span><strong>${report.failed}</strong></article></div><h2>Trend</h2><table><thead><tr><th>Day</th><th>Total</th><th>Passed</th><th>Failed</th></tr></thead><tbody>${trend}</tbody></table><h2>Session Eval Results</h2><table><thead><tr><th>Session</th><th>Status</th><th>Events</th><th>Turns</th><th>Errors</th><th>Last event</th><th>Failed metrics</th></tr></thead><tbody>${sessions}</tbody></table></main></body></html>`;
+};
+var renderVoiceEvalBaselineHTML = (comparison, options = {}) => {
+  const title = options.title ?? "AbsoluteJS Voice Eval Baseline";
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml9(link.href)}">${escapeHtml9(link.label)}</a>`).join("")}</nav>` : "";
+  const reasons = comparison.reasons.length ? comparison.reasons.map((reason) => `<li>${escapeHtml9(reason)}</li>`).join("") : "<li>No baseline regressions detected.</li>";
+  const newFailures = comparison.newFailedSessionIds.length ? comparison.newFailedSessionIds.map((id) => `<li>${escapeHtml9(id)}</li>`).join("") : "<li>none</li>";
+  const recovered = comparison.recoveredSessionIds.length ? comparison.recoveredSessionIds.map((id) => `<li>${escapeHtml9(id)}</li>`).join("") : "<li>none</li>";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml9(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1000px;margin:auto}nav{display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:1rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;font-weight:800;padding:.35rem .75rem}.pass{background:#dcfce7;color:#166534}.fail{background:#fee2e2;color:#991b1b}.grid{display:grid;gap:1rem;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));margin:1rem 0}.card{background:white;border:1px solid #e7e5e4;border-radius:1rem;padding:1rem}.card strong{display:block;font-size:2rem}section{background:white;border:1px solid #e7e5e4;border-radius:1rem;margin:1rem 0;padding:1rem}</style></head><body><main>${links}<h1>${escapeHtml9(title)}</h1><p class="status ${comparison.status}">${comparison.status}</p><div class="grid"><article class="card"><span>Baseline pass rate</span><strong>${escapeHtml9(formatPercent(comparison.baseline.passRate))}</strong></article><article class="card"><span>Current pass rate</span><strong>${escapeHtml9(formatPercent(comparison.current.passRate))}</strong></article><article class="card"><span>Failed delta</span><strong>${comparison.deltas.failed}</strong></article><article class="card"><span>Pass rate delta</span><strong>${escapeHtml9(formatPercent(comparison.deltas.passRate))}</strong></article></div><section><h2>Regression Reasons</h2><ul>${reasons}</ul></section><section><h2>New Failed Sessions</h2><ul>${newFailures}</ul></section><section><h2>Recovered Sessions</h2><ul>${recovered}</ul></section></main></body></html>`;
+};
+var renderVoiceScenarioEvalHTML = (report, options = {}) => {
+  const title = options.title ?? "AbsoluteJS Voice Scenario Evals";
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml9(link.href)}">${escapeHtml9(link.label)}</a>`).join("")}</nav>` : "";
+  const scenarios = report.scenarios.length ? report.scenarios.map((scenario) => {
+    const scenarioIssues = scenario.issues.length ? `<ul>${scenario.issues.map((issue) => `<li>${escapeHtml9(issue)}</li>`).join("")}</ul>` : "";
+    const sessions = scenario.sessions.length ? scenario.sessions.map((session) => `<tr class="${session.status}"><td>${escapeHtml9(session.sessionId)}</td><td>${escapeHtml9(session.status)}</td><td>${session.eventCount}</td><td>${escapeHtml9(session.issues.join(", ") || "none")}</td></tr>`).join("") : '<tr><td colspan="4">No matching sessions.</td></tr>';
+    return `<section class="scenario ${scenario.status}"><h2>${escapeHtml9(scenario.label)}</h2>${scenario.description ? `<p>${escapeHtml9(scenario.description)}</p>` : ""}<p class="status ${scenario.status}">${scenario.status}</p><p>${scenario.passed} passed, ${scenario.failed} failed, ${scenario.matchedSessions} matched.</p>${scenarioIssues}<table><thead><tr><th>Session</th><th>Status</th><th>Events</th><th>Issues</th></tr></thead><tbody>${sessions}</tbody></table></section>`;
+  }).join("") : "<section><p>No scenarios configured.</p></section>";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml9(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1180px;margin:auto}nav{display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:1rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;font-weight:800;padding:.35rem .75rem}.status.pass{background:#dcfce7;color:#166534}.status.fail{background:#fee2e2;color:#991b1b}.grid{display:grid;gap:1rem;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));margin:1rem 0}.card,section{background:white;border:1px solid #e7e5e4;border-radius:1rem;padding:1rem}.card strong{display:block;font-size:2rem}section{margin:1rem 0}table{border-collapse:collapse;width:100%;margin-top:1rem}td,th{border-bottom:1px solid #eee;padding:.75rem;text-align:left}tr.fail td{border-left:4px solid #dc2626}tr.pass td{border-left:4px solid #16a34a}</style></head><body><main>${links}<h1>${escapeHtml9(title)}</h1><p class="status ${report.status}">${report.status}</p><div class="grid"><article class="card"><span>Total</span><strong>${report.total}</strong></article><article class="card"><span>Passed</span><strong>${report.passed}</strong></article><article class="card"><span>Failed</span><strong>${report.failed}</strong></article></div>${scenarios}</main></body></html>`;
+};
+var renderVoiceScenarioFixtureEvalHTML = (report, options = {}) => {
+  const title = options.title ?? "AbsoluteJS Voice Fixture Evals";
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml9(link.href)}">${escapeHtml9(link.label)}</a>`).join("")}</nav>` : "";
+  const fixtures = report.fixtures.length ? report.fixtures.map((fixture) => {
+    const scenarios = fixture.report.scenarios.map((scenario) => `<tr class="${scenario.status}"><td>${escapeHtml9(scenario.label)}</td><td>${escapeHtml9(scenario.status)}</td><td>${scenario.matchedSessions}</td><td>${escapeHtml9([...scenario.issues, ...scenario.sessions.flatMap((session) => session.issues)].join(", ") || "none")}</td></tr>`).join("");
+    return `<section class="${fixture.status}"><h2>${escapeHtml9(fixture.label)}</h2>${fixture.description ? `<p>${escapeHtml9(fixture.description)}</p>` : ""}<p class="status ${fixture.status}">${fixture.status}</p><table><thead><tr><th>Scenario</th><th>Status</th><th>Sessions</th><th>Issues</th></tr></thead><tbody>${scenarios}</tbody></table></section>`;
+  }).join("") : "<section><p>No scenario fixtures configured.</p></section>";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml9(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1180px;margin:auto}nav{display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:1rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;font-weight:800;padding:.35rem .75rem}.status.pass{background:#dcfce7;color:#166534}.status.fail{background:#fee2e2;color:#991b1b}.grid{display:grid;gap:1rem;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));margin:1rem 0}.card,section{background:white;border:1px solid #e7e5e4;border-radius:1rem;padding:1rem}.card strong{display:block;font-size:2rem}section{margin:1rem 0}table{border-collapse:collapse;width:100%;margin-top:1rem}td,th{border-bottom:1px solid #eee;padding:.75rem;text-align:left}tr.fail td{border-left:4px solid #dc2626}tr.pass td{border-left:4px solid #16a34a}</style></head><body><main>${links}<h1>${escapeHtml9(title)}</h1><p class="status ${report.status}">${report.status}</p><div class="grid"><article class="card"><span>Total</span><strong>${report.total}</strong></article><article class="card"><span>Passed</span><strong>${report.passed}</strong></article><article class="card"><span>Failed</span><strong>${report.failed}</strong></article></div>${fixtures}</main></body></html>`;
+};
+var createVoiceEvalRoutes = (options) => {
+  const path = options.path ?? "/evals";
+  const routes = new Elysia7({
+    name: options.name ?? "absolutejs-voice-evals"
+  });
+  const getReport = () => runVoiceSessionEvals({
+    events: options.events,
+    limit: options.limit,
+    store: options.store,
+    thresholds: options.thresholds
+  });
+  const getBaseline = async () => typeof options.baseline === "function" ? options.baseline() : options.baseline ?? await options.baselineStore?.get();
+  const getBaselineComparison = async () => {
+    const [current, baseline] = await Promise.all([getReport(), getBaseline()]);
+    return baseline ? compareVoiceEvalBaseline(current, baseline, options.baselineComparison) : undefined;
+  };
+  const getScenarioReport = () => runVoiceScenarioEvals({
+    events: options.events,
+    scenarios: options.scenarios,
+    store: options.store
+  });
+  const getFixtureReport = () => runVoiceScenarioFixtureEvals({
+    fixtures: options.fixtures,
+    fixtureStore: options.fixtureStore,
+    scenarios: options.scenarios
+  });
+  routes.get(path, async () => {
+    const report = await getReport();
+    return new Response(renderVoiceEvalHTML(report, {
+      links: options.links,
+      title: options.title
+    }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async () => getReport());
+  routes.get(`${path}/status`, async ({ set }) => {
+    const report = await getReport();
+    if (report.status === "fail") {
+      set.status = 503;
+    }
+    return report;
+  });
+  routes.get(`${path}/baseline`, async ({ set }) => {
+    const comparison = await getBaselineComparison();
+    if (!comparison) {
+      set.status = 404;
+      return Response.json({ error: "No voice eval baseline found." });
+    }
+    return new Response(renderVoiceEvalBaselineHTML(comparison, {
+      links: options.links,
+      title: `${options.title ?? "AbsoluteJS Voice Evals"} Baseline`
+    }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/baseline/json`, async ({ set }) => {
+    const comparison = await getBaselineComparison();
+    if (!comparison) {
+      set.status = 404;
+      return { error: "No voice eval baseline found." };
+    }
+    return comparison;
+  });
+  routes.get(`${path}/baseline/status`, async ({ set }) => {
+    const comparison = await getBaselineComparison();
+    if (!comparison) {
+      set.status = 404;
+      return { error: "No voice eval baseline found." };
+    }
+    if (comparison.status === "fail") {
+      set.status = 503;
+    }
+    return comparison;
+  });
+  routes.post(`${path}/baseline`, async ({ set }) => {
+    if (!options.baselineStore) {
+      set.status = 501;
+      return { error: "No voice eval baseline store configured." };
+    }
+    const report = await getReport();
+    await options.baselineStore.set(report);
+    return {
+      baseline: report,
+      status: "saved"
+    };
+  });
+  routes.get(`${path}/scenarios`, async () => {
+    const report = await getScenarioReport();
+    return new Response(renderVoiceScenarioEvalHTML(report, {
+      links: options.links,
+      title: `${options.title ?? "AbsoluteJS Voice Evals"} Scenarios`
+    }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/scenarios/json`, async () => getScenarioReport());
+  routes.get(`${path}/scenarios/status`, async ({ set }) => {
+    const report = await getScenarioReport();
+    if (report.status === "fail") {
+      set.status = 503;
+    }
+    return report;
+  });
+  routes.get(`${path}/fixtures`, async () => {
+    const report = await getFixtureReport();
+    return new Response(renderVoiceScenarioFixtureEvalHTML(report, {
+      links: options.links,
+      title: `${options.title ?? "AbsoluteJS Voice Evals"} Fixtures`
+    }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/fixtures/json`, async () => getFixtureReport());
+  routes.get(`${path}/fixtures/status`, async ({ set }) => {
+    const report = await getFixtureReport();
+    if (report.status === "fail") {
+      set.status = 503;
+    }
+    return report;
+  });
+  return routes;
+};
+
+// src/opsConsoleRoutes.ts
+import { Elysia as Elysia10 } from "elysia";
+
+// src/resilienceRoutes.ts
+import { Elysia as Elysia8 } from "elysia";
+var escapeHtml10 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString7 = (value) => typeof value === "string" ? value : undefined;
+var getNumber4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getBoolean2 = (value) => value === true;
+var isProviderStatus2 = (value) => value === "error" || value === "fallback" || value === "success";
+var listVoiceRoutingEvents = (events) => {
+  const routingEvents = [];
+  for (const event of events) {
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = getString7(event.payload.provider);
+    const providerStatus = isProviderStatus2(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    if (!provider || !providerStatus) {
+      continue;
+    }
+    const kind = getString7(event.payload.kind);
+    routingEvents.push({
+      at: event.at,
+      attempt: getNumber4(event.payload.attempt),
+      elapsedMs: getNumber4(event.payload.elapsedMs),
+      error: getString7(event.payload.error),
+      fallbackProvider: getString7(event.payload.fallbackProvider),
+      kind: kind === "stt" || kind === "tts" ? kind : "llm",
+      latencyBudgetMs: getNumber4(event.payload.latencyBudgetMs),
+      operation: getString7(event.payload.operation),
+      provider,
+      routing: getString7(event.payload.routing),
+      selectedProvider: getString7(event.payload.selectedProvider),
+      sessionId: event.sessionId,
+      status: providerStatus,
+      suppressionRemainingMs: getNumber4(event.payload.suppressionRemainingMs),
+      timedOut: getBoolean2(event.payload.timedOut),
+      turnId: event.turnId
+    });
+  }
+  return routingEvents.sort((left, right) => right.at - left.at);
+};
+var summarizeVoiceRoutingDecision = (events, options = {}) => {
+  const routingEvents = listVoiceRoutingEvents(events).filter((event) => {
+    if (options.kind && event.kind !== options.kind) {
+      return false;
+    }
+    if (options.sessionId && event.sessionId !== options.sessionId) {
+      return false;
+    }
+    return true;
+  });
+  const limited = typeof options.limit === "number" && options.limit >= 0 ? routingEvents.slice(0, options.limit) : routingEvents;
+  return limited[0] ?? null;
+};
+var createVoiceRoutingDecisionSummary = async (options) => {
+  const events = await options.store.list({
+    sessionId: options.sessionId,
+    type: "session.error"
+  });
+  return summarizeVoiceRoutingDecision(events, options);
+};
+var summarizeRoutingEvents = (events) => {
+  const byKind = new Map;
+  let errors = 0;
+  let fallbacks = 0;
+  let timeouts = 0;
+  for (const event of events) {
+    byKind.set(event.kind, (byKind.get(event.kind) ?? 0) + 1);
+    if (event.status === "error") {
+      errors += 1;
+    }
+    if (event.status === "fallback") {
+      fallbacks += 1;
+    }
+    if (event.timedOut) {
+      timeouts += 1;
+    }
+  }
+  return {
+    byKind,
+    errors,
+    fallbacks,
+    timeouts,
+    total: events.length
+  };
+};
+var renderProviderCards = (title, providers) => {
+  if (providers.length === 0) {
+    return `<p class="muted">No ${escapeHtml10(title)} provider health yet.</p>`;
+  }
+  return `<div class="provider-grid">${providers.map((provider) => `
+        <article class="card provider ${escapeHtml10(provider.status)}">
+          <div class="card-header">
+            <strong>${escapeHtml10(provider.provider)}</strong>
+            <span>${escapeHtml10(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>
+          </div>
+          <dl>
+            <div><dt>Runs</dt><dd>${provider.runCount}</dd></div>
+            <div><dt>Avg latency</dt><dd>${provider.averageElapsedMs ?? 0}ms</dd></div>
+            <div><dt>Errors</dt><dd>${provider.errorCount}</dd></div>
+            <div><dt>Timeouts</dt><dd>${provider.timeoutCount}</dd></div>
+            <div><dt>Fallbacks</dt><dd>${provider.fallbackCount}</dd></div>
+          </dl>
+          ${provider.lastError ? `<p class="muted">${escapeHtml10(provider.lastError)}</p>` : ""}
+        </article>
+      `).join("")}</div>`;
+};
+var renderTimeline2 = (events) => {
+  if (events.length === 0) {
+    return '<p class="muted">No provider routing events yet. Run the app or simulate provider failover.</p>';
+  }
+  return `<div class="timeline">${events.slice(0, 40).map((event) => `
+        <article class="card event ${escapeHtml10(event.status ?? "unknown")}">
+          <div class="card-header">
+            <strong>${escapeHtml10(event.kind.toUpperCase())} ${escapeHtml10(event.operation ?? "generate")}</strong>
+            <span>${new Date(event.at).toLocaleString()}</span>
+          </div>
+          <p>
+            <span class="pill">${escapeHtml10(event.status ?? "unknown")}</span>
+            <span class="pill">provider: ${escapeHtml10(event.provider ?? "unknown")}</span>
+            ${event.fallbackProvider ? `<span class="pill">fallback: ${escapeHtml10(event.fallbackProvider)}</span>` : ""}
+            ${event.timedOut ? '<span class="pill danger">timed out</span>' : ""}
+          </p>
+          <dl>
+            <div><dt>Attempt</dt><dd>${event.attempt ?? 0}</dd></div>
+            <div><dt>Elapsed</dt><dd>${event.elapsedMs ?? 0}ms</dd></div>
+            <div><dt>Budget</dt><dd>${event.latencyBudgetMs ?? 0}ms</dd></div>
+            <div><dt>Session</dt><dd>${escapeHtml10(event.sessionId)}</dd></div>
+          </dl>
+          ${event.error ? `<p class="muted">${escapeHtml10(event.error)}</p>` : ""}
+        </article>
+      `).join("")}</div>`;
+};
+var renderSimulationControls = (kind, simulation) => {
+  if (!simulation) {
+    return "";
+  }
+  const configuredProviders = simulation.providers.filter((provider) => provider.configured !== false);
+  if (configuredProviders.length === 0) {
+    return `<p class="muted">No ${kind.toUpperCase()} providers are configured for simulation.</p>`;
+  }
+  const pathPrefix = simulation.pathPrefix ?? `/api/${kind}-simulate`;
+  const failureProviders = simulation.failureProviders ?? configuredProviders.map(({ provider }) => provider);
+  const canFail = (provider) => configuredProviders.some((entry) => entry.provider === provider) && (!simulation.fallbackRequiredProvider || configuredProviders.some((entry) => entry.provider === simulation.fallbackRequiredProvider));
+  return `<div class="simulate-panel" data-sim-kind="${kind}" data-sim-prefix="${escapeHtml10(pathPrefix)}">
+    <p class="muted">${escapeHtml10(simulation.failureMessage ?? `Simulate ${kind.toUpperCase()} provider failure without changing provider credentials.`)}</p>
+    <div class="simulate-actions">
+      ${failureProviders.map((provider) => `<button type="button" data-provider-fail="${escapeHtml10(provider)}"${canFail(provider) ? "" : " disabled"}>Simulate ${escapeHtml10(provider)} ${kind.toUpperCase()} failure</button>`).join("")}
+      ${configuredProviders.map((provider) => `<button type="button" data-provider-recover="${escapeHtml10(provider.provider)}">Mark ${escapeHtml10(provider.provider)} recovered</button>`).join("")}
+    </div>
+    ${simulation.fallbackRequiredProvider && !configuredProviders.some((entry) => entry.provider === simulation.fallbackRequiredProvider) ? `<p class="muted">${escapeHtml10(simulation.fallbackRequiredMessage ?? `Configure ${simulation.fallbackRequiredProvider} to enable fallback simulation.`)}</p>` : ""}
+    <pre class="simulate-output" hidden></pre>
+  </div>`;
+};
+var renderVoiceResilienceHTML = (input) => {
+  const summary = summarizeRoutingEvents(input.routingEvents);
+  const kindCounts = [...summary.byKind.entries()].map(([kind, count]) => `<span class="pill">${escapeHtml10(kind)}: ${String(count)}</span>`).join("");
+  const links = input.links?.length ? input.links.map((link) => `<a href="${escapeHtml10(link.href)}">${escapeHtml10(link.label)}</a>`).join(" \xB7 ") : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml10(input.title ?? "AbsoluteJS Voice Resilience")}</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { background: radial-gradient(circle at top left, #172554, #09090b 36%, #050505); color: #f4f4f5; font-family: ui-sans-serif, system-ui, sans-serif; margin: 0; padding: 24px; }
+    main { display: grid; gap: 16px; margin: 0 auto; max-width: 1180px; }
+    section, .card { background: rgba(19, 22, 27, 0.92); border: 1px solid #27272a; border-radius: 20px; padding: 20px; }
+    .hero { background: linear-gradient(135deg, rgba(14, 165, 233, 0.18), rgba(245, 158, 11, 0.12)); }
+    .grid, .provider-grid { display: grid; gap: 14px; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+    .timeline { display: grid; gap: 12px; }
+    .card-header { align-items: center; display: flex; gap: 12px; justify-content: space-between; }
+    .card-header strong { font-size: 1.05rem; }
+    .metric strong { display: block; font-size: 2rem; margin-top: 6px; }
+    .muted, dt, span { color: #a1a1aa; }
+    dl { display: grid; gap: 8px; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+    dl div { background: #0f1217; border: 1px solid #27272a; border-radius: 12px; padding: 10px; }
+    dd { font-weight: 800; margin: 4px 0 0; }
+    .pill { background: #0f1217; border: 1px solid #3f3f46; border-radius: 999px; color: #d4d4d8; display: inline-flex; margin: 3px 4px 3px 0; padding: 5px 9px; }
+    .danger { border-color: rgba(239, 68, 68, 0.75); color: #fecaca; }
+    .event.error { border-color: rgba(239, 68, 68, 0.7); }
+    .event.fallback { border-color: rgba(245, 158, 11, 0.7); }
+    .event.success, .provider.healthy { border-color: rgba(34, 197, 94, 0.5); }
+    .provider.suppressed, .provider.degraded, .provider.rate-limited { border-color: rgba(239, 68, 68, 0.7); }
+    .provider.recoverable { border-color: rgba(59, 130, 246, 0.7); }
+    button { background: #f59e0b; border: 0; border-radius: 999px; color: #111827; cursor: pointer; font-weight: 800; padding: 10px 14px; }
+    button:disabled { cursor: not-allowed; opacity: 0.45; }
+    .simulate-actions { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 12px; }
+    .simulate-output { background: #050505; border: 1px solid #27272a; border-radius: 14px; color: #d4d4d8; overflow: auto; padding: 12px; white-space: pre-wrap; }
+    a { color: #f59e0b; }
+    @media (max-width: 850px) { .grid, .provider-grid, dl { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <main>
+    <section class="hero">
+      <h1>Provider routing and resilience</h1>
+      <p>One view for the production reliability story: LLM failover, STT/TTS routing, latency budgets, timeouts, and fallback decisions.</p>
+      ${links ? `<p>${links}</p>` : ""}
+      <p>${kindCounts || '<span class="pill">No routing events yet</span>'}</p>
+    </section>
+    <section class="grid">
+      <article class="card metric"><span>Total routing events</span><strong>${summary.total}</strong></article>
+      <article class="card metric"><span>Fallbacks</span><strong>${summary.fallbacks}</strong></article>
+      <article class="card metric"><span>Errors</span><strong>${summary.errors}</strong></article>
+      <article class="card metric"><span>Timeouts</span><strong>${summary.timeouts}</strong></article>
+    </section>
+    <section>
+      <h2>LLM provider health</h2>
+      ${renderProviderCards("LLM", input.llmProviderHealth)}
+    </section>
+    <section>
+      <h2>STT provider health</h2>
+      ${renderSimulationControls("stt", input.sttSimulation)}
+      ${renderProviderCards("STT", input.sttProviderHealth)}
+    </section>
+    <section>
+      <h2>TTS provider health</h2>
+      ${renderSimulationControls("tts", input.ttsSimulation)}
+      ${renderProviderCards("TTS", input.ttsProviderHealth)}
+    </section>
+    <section>
+      <h2>Routing timeline</h2>
+      ${renderTimeline2(input.routingEvents)}
+    </section>
+  </main>
+  <script>
+    const showResult = (panel, result) => {
+      const output = panel.querySelector(".simulate-output");
+      if (!output) return;
+      output.hidden = false;
+      output.textContent = JSON.stringify(result, null, 2);
+    };
+    document.querySelectorAll("[data-sim-prefix]").forEach((panel) => {
+      const prefix = panel.getAttribute("data-sim-prefix");
+      panel.querySelectorAll("[data-provider-fail]").forEach((button) => {
+        button.addEventListener("click", async () => {
+          const provider = button.getAttribute("data-provider-fail");
+          const response = await fetch(prefix + "/failure?provider=" + encodeURIComponent(provider || ""), { method: "POST" });
+          showResult(panel, await response.json());
+          if (response.ok) window.setTimeout(() => window.location.reload(), 450);
+        });
+      });
+      panel.querySelectorAll("[data-provider-recover]").forEach((button) => {
+        button.addEventListener("click", async () => {
+          const provider = button.getAttribute("data-provider-recover");
+          const response = await fetch(prefix + "/recovery?provider=" + encodeURIComponent(provider || ""), { method: "POST" });
+          showResult(panel, await response.json());
+          if (response.ok) window.setTimeout(() => window.location.reload(), 450);
+        });
+      });
+    });
+  </script>
+</body>
+</html>`;
+};
+var providerFromQuery = (value, providers) => typeof value === "string" && providers.some((provider) => provider.provider === value && provider.configured !== false) ? value : undefined;
+var registerSimulationRoutes = (routes, simulation, defaultPathPrefix) => {
+  if (!simulation) {
+    return routes;
+  }
+  const pathPrefix = simulation.pathPrefix ?? defaultPathPrefix;
+  routes.post(`${pathPrefix}/failure`, async ({ query, set }) => {
+    const provider = providerFromQuery(query.provider, simulation.providers);
+    if (!provider) {
+      set.status = 400;
+      return {
+        error: "Provider is not configured for simulation."
+      };
+    }
+    if (simulation.failureProviders && !simulation.failureProviders.includes(provider)) {
+      set.status = 400;
+      return {
+        error: `${provider} is not configured for failure simulation.`
+      };
+    }
+    if (simulation.fallbackRequiredProvider && !simulation.providers.some((entry) => entry.provider === simulation.fallbackRequiredProvider && entry.configured !== false)) {
+      set.status = 400;
+      return {
+        error: simulation.fallbackRequiredMessage ?? `Configure ${simulation.fallbackRequiredProvider} before simulating fallback.`
+      };
+    }
+    return simulation.run(provider, "failure");
+  });
+  routes.post(`${pathPrefix}/recovery`, async ({ query, set }) => {
+    const provider = providerFromQuery(query.provider, simulation.providers);
+    if (!provider) {
+      set.status = 400;
+      return {
+        error: "Provider is not configured for simulation."
+      };
+    }
+    return simulation.run(provider, "recovery");
+  });
+  return routes;
+};
+var createVoiceResilienceRoutes = (options) => {
+  const path = options.path ?? "/resilience";
+  const routes = new Elysia8({
+    name: options.name ?? "absolutejs-voice-resilience"
+  }).get(path, async () => {
+    const events = await options.store.list();
+    const sttEvents = events.filter((event) => event.payload.kind === "stt");
+    const ttsEvents = events.filter((event) => event.payload.kind === "tts");
+    const data = {
+      links: options.links,
+      llmProviderHealth: await summarizeVoiceProviderHealth({
+        events,
+        providers: options.llmProviders ?? []
+      }),
+      routingEvents: listVoiceRoutingEvents(events),
+      sttProviderHealth: await summarizeVoiceProviderHealth({
+        events: sttEvents,
+        providers: options.sttProviders ?? []
+      }),
+      sttSimulation: options.sttSimulation,
+      title: options.title,
+      ttsProviderHealth: await summarizeVoiceProviderHealth({
+        events: ttsEvents,
+        providers: options.ttsProviders ?? []
+      }),
+      ttsSimulation: options.ttsSimulation
+    };
+    const body = await (options.render ?? renderVoiceResilienceHTML)(data);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  registerSimulationRoutes(routes, options.sttSimulation, "/api/stt-simulate");
+  registerSimulationRoutes(routes, options.ttsSimulation, "/api/tts-simulate");
+  return routes;
+};
+
+// src/sessionReplay.ts
+import { Elysia as Elysia9 } from "elysia";
+var getString8 = (value) => typeof value === "string" ? value : undefined;
+var escapeHtml11 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var increment3 = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+var buildReplayTurns = (events) => {
+  const turns = new Map;
+  const getTurn = (turnId) => {
+    const existing = turns.get(turnId);
+    if (existing) {
+      return existing;
+    }
+    const turn = {
+      assistantReplies: [],
+      errors: [],
+      id: turnId,
+      modelCalls: [],
+      tools: [],
+      transcripts: []
+    };
+    turns.set(turnId, turn);
+    return turn;
+  };
+  for (const event of events) {
+    const turnId = event.turnId ?? "session";
+    const turn = getTurn(turnId);
+    switch (event.type) {
+      case "turn.transcript":
+        turn.transcripts.push({
+          isFinal: event.payload.isFinal === true,
+          text: getString8(event.payload.text)
+        });
+        break;
+      case "turn.committed":
+        turn.committedText = getString8(event.payload.text);
+        break;
+      case "turn.assistant": {
+        const text = getString8(event.payload.text);
+        if (text) {
+          turn.assistantReplies.push(text);
+        }
+        break;
+      }
+      case "agent.model":
+      case "assistant.run":
+        turn.modelCalls.push(event.payload);
+        break;
+      case "agent.tool":
+        turn.tools.push(event.payload);
+        break;
+      case "session.error":
+        turn.errors.push(event.payload);
+        break;
+    }
+  }
+  return [...turns.values()];
+};
+var summarizeVoiceSessionReplay = async (options) => {
+  const sourceEvents = options.events ?? await options.store?.list({ sessionId: options.sessionId }) ?? [];
+  const events = filterVoiceTraceEvents(sourceEvents, {
+    sessionId: options.sessionId
+  });
+  const replay = buildVoiceTraceReplay(events, {
+    evaluation: options.evaluation,
+    redact: options.redact,
+    title: options.title ?? `Voice Session ${options.sessionId}`
+  });
+  const startedAt = replay.summary.startedAt;
+  return {
+    evaluation: replay.evaluation,
+    events,
+    html: replay.html,
+    markdown: replay.markdown,
+    sessionId: options.sessionId,
+    summary: replay.summary,
+    timeline: events.map((event) => ({
+      at: event.at,
+      offsetMs: startedAt === undefined ? undefined : Math.max(0, event.at - startedAt),
+      payload: event.payload,
+      turnId: event.turnId,
+      type: event.type
+    })),
+    turns: buildReplayTurns(events)
+  };
+};
+var summarizeVoiceSessions = async (options = {}) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  const grouped = new Map;
+  for (const event of events) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const sessions = [...grouped.entries()].map(([sessionId, sessionEvents]) => {
+    const sorted = filterVoiceTraceEvents(sessionEvents);
+    const summary = buildVoiceTraceReplay(sorted, {
+      evaluation: {
+        requireAssistantReply: false,
+        requireCompletedCall: false,
+        requireTranscript: false,
+        requireTurn: false
+      }
+    }).summary;
+    const providerErrors = {};
+    const providers = new Set;
+    let latestOutcome;
+    let errorCount = 0;
+    for (const event of sorted) {
+      const provider = getString8(event.payload.provider);
+      if (provider) {
+        providers.add(provider);
+      }
+      if (event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string")) {
+        errorCount += 1;
+        increment3(providerErrors, provider ?? "unknown");
+      }
+      const outcome = getString8(event.payload.outcome);
+      if (outcome) {
+        latestOutcome = outcome;
+      }
+    }
+    const item = {
+      endedAt: summary.endedAt,
+      errorCount,
+      eventCount: summary.eventCount,
+      latestOutcome,
+      providerErrors,
+      providers: [...providers].sort(),
+      sessionId,
+      startedAt: summary.startedAt,
+      status: errorCount > 0 ? "failed" : "healthy",
+      transcriptCount: summary.transcriptCount,
+      turnCount: summary.turnCount
+    };
+    const replayHref = options.replayHref === false ? "" : typeof options.replayHref === "function" ? options.replayHref(item) : `${options.replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(sessionId)}/replay/htmx`;
+    return {
+      ...item,
+      replayHref
+    };
+  });
+  const search = options.q?.trim().toLowerCase();
+  return sessions.filter((session) => {
+    if (options.status && options.status !== "all" && session.status !== options.status) {
+      return false;
+    }
+    if (options.provider && !session.providers.includes(options.provider)) {
+      return false;
+    }
+    if (!search) {
+      return true;
+    }
+    return [
+      session.sessionId,
+      session.latestOutcome,
+      session.status,
+      ...session.providers
+    ].some((value) => value?.toLowerCase().includes(search));
+  }).sort((left, right) => (right.endedAt ?? right.startedAt ?? 0) - (left.endedAt ?? left.startedAt ?? 0)).slice(0, options.limit ?? 50);
+};
+var renderVoiceSessionsHTML = (sessions) => sessions.length === 0 ? '<p class="voice-sessions-empty">No voice sessions found.</p>' : [
+  '<div class="voice-sessions-list">',
+  ...sessions.map((session) => [
+    `<article class="voice-session-card ${escapeHtml11(session.status)}">`,
+    '<div class="voice-session-card-header">',
+    `<strong>${escapeHtml11(session.sessionId)}</strong>`,
+    `<span>${escapeHtml11(session.status)}</span>`,
+    "</div>",
+    "<dl>",
+    `<div><dt>Events</dt><dd>${String(session.eventCount)}</dd></div>`,
+    `<div><dt>Turns</dt><dd>${String(session.turnCount)}</dd></div>`,
+    `<div><dt>Transcripts</dt><dd>${String(session.transcriptCount)}</dd></div>`,
+    `<div><dt>Errors</dt><dd>${String(session.errorCount)}</dd></div>`,
+    "</dl>",
+    session.latestOutcome ? `<p>Outcome: ${escapeHtml11(session.latestOutcome)}</p>` : "",
+    session.providers.length ? `<p>Providers: ${session.providers.map(escapeHtml11).join(", ")}</p>` : "",
+    session.replayHref ? `<p><a href="${escapeHtml11(session.replayHref)}">Open replay</a></p>` : "",
+    "</article>"
+  ].join("")),
+  "</div>"
+].join("");
+var createVoiceSessionsJSONHandler = (options = {}) => async ({ query }) => summarizeVoiceSessions({
+  ...options,
+  limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+  provider: query?.provider ?? options.provider,
+  q: query?.q ?? options.q,
+  status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+});
+var createVoiceSessionsHTMLHandler = (options = {}) => async ({ query }) => {
+  const sessions = await summarizeVoiceSessions({
+    ...options,
+    limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+    provider: query?.provider ?? options.provider,
+    q: query?.q ?? options.q,
+    status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+  });
+  const body = await (options.render?.(sessions) ?? renderVoiceSessionsHTML(sessions));
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionListRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-sessions";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia9({
+    name: options.name ?? "absolutejs-voice-session-list"
+  }).get(path, createVoiceSessionsJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionsHTMLHandler(options));
+  }
+  return routes;
+};
+var createVoiceSessionReplayJSONHandler = (options) => async ({ params }) => summarizeVoiceSessionReplay({
+  ...options,
+  sessionId: params.sessionId ?? ""
+});
+var createVoiceSessionReplayHTMLHandler = (options) => async ({ params }) => {
+  const replay = await summarizeVoiceSessionReplay({
+    ...options,
+    sessionId: params.sessionId ?? ""
+  });
+  const body = await (options.render?.(replay) ?? replay.html);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionReplayRoutes = (options) => {
+  const path = options.path ?? "/api/voice-sessions/:sessionId/replay";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia9({
+    name: options.name ?? "absolutejs-voice-session-replay"
+  }).get(path, createVoiceSessionReplayJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionReplayHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/opsConsoleRoutes.ts
+var DEFAULT_LINKS = [
+  {
+    description: "Quality gates for CI, deploy checks, and production readiness.",
+    href: "/quality",
+    label: "Quality",
+    statusHref: "/quality/status"
+  },
+  {
+    description: "Replay stored sessions against acceptance gates over time.",
+    href: "/evals",
+    label: "Evals",
+    statusHref: "/evals/status"
+  },
+  {
+    description: "Provider health, fallback paths, and failure simulation.",
+    href: "/resilience",
+    label: "Resilience"
+  },
+  {
+    description: "Redacted trace exports for debugging and support handoffs.",
+    href: "/diagnostics",
+    label: "Diagnostics"
+  },
+  {
+    description: "Recent sessions with replay links.",
+    href: "/sessions",
+    label: "Sessions"
+  },
+  {
+    description: "Transfer and webhook delivery health.",
+    href: "/handoffs",
+    label: "Handoffs"
+  }
+];
+var escapeHtml12 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var countProviderStatuses = (providers) => {
+  const degradedStatuses = new Set(["degraded", "rate-limited", "suppressed"]);
+  const healthy = providers.filter((provider) => provider.status === "healthy").length;
+  const degraded = providers.filter((provider) => degradedStatuses.has(provider.status)).length;
+  return {
+    degraded,
+    healthy,
+    total: providers.length
+  };
+};
+var buildVoiceOpsConsoleReport = async (options) => {
+  const events = await options.store.list();
+  const providers = [
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.llmProviders
+    }),
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.sttProviders
+    }),
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.ttsProviders
+    })
+  ];
+  const handoffs = await summarizeVoiceHandoffHealth({ events });
+  const sessions = await summarizeVoiceSessions({
+    events,
+    limit: 8,
+    status: "all"
+  });
+  const quality = await evaluateVoiceQuality({ events });
+  const routingEvents = listVoiceRoutingEvents(events).slice(0, 10);
+  const trace = summarizeVoiceTrace(events);
+  return {
+    checkedAt: Date.now(),
+    eventCount: events.length,
+    handoffs: {
+      failed: handoffs.failed,
+      total: handoffs.total
+    },
+    links: options.links ?? DEFAULT_LINKS,
+    providers: countProviderStatuses(providers),
+    quality,
+    recentRoutingEvents: routingEvents,
+    recentSessions: sessions,
+    sessions: {
+      failed: sessions.filter((session) => session.status === "failed").length,
+      healthy: sessions.filter((session) => session.status === "healthy").length,
+      total: sessions.length
+    },
+    trace
+  };
+};
+var renderMetricCard = (input) => `<article class="metric"><span>${escapeHtml12(input.label)}</span><strong>${escapeHtml12(String(input.value))}</strong>${input.status ? `<p class="${escapeHtml12(input.status)}">${escapeHtml12(input.status)}</p>` : ""}${input.href ? `<a href="${escapeHtml12(input.href)}">Open</a>` : ""}</article>`;
+var renderVoiceOpsConsoleHTML = (report, options = {}) => {
+  const links = report.links.map((link) => `<article class="surface">
+<div><h2>${escapeHtml12(link.label)}</h2>${link.description ? `<p>${escapeHtml12(link.description)}</p>` : ""}</div>
+<p><a href="${escapeHtml12(link.href)}">Open ${escapeHtml12(link.label)}</a>${link.statusHref ? ` \xB7 <a href="${escapeHtml12(link.statusHref)}">Status</a>` : ""}</p>
+</article>`).join("");
+  const sessions = report.recentSessions.length ? report.recentSessions.map((session) => `<tr><td>${escapeHtml12(session.sessionId)}</td><td>${escapeHtml12(session.status)}</td><td>${session.turnCount}</td><td>${session.errorCount}</td><td>${session.replayHref ? `<a href="${escapeHtml12(session.replayHref)}">Replay</a>` : ""}</td></tr>`).join("") : '<tr><td colspan="5">No sessions yet.</td></tr>';
+  const routing = report.recentRoutingEvents.length ? report.recentRoutingEvents.map((event) => `<tr><td>${escapeHtml12(event.kind)}</td><td>${escapeHtml12(event.provider ?? "unknown")}</td><td>${escapeHtml12(event.status ?? "unknown")}</td><td>${event.elapsedMs ?? 0}ms</td><td>${escapeHtml12(event.sessionId)}</td></tr>`).join("") : '<tr><td colspan="5">No provider routing events yet.</td></tr>';
+  const title = options.title ?? "AbsoluteJS Voice Ops Console";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml12(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;background:#101316;color:#f6f2e8;margin:0}main{max-width:1180px;margin:auto;padding:32px}a{color:#fbbf24}header{display:flex;justify-content:space-between;gap:24px;align-items:flex-start;margin-bottom:24px}.eyebrow{color:#fbbf24;font-weight:800;letter-spacing:.08em;text-transform:uppercase}h1{font-size:clamp(2.2rem,5vw,4.5rem);line-height:.95;margin:.2rem 0 1rem}.muted{color:#a8b0b8}.grid{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));margin:20px 0}.metric,.surface{background:#181d22;border:1px solid #2a323a;border-radius:20px;padding:18px}.metric strong{display:block;font-size:2.2rem;margin:.25rem 0}.pass,.healthy{color:#86efac}.fail,.failed,.degraded{color:#fca5a5}.surfaces{display:grid;gap:16px;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));margin:24px 0}table{width:100%;border-collapse:collapse;background:#181d22;border-radius:16px;overflow:hidden;margin:12px 0 28px}td,th{border-bottom:1px solid #2a323a;padding:12px;text-align:left}section{margin-top:30px}@media(max-width:700px){main{padding:20px}header{display:block}}</style></head><body><main><header><div><p class="eyebrow">Self-hosted voice operations</p><h1>${escapeHtml12(title)}</h1><p class="muted">One deployable control plane for quality gates, failover, traces, sessions, handoffs, and provider health.</p></div><p class="muted">Checked ${escapeHtml12(new Date(report.checkedAt).toLocaleString())}</p></header><div class="grid">${renderMetricCard({ label: "Quality", value: report.quality.status, status: report.quality.status, href: "/quality" })}${renderMetricCard({ label: "Events", value: report.eventCount, href: "/diagnostics" })}${renderMetricCard({ label: "Sessions", value: report.sessions.total, status: report.sessions.failed > 0 ? "failed" : "healthy", href: "/sessions" })}${renderMetricCard({ label: "Handoffs failed", value: report.handoffs.failed, status: report.handoffs.failed > 0 ? "failed" : "healthy", href: "/handoffs" })}${renderMetricCard({ label: "Providers degraded", value: report.providers.degraded, status: report.providers.degraded > 0 ? "degraded" : "healthy", href: "/resilience" })}</div><section><h2>Operational Surfaces</h2><div class="surfaces">${links}</div></section><section><h2>Recent Sessions</h2><table><thead><tr><th>Session</th><th>Status</th><th>Turns</th><th>Errors</th><th>Replay</th></tr></thead><tbody>${sessions}</tbody></table></section><section><h2>Recent Provider Routing</h2><table><thead><tr><th>Kind</th><th>Provider</th><th>Status</th><th>Elapsed</th><th>Session</th></tr></thead><tbody>${routing}</tbody></table></section></main></body></html>`;
+};
+var createVoiceOpsConsoleRoutes = (options) => {
+  const path = options.path ?? "/ops-console";
+  const routes = new Elysia10({
+    name: options.name ?? "absolutejs-voice-ops-console"
+  });
+  const getReport = () => buildVoiceOpsConsoleReport(options);
+  routes.get(path, async () => {
+    const report = await getReport();
+    return new Response(renderVoiceOpsConsoleHTML(report, { title: options.title }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async () => getReport());
+  return routes;
+};
+
+// src/appKit.ts
+var DEFAULT_LINKS2 = [
+  {
+    description: "Integrated voice operations console.",
+    href: "/ops-console",
+    label: "Ops Console"
+  },
+  {
+    description: "Production quality gates.",
+    href: "/quality",
+    label: "Quality",
+    statusHref: "/quality/status"
+  },
+  {
+    description: "Replay sessions against evals and workflow contracts.",
+    href: "/evals",
+    label: "Evals",
+    statusHref: "/evals/status"
+  },
+  {
+    description: "Provider routing, fallback, and resilience controls.",
+    href: "/resilience",
+    label: "Resilience"
+  },
+  {
+    description: "Recent sessions and replay links.",
+    href: "/sessions",
+    label: "Sessions"
+  },
+  {
+    description: "Handoff delivery health.",
+    href: "/handoffs",
+    label: "Handoffs"
+  },
+  {
+    description: "Redacted traces and bug-report exports.",
+    href: "/diagnostics",
+    label: "Diagnostics"
+  }
+];
+var resolveLinks = (links) => links ?? DEFAULT_LINKS2;
+var toBasicLinks = (links) => links.map(({ href, label }) => ({ href, label }));
+var toOpsLinks = (links) => links.map((link) => ({
+  description: link.description ?? link.label,
+  href: link.href,
+  label: link.label,
+  statusHref: link.statusHref
+}));
+var toResilienceLinks = (links) => links.map(({ href, label }) => ({ href, label }));
+var countStatus = (statuses) => ({
+  failed: statuses.filter((status) => status === "fail").length,
+  passed: statuses.filter((status) => status === "pass").length,
+  total: statuses.length
+});
+var summarizeVoiceAppKitStatus = async (options) => {
+  const links = resolveLinks(options.links);
+  const statusOptions = options.appStatus && typeof options.appStatus === "object" ? options.appStatus : undefined;
+  const evalOptions = options.evals === false ? undefined : options.evals;
+  const include = statusOptions?.include;
+  const shouldInclude = (surface) => include?.[surface] !== false;
+  const events = filterVoiceTraceEvents(await options.store.list());
+  const [quality, workflows, providers, sessions, handoffs] = await Promise.all([
+    options.quality === false || !shouldInclude("quality") ? undefined : evaluateVoiceQuality({
+      events,
+      thresholds: options.quality?.thresholds
+    }),
+    !evalOptions || !shouldInclude("workflows") ? undefined : (async () => {
+      const fixtureReport = await runVoiceScenarioFixtureEvals({
+        fixtures: evalOptions.fixtures,
+        fixtureStore: evalOptions.fixtureStore,
+        scenarios: evalOptions.scenarios
+      });
+      if ((statusOptions?.preferFixtureWorkflows ?? true) && fixtureReport.total > 0) {
+        return {
+          failed: fixtureReport.failed,
+          source: "fixtures",
+          status: fixtureReport.status,
+          total: fixtureReport.total
+        };
+      }
+      const liveReport = await runVoiceScenarioEvals({
+        events,
+        scenarios: evalOptions.scenarios
+      });
+      return {
+        failed: liveReport.failed,
+        source: "live",
+        status: liveReport.status,
+        total: liveReport.total
+      };
+    })(),
+    options.providerHealth === false || !shouldInclude("providers") ? undefined : summarizeVoiceProviderHealth({
+      events,
+      providers: options.llmProviders
+    }),
+    options.sessions === false || !shouldInclude("sessions") ? undefined : summarizeVoiceSessions({
+      events
+    }),
+    options.handoffs === false || !shouldInclude("handoffs") ? undefined : summarizeVoiceHandoffHealth({
+      events
+    })
+  ]);
+  const surfaces = {};
+  const statuses = [];
+  if (quality) {
+    surfaces.quality = { status: quality.status };
+    statuses.push(quality.status);
+  }
+  if (workflows) {
+    const status = workflows.status;
+    surfaces.workflows = {
+      failed: workflows.failed,
+      source: workflows.source,
+      status,
+      total: workflows.total
+    };
+    statuses.push(status);
+  }
+  if (providers) {
+    const degraded = providers.filter((provider) => provider.status === "degraded" || provider.status === "rate-limited" || provider.status === "suppressed").length;
+    const status = degraded > 0 ? "fail" : "pass";
+    surfaces.providers = {
+      degraded,
+      status,
+      total: providers.length
+    };
+    statuses.push(status);
+  }
+  if (sessions) {
+    const failed = sessions.filter((session) => session.status === "failed").length;
+    const status = failed > 0 ? "fail" : "pass";
+    surfaces.sessions = {
+      failed,
+      status,
+      total: sessions.length
+    };
+    statuses.push(status);
+  }
+  if (handoffs) {
+    const status = handoffs.failed > 0 ? "fail" : "pass";
+    surfaces.handoffs = {
+      failed: handoffs.failed,
+      status,
+      total: handoffs.total
+    };
+    statuses.push(status);
+  }
+  return {
+    checkedAt: Date.now(),
+    links,
+    status: statuses.includes("fail") ? "fail" : "pass",
+    surfaces,
+    ...countStatus(statuses)
+  };
+};
+var createVoiceAppKitRoutes = (options) => {
+  const routes = new Elysia11({
+    name: options.name ?? "absolutejs-voice-app-kit"
+  });
+  const links = resolveLinks(options.links);
+  const common = {
+    headers: options.headers,
+    store: options.store
+  };
+  const surfaces = [];
+  if (options.appStatus !== false) {
+    routes.get(options.appStatus?.path ?? "/app-kit/status", () => summarizeVoiceAppKitStatus(options));
+  }
+  if (options.providerHealth !== false) {
+    surfaces.push("providerHealth");
+    routes.use(createVoiceProviderHealthRoutes({
+      ...common,
+      providers: options.llmProviders,
+      ...options.providerHealth
+    }));
+  }
+  if (options.assistantHealth !== false) {
+    surfaces.push("assistantHealth");
+    routes.use(createVoiceAssistantHealthRoutes({
+      ...common,
+      providers: options.llmProviders,
+      ...options.assistantHealth
+    }));
+  }
+  if (options.quality !== false) {
+    surfaces.push("quality");
+    routes.use(createVoiceQualityRoutes({
+      ...common,
+      links: toBasicLinks(links),
+      ...options.quality
+    }));
+  }
+  if (options.evals !== false) {
+    surfaces.push("evals");
+    routes.use(createVoiceEvalRoutes({
+      ...common,
+      links: toBasicLinks(links),
+      title: options.title ? `${options.title} Evals` : undefined,
+      ...options.evals
+    }));
+  }
+  if (options.sessions !== false) {
+    surfaces.push("sessions");
+    routes.use(createVoiceSessionListRoutes({
+      ...common,
+      htmlPath: "/sessions",
+      path: "/api/voice-sessions",
+      replayHref: "/sessions/:sessionId",
+      ...options.sessions
+    }));
+  }
+  if (options.sessionReplay !== false) {
+    surfaces.push("sessionReplay");
+    routes.use(createVoiceSessionReplayRoutes({
+      ...common,
+      htmlPath: "/sessions/:sessionId",
+      path: "/api/voice-sessions/:sessionId/replay",
+      ...options.sessionReplay
+    }));
+  }
+  if (options.handoffs !== false) {
+    surfaces.push("handoffs");
+    routes.use(createVoiceHandoffHealthRoutes({
+      ...common,
+      htmlPath: "/handoffs",
+      path: "/api/voice-handoffs",
+      ...options.handoffs
+    }));
+  }
+  if (options.diagnostics !== false) {
+    surfaces.push("diagnostics");
+    routes.use(createVoiceDiagnosticsRoutes({
+      ...common,
+      path: "/diagnostics",
+      title: options.title ? `${options.title} Diagnostics` : undefined,
+      ...options.diagnostics
+    }));
+  }
+  if (options.resilience !== false) {
+    surfaces.push("resilience");
+    routes.use(createVoiceResilienceRoutes({
+      ...common,
+      links: toResilienceLinks(links),
+      llmProviders: options.llmProviders,
+      sttProviders: options.sttProviders,
+      title: options.title ? `${options.title} Resilience` : undefined,
+      ttsProviders: options.ttsProviders,
+      ...options.resilience
+    }));
+  }
+  if (options.opsConsole !== false) {
+    surfaces.push("opsConsole");
+    routes.use(createVoiceOpsConsoleRoutes({
+      ...common,
+      links: toOpsLinks(links),
+      llmProviders: options.llmProviders,
+      sttProviders: options.sttProviders,
+      title: options.title,
+      ttsProviders: options.ttsProviders,
+      ...options.opsConsole
+    }));
+  }
+  return {
+    links,
+    routes,
+    surfaces,
+    use: routes.use.bind(routes)
+  };
+};
+var createVoiceAppKit = createVoiceAppKitRoutes;
+// src/workflowContract.ts
+var getObject2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var getPathValue2 = (value, path) => {
+  let current = value;
+  for (const part of path.split(".").filter(Boolean)) {
+    const record = getObject2(current);
+    if (!record || !(part in record)) {
+      return;
+    }
+    current = record[part];
+  }
+  return current;
+};
+var hasValue = (value, match) => {
+  switch (match) {
+    case "boolean":
+      return typeof value === "boolean";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "string":
+      return typeof value === "string";
+    case "truthy":
+      return Boolean(value);
+    case "non-empty":
+    default:
+      return Array.isArray(value) ? value.length > 0 : typeof value === "string" ? value.trim().length > 0 : value !== undefined && value !== null;
+  }
+};
+var resolveOutcome2 = (routeResult) => {
+  if (routeResult.complete)
+    return "complete";
+  if (routeResult.transfer)
+    return "transfer";
+  if (routeResult.escalate)
+    return "escalate";
+  if (routeResult.voicemail)
+    return "voicemail";
+  if (routeResult.noAnswer)
+    return "no-answer";
+  return;
+};
+var validateVoiceWorkflowRouteResult = (definition, routeResult) => {
+  const issues = [];
+  const requiredFields = (definition.fields ?? []).filter((field) => field.required !== false).map((field) => field.path);
+  const missingFields = [];
+  const outcome = resolveOutcome2(routeResult);
+  if (definition.outcome && outcome !== definition.outcome) {
+    issues.push({
+      code: "workflow.outcome_mismatch",
+      message: `Expected workflow outcome ${definition.outcome}, saw ${outcome ?? "none"}.`
+    });
+  }
+  for (const field of definition.fields ?? []) {
+    if (field.required === false)
+      continue;
+    const paths = [field.path, ...field.aliases ?? []];
+    const present = paths.some((path) => hasValue(getPathValue2(routeResult.result, path), field.match ?? "non-empty"));
+    if (!present) {
+      missingFields.push(field.path);
+      issues.push({
+        code: "workflow.missing_field",
+        field: field.path,
+        message: `Missing required workflow field: ${field.label ?? field.path}.`
+      });
+    }
+  }
+  issues.push(...definition.validate?.({
+    result: routeResult.result,
+    routeResult
+  }) ?? []);
+  return {
+    contractId: definition.id,
+    issues,
+    missingFields,
+    outcome,
+    pass: issues.length === 0,
+    requiredFields
+  };
+};
+var createVoiceWorkflowScenario = (definition, overrides = {}) => ({
+  description: definition.description,
+  forbiddenHandoffActions: definition.forbiddenHandoffActions,
+  id: definition.id,
+  label: definition.label,
+  maxProviderErrors: definition.maxProviderErrors,
+  maxSessionErrors: definition.maxSessionErrors,
+  minSessions: definition.minSessions,
+  minTurns: definition.minTurns,
+  requiredAssistantIncludes: definition.requiredAssistantIncludes,
+  requiredDisposition: definition.requiredDisposition,
+  requiredHandoffActions: definition.requiredHandoffActions,
+  requiredLifecycleTypes: definition.requiredLifecycleTypes,
+  requiredTranscriptIncludes: definition.requiredTranscriptIncludes,
+  requiredWorkflowContracts: [definition.id],
+  scenarioId: definition.scenarioId,
+  ...overrides
+});
+var createVoiceWorkflowContract = (definition) => ({
+  assertRouteResult: (routeResult) => {
+    const validation = validateVoiceWorkflowRouteResult(definition, routeResult);
+    if (!validation.pass) {
+      throw new Error(`Voice workflow contract ${definition.id} failed: ${validation.issues.map((issue) => issue.message).join(" ")}`);
+    }
+  },
+  definition,
+  toScenarioEval: (overrides) => createVoiceWorkflowScenario(definition, overrides),
+  validateRouteResult: (routeResult) => validateVoiceWorkflowRouteResult(definition, routeResult)
+});
+var presetDefinitions = {
+  "appointment-booking": {
+    description: "Appointment booking should complete with enough identity, appointment, and follow-up details to act on.",
+    fields: [
+      { aliases: ["name", "customer.name"], label: "Caller name", path: "caller.name" },
+      {
+        aliases: ["phone", "customer.phone"],
+        label: "Caller phone",
+        path: "caller.phone"
+      },
+      {
+        aliases: ["appointment.start", "appointment.time", "scheduledAt"],
+        label: "Appointment time",
+        path: "appointment.startsAt"
+      },
+      {
+        aliases: ["summary", "assistantSummary"],
+        label: "Summary",
+        path: "appointment.summary"
+      }
+    ],
+    id: "appointment-booking",
+    label: "Appointment booking",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "lead-qualification": {
+    description: "Lead qualification should complete with contact, need, qualification, and next-step fields.",
+    fields: [
+      { aliases: ["name", "lead.name"], label: "Lead name", path: "contact.name" },
+      {
+        aliases: ["email", "lead.email"],
+        label: "Lead email",
+        path: "contact.email"
+      },
+      {
+        aliases: ["need", "pain", "summary"],
+        label: "Need",
+        path: "qualification.need"
+      },
+      {
+        aliases: ["qualified", "qualification.qualified"],
+        label: "Qualified",
+        match: "boolean",
+        path: "qualification.isQualified"
+      },
+      {
+        aliases: ["nextStep", "followUp"],
+        label: "Next step",
+        path: "qualification.nextStep"
+      }
+    ],
+    id: "lead-qualification",
+    label: "Lead qualification",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "support-triage": {
+    description: "Support triage should capture identity, issue summary, severity, and the operational follow-up.",
+    fields: [
+      {
+        aliases: ["name", "customer.name"],
+        label: "Customer name",
+        path: "customer.name"
+      },
+      {
+        aliases: ["issue", "summary", "assistantSummary"],
+        label: "Issue summary",
+        path: "issue.summary"
+      },
+      {
+        aliases: ["priority", "severity"],
+        label: "Severity",
+        path: "issue.severity"
+      },
+      {
+        aliases: ["nextStep", "task.title"],
+        label: "Next step",
+        path: "resolution.nextStep"
+      }
+    ],
+    id: "support-triage",
+    label: "Support triage",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "transfer-handoff": {
+    description: "Transfer handoff should produce a routed transfer plus handoff evidence.",
+    fields: [
+      {
+        aliases: ["target", "callTarget"],
+        label: "Transfer target",
+        path: "transfer.target"
+      },
+      {
+        aliases: ["reason", "callReason"],
+        label: "Transfer reason",
+        path: "transfer.reason"
+      },
+      {
+        aliases: ["summary", "assistantSummary"],
+        label: "Transfer summary",
+        path: "transfer.summary"
+      }
+    ],
+    id: "transfer-handoff",
+    label: "Transfer handoff",
+    outcome: "transfer",
+    requiredDisposition: "transferred",
+    requiredHandoffActions: ["transfer"]
+  },
+  "voicemail-callback": {
+    description: "Voicemail callback should preserve enough caller and callback context for follow-up.",
+    fields: [
+      {
+        aliases: ["name", "caller.name"],
+        label: "Caller name",
+        path: "voicemail.callerName"
+      },
+      {
+        aliases: ["phone", "caller.phone"],
+        label: "Callback phone",
+        path: "voicemail.callbackPhone"
+      },
+      {
+        aliases: ["message", "summary", "assistantSummary"],
+        label: "Voicemail summary",
+        path: "voicemail.summary"
+      }
+    ],
+    id: "voicemail-callback",
+    label: "Voicemail callback",
+    outcome: "voicemail",
+    requiredDisposition: "voicemail",
+    requiredHandoffActions: ["voicemail"]
+  }
+};
+var createVoiceWorkflowContractPreset = (name, options = {}) => {
+  const preset = presetDefinitions[name];
+  return createVoiceWorkflowContract({
+    ...preset,
+    ...options,
+    fields: options.fields ?? preset.fields,
+    id: options.id ?? preset.id
+  });
+};
+var recordVoiceWorkflowContractTrace = async (input) => input.store.append({
+  at: input.at ?? Date.now(),
+  payload: {
+    contractId: input.contractId ?? input.validation.contractId,
+    issues: input.validation.issues,
+    missingFields: input.validation.missingFields,
+    outcome: input.validation.outcome,
+    requiredFields: input.validation.requiredFields,
+    status: input.validation.pass ? "pass" : "fail"
+  },
+  scenarioId: input.scenarioId,
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  turnId: input.turnId,
+  type: "workflow.contract"
 });
-
+var createVoiceWorkflowContractHandler = (input) => {
+  return async (session, turn, api, context) => {
+    const legacyHandler = input.handler;
+    const objectHandler = input.handler;
+    const result = input.handler.length >= 4 ? await legacyHandler(session, turn, api, context) : await objectHandler({ api, context, session, turn });
+    if (!result)
+      return result;
+    const resolved = input.resolveContract?.({ context, result, session, turn }) ?? input.contract;
+    if (!resolved)
+      return result;
+    const contract = "validateRouteResult" in resolved ? resolved : createVoiceWorkflowContract(resolved);
+    const validation = contract.validateRouteResult(result);
+    if (input.store) {
+      await recordVoiceWorkflowContractTrace({
+        scenarioId: session.scenarioId,
+        sessionId: session.id,
+        store: input.store,
+        turnId: turn.id,
+        validation
+      });
+    }
+    return result;
+  };
+};
 // src/fileStore.ts
+import { mkdir as mkdir2, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { join } from "path";
 var listJsonFiles = async (directory) => {
   try {
     const entries = await readdir(directory, {
@@ -6788,7 +9749,7 @@ var resolveFilePath = (directory, id) => join(directory, encodeStoreId(id));
 var createMemoryStoreId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
 var readJsonFile = async (path) => JSON.parse(await readFile(path, "utf8"));
 var writeJsonFile = async (path, value, options) => {
-  await mkdir(options.directory, {
+  await mkdir2(options.directory, {
     recursive: true
   });
   const tempPath = `${path}.${crypto.randomUUID()}.tmp`;
@@ -7085,6 +10046,47 @@ var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectM
   sourceType: mapping.sourceType
 });
 // src/modelAdapters.ts
+var resolveVoiceProviderRoutingPolicyPreset = (preset, options = {}) => {
+  switch (preset) {
+    case "balanced":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "balanced",
+        weights: {
+          cost: 1,
+          latencyMs: 0.005,
+          priority: 1,
+          quality: 10,
+          ...options.weights
+        },
+        ...options
+      };
+    case "cost-cap":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-cheapest",
+        ...options
+      };
+    case "cost-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-cheapest",
+        ...options
+      };
+    case "latency-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-fastest",
+        ...options
+      };
+    case "quality-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "quality-first",
+        ...options
+      };
+  }
+};
 var OUTPUT_SCHEMA = {
   additionalProperties: false,
   properties: {
@@ -7152,10 +10154,15 @@ var OUTPUT_SCHEMA = {
   },
   type: "object"
 };
-var ROUTE_RESULT_INSTRUCTION = "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools.";
+var ROUTE_RESULT_INSTRUCTION = "Return only a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools. Only set transfer, escalate, voicemail, or noAnswer when the user explicitly asks for that lifecycle outcome or a tool result says that exact outcome. Do not infer voicemail from generic words like voice, voice app, or voice integration.";
+var stripJSONCodeFence = (value) => {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return match?.[1]?.trim() ?? value;
+};
 var parseJSON = (value) => {
   try {
-    const parsed = JSON.parse(value);
+    const parsed = JSON.parse(stripJSONCodeFence(value));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {
@@ -7170,11 +10177,27 @@ var parseJSONValue = (value) => {
     return value;
   }
 };
+
+class VoiceProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(provider, timeoutMs) {
+    super(`Voice provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
 var getMessageToolCalls = (message) => {
   const toolCalls = message.metadata?.toolCalls;
   return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
 };
 var createHTTPError = (provider, response) => new Error(`${provider} voice assistant model failed: HTTP ${response.status}`);
+var sleep4 = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var defaultIsRateLimitError = (error) => /(\b429\b|rate limit|quota|too many requests)/i.test(errorMessage(error));
 var normalizeRouteOutput = (output) => {
   const result = {};
   if (typeof output.assistantText === "string") {
@@ -7228,19 +10251,272 @@ var createJSONVoiceAssistantModel = (options) => ({
     return options.mapOutput?.(output) ?? normalizeRouteOutput(output);
   }
 });
-var messageToOpenAIInput = (message) => {
-  if (message.role === "tool") {
+var createVoiceProviderRouter = (options) => {
+  const providerIds = Object.keys(options.providers);
+  const firstProvider = providerIds[0];
+  const policy = typeof options.policy === "string" ? options.policy === "balanced" || options.policy === "cost-cap" || options.policy === "cost-first" || options.policy === "latency-first" || options.policy === "quality-first" ? resolveVoiceProviderRoutingPolicyPreset(options.policy) : {
+    strategy: options.policy
+  } : options.policy;
+  const strategy = policy?.strategy ?? "prefer-selected";
+  const fallbackMode = policy?.fallbackMode ?? options.fallbackMode ?? "provider-error";
+  const healthOptions = typeof options.providerHealth === "object" ? options.providerHealth : options.providerHealth ? {} : undefined;
+  const healthState = new Map;
+  const now = () => healthOptions?.now?.() ?? Date.now();
+  const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
+  const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
+  const rateLimitCooldownMs = Math.max(0, healthOptions?.rateLimitCooldownMs ?? 60000);
+  const getProviderTimeoutMs = (provider) => {
+    const timeoutMs = options.providerProfiles?.[provider]?.timeoutMs ?? options.timeoutMs;
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+  };
+  const getHealth = (provider) => {
+    const existing = healthState.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const next = {
+      consecutiveFailures: 0,
+      provider,
+      status: "healthy"
+    };
+    healthState.set(provider, next);
+    return next;
+  };
+  const cloneHealth = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
     return {
-      call_id: message.toolCallId ?? message.name ?? crypto.randomUUID(),
-      output: message.content,
-      type: "function_call_output"
+      ...getHealth(provider)
     };
-  }
+  };
+  const getSuppressionRemainingMs = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" ? Math.max(0, suppressedUntil - now()) : undefined;
+  };
+  const isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const health = getHealth(provider);
+    return typeof health.suppressedUntil === "number" && health.suppressedUntil > now();
+  };
+  const recordProviderSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordProviderError = (provider, isProviderError, rateLimited) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const currentTime = now();
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = currentTime;
+    if (rateLimited) {
+      health.lastRateLimitedAt = currentTime;
+    }
+    if (rateLimited || health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = currentTime + (rateLimited ? rateLimitCooldownMs : cooldownMs);
+    }
+    return cloneHealth(provider);
+  };
+  const resolveAllowedProviders = async (input) => {
+    const allowProviders = policy?.allowProviders ?? options.allowProviders;
+    const allowed = typeof allowProviders === "function" ? await allowProviders(input) : allowProviders;
+    return new Set(allowed ?? providerIds);
+  };
+  const passesBudgetFilters = (provider) => {
+    const profile = options.providerProfiles?.[provider];
+    if (typeof policy?.maxCost === "number" && typeof profile?.cost === "number" && profile.cost > policy.maxCost) {
+      return false;
+    }
+    if (typeof policy?.maxLatencyMs === "number" && typeof profile?.latencyMs === "number" && profile.latencyMs > policy.maxLatencyMs) {
+      return false;
+    }
+    if (typeof policy?.minQuality === "number" && typeof profile?.quality === "number" && profile.quality < policy.minQuality) {
+      return false;
+    }
+    return true;
+  };
+  const getBalancedScore = (provider) => {
+    const profile = options.providerProfiles?.[provider];
+    if (policy?.scoreProvider) {
+      return policy.scoreProvider(provider, profile);
+    }
+    const weights = policy?.weights ?? {};
+    return (profile?.cost ?? Number.MAX_SAFE_INTEGER) * (weights.cost ?? 1) + (profile?.latencyMs ?? Number.MAX_SAFE_INTEGER) * (weights.latencyMs ?? 0.005) + (profile?.priority ?? 0) * (weights.priority ?? 1) - (profile?.quality ?? 0) * (weights.quality ?? 10);
+  };
+  const sortProviders = (providers) => {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest" && strategy !== "quality-first" && strategy !== "balanced") {
+      return providers;
+    }
+    return [...providers].sort((left, right) => {
+      const leftProfile = options.providerProfiles?.[left];
+      const rightProfile = options.providerProfiles?.[right];
+      if (strategy === "quality-first") {
+        return (rightProfile?.quality ?? Number.MIN_SAFE_INTEGER) - (leftProfile?.quality ?? Number.MIN_SAFE_INTEGER) || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.cost ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.cost ?? Number.MAX_SAFE_INTEGER);
+      }
+      if (strategy === "balanced") {
+        return getBalancedScore(left) - getBalancedScore(right);
+      }
+      const leftValue = strategy === "prefer-cheapest" ? leftProfile?.cost ?? Number.MAX_SAFE_INTEGER : leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      const rightValue = strategy === "prefer-cheapest" ? rightProfile?.cost ?? Number.MAX_SAFE_INTEGER : rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      return leftValue - rightValue || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER);
+    });
+  };
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input);
+    const allowedProviders = await resolveAllowedProviders(input);
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const allowedRankedProviders = sortProviders([
+      ...fallbackOrder ?? providerIds
+    ]).filter((provider) => allowedProviders.has(provider));
+    const rankedProviders = allowedRankedProviders.filter(passesBudgetFilters);
+    const healthyRankedProviders = healthOptions ? rankedProviders.filter((provider) => !isSuppressed(provider)) : rankedProviders;
+    const candidateRankedProviders = healthyRankedProviders.length ? healthyRankedProviders : rankedProviders;
+    const preferred = selectedProvider && allowedProviders.has(selectedProvider) && passesBudgetFilters(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : candidateRankedProviders[0] ?? firstProvider;
+    const seen = new Set;
+    const order = [];
+    const candidates = strategy === "ordered" ? candidateRankedProviders : [
+      preferred,
+      ...candidateRankedProviders,
+      ...providerIds.filter((provider) => !healthOptions || !isSuppressed(provider))
+    ];
+    for (const provider of candidates) {
+      if (!provider || seen.has(provider) || !allowedProviders.has(provider) || !options.providers[provider]) {
+        continue;
+      }
+      seen.add(provider);
+      order.push(provider);
+    }
+    return {
+      order,
+      selectedProvider: preferred
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  const runProvider = async (provider, model, input) => {
+    const timeoutMs = getProviderTimeoutMs(provider);
+    if (!timeoutMs) {
+      return model.generate(input);
+    }
+    let timeout;
+    try {
+      return await Promise.race([
+        model.generate(input),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new VoiceProviderTimeoutError(provider, timeoutMs)), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  };
   return {
-    content: message.content,
-    role: message.role === "system" ? "developer" : message.role
+    generate: async (input) => {
+      const { order, selectedProvider } = await resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const model = options.providers[provider];
+        if (!model) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const output = await runProvider(provider, model, input);
+          const providerHealth = recordProviderSuccess(provider);
+          await emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            latencyBudgetMs: getProviderTimeoutMs(provider),
+            provider,
+            providerHealth,
+            recovered: provider !== selectedProvider,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return output;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const isProviderError = options.isProviderError?.(error, provider) ?? true;
+          const timedOut = options.isTimeoutError?.(error, provider) ?? error instanceof VoiceProviderTimeoutError;
+          const rateLimited = options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error);
+          const shouldFallback = fallbackMode === "provider-error" ? isProviderError : fallbackMode === "rate-limit" ? isProviderError && rateLimited : false;
+          const providerHealth = recordProviderError(provider, isProviderError, rateLimited);
+          const nextProvider = hasNextProvider ? order[index + 1] : undefined;
+          await emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage(error),
+            fallbackProvider: shouldFallback ? nextProvider : undefined,
+            latencyBudgetMs: getProviderTimeoutMs(provider),
+            provider,
+            providerHealth,
+            rateLimited,
+            selectedProvider,
+            suppressionRemainingMs: getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            status: "error",
+            timedOut
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            throw error;
+          }
+        }
+      }
+      throw lastError ?? new Error("Voice provider router did not run a provider.");
+    }
   };
 };
+var messageToOpenAIInput = (message) => {
+  if (message.role === "tool") {
+    return [
+      {
+        call_id: message.toolCallId ?? message.name ?? crypto.randomUUID(),
+        output: message.content,
+        type: "function_call_output"
+      }
+    ];
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return toolCalls.map((toolCall) => ({
+      arguments: JSON.stringify(toolCall.args),
+      call_id: toolCall.id ?? crypto.randomUUID(),
+      name: toolCall.name,
+      type: "function_call"
+    }));
+  }
+  return [
+    {
+      content: message.content,
+      role: message.role === "system" ? "developer" : message.role
+    }
+  ];
+};
+var messagesToOpenAIInput = (messages) => messages.flatMap(messageToOpenAIInput);
 var messageToAnthropicMessage = (message) => {
   if (message.role === "system") {
     return;
@@ -7410,7 +10686,7 @@ var createOpenAIVoiceAssistantModel = (options) => {
     generate: async (input) => {
       const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
         body: JSON.stringify({
-          input: input.messages.map(messageToOpenAIInput),
+          input: messagesToOpenAIInput(input.messages),
           instructions: [
             input.system,
             "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools."
@@ -7574,64 +10850,492 @@ var extractGeminiToolCalls = (response) => {
   }
   return toolCalls;
 };
-var createGeminiVoiceAssistantModel = (options) => {
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  const baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
-  const model = options.model ?? "gemini-2.5-flash";
+var createGeminiVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+  const model = options.model ?? "gemini-2.5-flash";
+  const maxRetries = Math.max(0, options.maxRetries ?? 2);
+  return {
+    generate: async (input) => {
+      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
+      let response;
+      for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
+        response = await fetchImpl(endpoint, {
+          body: JSON.stringify({
+            contents: input.messages.map(messageToGeminiContent).filter(Boolean),
+            generationConfig: {
+              maxOutputTokens: options.maxOutputTokens,
+              ...input.tools.length ? {} : {
+                responseMimeType: "application/json",
+                responseSchema: toGeminiSchema(OUTPUT_SCHEMA)
+              },
+              temperature: options.temperature
+            },
+            systemInstruction: {
+              parts: [
+                {
+                  text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`)
+                }
+              ]
+            },
+            tools: input.tools.length ? [
+              {
+                functionDeclarations: input.tools.map((tool) => ({
+                  description: tool.description,
+                  name: tool.name,
+                  parameters: toGeminiSchema(tool.parameters ?? {
+                    additionalProperties: true,
+                    type: "object"
+                  })
+                }))
+              }
+            ] : undefined
+          }),
+          headers: {
+            "content-type": "application/json"
+          },
+          method: "POST"
+        });
+        if (response.ok || response.status !== 429 && response.status < 500 || attempt === maxRetries) {
+          break;
+        }
+        const retryAfter = Number(response.headers.get("retry-after"));
+        await sleep4(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt);
+      }
+      if (!response) {
+        throw new Error("Gemini voice assistant model failed: no response");
+      }
+      if (!response.ok) {
+        throw createHTTPError("Gemini", response);
+      }
+      const body = await response.json();
+      if (body.usageMetadata && typeof body.usageMetadata === "object") {
+        await options.onUsage?.(body.usageMetadata);
+      }
+      const toolCalls = extractGeminiToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractGeminiText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+    }
+  };
+};
+// src/providerAdapters.ts
+class VoiceIOProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(kind, provider, timeoutMs) {
+    super(`Voice ${kind} provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceIOProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var createEmitter = () => {
+  const listeners = new Map;
+  return {
+    emit: async (event, payload) => {
+      await Promise.all([...listeners.get(event) ?? []].map((handler) => Promise.resolve(handler(payload))));
+    },
+    on: (event, handler) => {
+      const set = listeners.get(event) ?? new Set;
+      set.add(handler);
+      listeners.set(event, set);
+      return () => {
+        set.delete(handler);
+      };
+    }
+  };
+};
+var getTimeoutMs = (options, provider) => {
+  const timeoutMs = options.providerProfiles?.[provider]?.timeoutMs ?? options.timeoutMs;
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+};
+var withTimeout = async (input) => {
+  if (!input.timeoutMs) {
+    return input.run();
+  }
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(input.run()),
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new VoiceIOProviderTimeoutError(input.kind, input.provider, input.timeoutMs)), input.timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+var isVoiceProviderRoutingPolicyPreset = (policy) => policy === "balanced" || policy === "cost-cap" || policy === "cost-first" || policy === "latency-first" || policy === "quality-first";
+var createResolver = (options) => {
+  const providerIds = Object.keys(options.adapters);
+  const firstProvider = providerIds[0];
+  const policy = typeof options.policy === "string" ? isVoiceProviderRoutingPolicyPreset(options.policy) ? resolveVoiceProviderRoutingPolicyPreset(options.policy) : {
+    strategy: options.policy
+  } : options.policy;
+  const strategy = policy?.strategy ?? "prefer-selected";
+  const healthOptions = typeof options.providerHealth === "object" ? options.providerHealth : options.providerHealth ? {} : undefined;
+  const healthState = new Map;
+  const now = () => healthOptions?.now?.() ?? Date.now();
+  const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
+  const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
+  const getHealth = (provider) => {
+    const existing = healthState.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const next = {
+      consecutiveFailures: 0,
+      provider,
+      status: "healthy"
+    };
+    healthState.set(provider, next);
+    return next;
+  };
+  const cloneHealth = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    return {
+      ...getHealth(provider)
+    };
+  };
+  const getSuppressionRemainingMs = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" ? Math.max(0, suppressedUntil - now()) : undefined;
+  };
+  const isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" && suppressedUntil > now();
+  };
+  const recordSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordError = (provider, isProviderError) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = now();
+    if (health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = now() + cooldownMs;
+    }
+    return cloneHealth(provider);
+  };
+  const resolveAllowedProviders = async (input) => {
+    const allowed = typeof policy?.allowProviders === "function" ? await policy.allowProviders(input) : policy?.allowProviders;
+    return new Set(allowed ?? providerIds);
+  };
+  const passesBudgetFilters = (provider) => {
+    const profile = options.providerProfiles?.[provider];
+    if (typeof policy?.maxCost === "number" && typeof profile?.cost === "number" && profile.cost > policy.maxCost) {
+      return false;
+    }
+    if (typeof policy?.maxLatencyMs === "number" && typeof profile?.latencyMs === "number" && profile.latencyMs > policy.maxLatencyMs) {
+      return false;
+    }
+    if (typeof policy?.minQuality === "number" && typeof profile?.quality === "number" && profile.quality < policy.minQuality) {
+      return false;
+    }
+    return true;
+  };
+  const getBalancedScore = (provider) => {
+    const profile = options.providerProfiles?.[provider];
+    if (policy?.scoreProvider) {
+      return policy.scoreProvider(provider, profile);
+    }
+    const weights = policy?.weights ?? {};
+    return (profile?.cost ?? Number.MAX_SAFE_INTEGER) * (weights.cost ?? 1) + (profile?.latencyMs ?? Number.MAX_SAFE_INTEGER) * (weights.latencyMs ?? 0.005) + (profile?.priority ?? 0) * (weights.priority ?? 1) - (profile?.quality ?? 0) * (weights.quality ?? 10);
+  };
+  const sortProviders = (providers) => {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest" && strategy !== "quality-first" && strategy !== "balanced") {
+      return providers;
+    }
+    return [...providers].sort((left, right) => {
+      const leftProfile = options.providerProfiles?.[left];
+      const rightProfile = options.providerProfiles?.[right];
+      if (strategy === "quality-first") {
+        return (rightProfile?.quality ?? Number.MIN_SAFE_INTEGER) - (leftProfile?.quality ?? Number.MIN_SAFE_INTEGER) || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.cost ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.cost ?? Number.MAX_SAFE_INTEGER);
+      }
+      if (strategy === "balanced") {
+        return getBalancedScore(left) - getBalancedScore(right);
+      }
+      const leftValue = strategy === "prefer-cheapest" ? leftProfile?.cost ?? Number.MAX_SAFE_INTEGER : leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      const rightValue = strategy === "prefer-cheapest" ? rightProfile?.cost ?? Number.MAX_SAFE_INTEGER : rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      return leftValue - rightValue || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER);
+    });
+  };
+  const resolveOrder = async (input) => {
+    const requestedProvider = await options.selectProvider?.(input);
+    const selectedProvider = requestedProvider ?? firstProvider;
+    const allowedProviders = await resolveAllowedProviders(input);
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const candidates = [selectedProvider, ...fallbackOrder ?? providerIds];
+    const seen = new Set;
+    const orderedCandidates = candidates.filter((provider) => {
+      if (!provider || seen.has(provider) || !options.adapters[provider]) {
+        return false;
+      }
+      seen.add(provider);
+      return true;
+    });
+    const rankedOrder = sortProviders(orderedCandidates).filter((provider) => allowedProviders.has(provider)).filter(passesBudgetFilters);
+    const healthyOrder = healthOptions ? rankedOrder.filter((provider) => !isSuppressed(provider)) : rankedOrder;
+    const order = healthyOrder.length ? healthyOrder : rankedOrder;
+    const preferred = strategy === "prefer-selected" && selectedProvider && allowedProviders.has(selectedProvider) && passesBudgetFilters(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : order[0];
+    return {
+      order,
+      selectedProvider: preferred
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  return {
+    emit,
+    getSuppressionRemainingMs,
+    providerIds,
+    recordError,
+    recordSuccess,
+    resolveOrder
+  };
+};
+var createVoiceSTTProviderRouter = (options) => {
+  const resolver = createResolver(options);
   return {
-    generate: async (input) => {
-      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
-      const response = await fetchImpl(endpoint, {
-        body: JSON.stringify({
-          contents: input.messages.map(messageToGeminiContent).filter(Boolean),
-          generationConfig: {
-            maxOutputTokens: options.maxOutputTokens,
-            responseMimeType: "application/json",
-            responseSchema: toGeminiSchema(OUTPUT_SCHEMA),
-            temperature: options.temperature
-          },
-          systemInstruction: {
-            parts: [
-              {
-                text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
-
-`)
-              }
-            ]
-          },
-          tools: input.tools.length ? [
-            {
-              functionDeclarations: input.tools.map((tool) => ({
-                description: tool.description,
-                name: tool.name,
-                parameters: toGeminiSchema(tool.parameters ?? {
-                  additionalProperties: true,
-                  type: "object"
-                })
-              }))
-            }
-          ] : undefined
-        }),
-        headers: {
-          "content-type": "application/json"
-        },
-        method: "POST"
-      });
-      if (!response.ok) {
-        throw createHTTPError("Gemini", response);
+    kind: "stt",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice STT provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const session = await withTimeout({
+            kind: "stt",
+            operation: "open",
+            provider,
+            run: () => adapter.open(input),
+            timeoutMs: getTimeoutMs(options, provider)
+          });
+          const providerHealth = resolver.recordSuccess(provider);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return session;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const shouldFallback = options.isProviderError?.(error, provider) ?? true;
+          const providerHealth = resolver.recordError(provider, shouldFallback);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage2(error),
+            fallbackProvider: shouldFallback ? order[index + 1] : undefined,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: "error",
+            suppressionRemainingMs: resolver.getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            timedOut: error instanceof VoiceIOProviderTimeoutError
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            throw error;
+          }
+        }
       }
-      const body = await response.json();
-      if (body.usageMetadata && typeof body.usageMetadata === "object") {
-        await options.onUsage?.(body.usageMetadata);
+      throw lastError ?? new Error("Voice STT provider router did not open a provider.");
+    }
+  };
+};
+var createVoiceTTSProviderRouter = (options) => {
+  const resolver = createResolver(options);
+  return {
+    kind: "tts",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice TTS provider router has no available providers.");
+      }
+      const emitter = createEmitter();
+      let activeSession;
+      let activeProvider;
+      let nextProviderIndex = 0;
+      const attach = (session) => {
+        session.on("audio", (event) => emitter.emit("audio", event));
+        session.on("error", (event) => emitter.emit("error", event));
+        session.on("close", (event) => emitter.emit("close", event));
+      };
+      const openProvider = async (provider, attempt) => {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          throw new Error(`Voice TTS provider ${provider} is not configured.`);
+        }
+        const startedAt = Date.now();
+        const session = await withTimeout({
+          kind: "tts",
+          operation: "open",
+          provider,
+          run: () => adapter.open(input),
+          timeoutMs: getTimeoutMs(options, provider)
+        });
+        attach(session);
+        activeSession = session;
+        activeProvider = provider;
+        const providerHealth = resolver.recordSuccess(provider);
+        await resolver.emit({
+          at: Date.now(),
+          attempt,
+          elapsedMs: Date.now() - startedAt,
+          fallbackProvider: provider === selectedProvider ? undefined : provider,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, provider),
+          operation: "open",
+          provider,
+          providerHealth,
+          selectedProvider,
+          status: provider === selectedProvider ? "success" : "fallback"
+        }, input);
+        return session;
+      };
+      const failProvider = async (inputEvent) => {
+        const shouldFallback = options.isProviderError?.(inputEvent.error, inputEvent.provider) ?? true;
+        const providerHealth = resolver.recordError(inputEvent.provider, shouldFallback);
+        await resolver.emit({
+          at: Date.now(),
+          attempt: inputEvent.attempt,
+          elapsedMs: Date.now() - inputEvent.startedAt,
+          error: errorMessage2(inputEvent.error),
+          fallbackProvider: shouldFallback ? order[nextProviderIndex] : undefined,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, inputEvent.provider),
+          operation: inputEvent.operation,
+          provider: inputEvent.provider,
+          providerHealth,
+          selectedProvider,
+          status: "error",
+          suppressionRemainingMs: resolver.getSuppressionRemainingMs(inputEvent.provider),
+          suppressedUntil: providerHealth?.suppressedUntil,
+          timedOut: inputEvent.error instanceof VoiceIOProviderTimeoutError
+        }, input);
+        return shouldFallback;
+      };
+      for (const [index, provider] of order.entries()) {
+        nextProviderIndex = index + 1;
+        const startedAt = Date.now();
+        try {
+          await openProvider(provider, index + 1);
+          break;
+        } catch (error) {
+          const shouldFallback = await failProvider({
+            attempt: index + 1,
+            error,
+            operation: "open",
+            provider,
+            startedAt
+          });
+          if (!shouldFallback || index >= order.length - 1) {
+            throw error;
+          }
+        }
       }
-      const toolCalls = extractGeminiToolCalls(body);
-      if (toolCalls.length) {
-        return {
-          assistantText: extractGeminiText(body) || undefined,
-          toolCalls
-        };
+      if (!activeSession || !activeProvider) {
+        throw new Error("Voice TTS provider router did not open a provider.");
       }
-      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+      const sendWithFallback = async (text) => {
+        for (;; ) {
+          const session = activeSession;
+          const provider = activeProvider;
+          if (!session || !provider) {
+            throw new Error("Voice TTS provider router has no active provider.");
+          }
+          const startedAt = Date.now();
+          try {
+            await withTimeout({
+              kind: "tts",
+              operation: "send",
+              provider,
+              run: () => session.send(text),
+              timeoutMs: getTimeoutMs(options, provider)
+            });
+            return;
+          } catch (error) {
+            const shouldFallback = await failProvider({
+              attempt: nextProviderIndex,
+              error,
+              operation: "send",
+              provider,
+              startedAt
+            });
+            const nextProvider = order[nextProviderIndex];
+            if (!shouldFallback || !nextProvider) {
+              throw error;
+            }
+            nextProviderIndex += 1;
+            await session.close("tts-provider-fallback").catch(() => {});
+            await openProvider(nextProvider, nextProviderIndex);
+          }
+        }
+      };
+      return {
+        close: async (reason) => {
+          await activeSession?.close(reason);
+          activeSession = undefined;
+          activeProvider = undefined;
+          await emitter.emit("close", {
+            reason,
+            type: "close"
+          });
+        },
+        on: emitter.on,
+        send: sendWithFallback
+      };
     }
   };
 };
@@ -8116,6 +11820,169 @@ var createVoiceMemoryStore = () => {
   };
   return { get, getOrCreate, list, remove, set };
 };
+// src/opsWebhook.ts
+import { Elysia as Elysia12 } from "elysia";
+var toHex5 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signVoiceOpsWebhookBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  return `sha256=${toHex5(new Uint8Array(signature))}`;
+};
+var timingSafeEqual = (left, right) => {
+  const encoder = new TextEncoder;
+  const leftBytes = encoder.encode(left);
+  const rightBytes = encoder.encode(right);
+  if (leftBytes.length !== rightBytes.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let index = 0;index < leftBytes.length; index += 1) {
+    diff |= leftBytes[index] ^ rightBytes[index];
+  }
+  return diff === 0;
+};
+var resolveWebhookLink = async (resolver, event) => {
+  if (typeof resolver === "function") {
+    return resolver({
+      event
+    });
+  }
+  return resolver;
+};
+var joinBaseUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var buildVoiceOpsWebhookEntity = (event) => ({
+  disposition: asString(event.payload.disposition),
+  outcome: asString(event.payload.outcome),
+  priority: asString(event.payload.priority),
+  queue: asString(event.payload.queue),
+  reviewId: asString(event.payload.reviewId),
+  scenarioId: asString(event.payload.scenarioId),
+  sessionId: asString(event.payload.sessionId),
+  status: asString(event.payload.status),
+  target: asString(event.payload.target),
+  taskId: asString(event.payload.taskId)
+});
+var createVoiceOpsWebhookEnvelope = async (input) => {
+  const entity = buildVoiceOpsWebhookEntity(input.event);
+  const replayHref = await resolveWebhookLink(input.replayHref, input.event) ?? (input.baseUrl && entity.sessionId ? joinBaseUrl(input.baseUrl, `/api/voice-sessions/${encodeURIComponent(entity.sessionId)}/replay`) : undefined);
+  const links = {
+    event: await resolveWebhookLink(input.eventHref, input.event),
+    replay: replayHref,
+    review: await resolveWebhookLink(input.reviewHref, input.event),
+    task: await resolveWebhookLink(input.taskHref, input.event)
+  };
+  return {
+    entity,
+    event: {
+      createdAt: input.event.createdAt,
+      id: input.event.id,
+      payload: input.event.payload,
+      type: input.event.type
+    },
+    links: links.event || links.replay || links.review || links.task ? links : undefined,
+    schemaVersion: 1,
+    source: "absolutejs-voice"
+  };
+};
+var createVoiceOpsWebhookSink = (options) => createVoiceIntegrationHTTPSink({
+  ...options,
+  body: ({ event }) => createVoiceOpsWebhookEnvelope({
+    baseUrl: options.baseUrl,
+    event,
+    eventHref: options.eventHref,
+    replayHref: options.replayHref,
+    reviewHref: options.reviewHref,
+    taskHref: options.taskHref
+  }),
+  kind: options.kind ?? "ops-webhook"
+});
+var verifyVoiceOpsWebhookSignature = async (input) => {
+  if (!input.secret) {
+    return {
+      ok: false,
+      reason: "missing-secret"
+    };
+  }
+  if (!input.signature) {
+    return {
+      ok: false,
+      reason: "missing-signature"
+    };
+  }
+  if (!input.signature.startsWith("sha256=")) {
+    return {
+      ok: false,
+      reason: "unsupported-algorithm"
+    };
+  }
+  if (!input.timestamp) {
+    return {
+      ok: false,
+      reason: "missing-timestamp"
+    };
+  }
+  const timestampMs = Number(input.timestamp);
+  const toleranceMs = Math.max(0, input.toleranceMs ?? 5 * 60 * 1000);
+  if (!Number.isFinite(timestampMs) || toleranceMs > 0 && Math.abs((input.now ?? Date.now()) - timestampMs) > toleranceMs) {
+    return {
+      ok: false,
+      reason: "stale-timestamp"
+    };
+  }
+  const expected = await signVoiceOpsWebhookBody({
+    body: input.body,
+    secret: input.secret,
+    timestamp: input.timestamp
+  });
+  if (!timingSafeEqual(expected, input.signature)) {
+    return {
+      ok: false,
+      reason: "invalid-signature"
+    };
+  }
+  return {
+    ok: true
+  };
+};
+var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-ops/webhook";
+  return new Elysia12().post(path, async ({ body, request, set }) => {
+    const bodyText = typeof body === "string" ? body : JSON.stringify(body);
+    if (options.signingSecret) {
+      const verification = await verifyVoiceOpsWebhookSignature({
+        body: bodyText,
+        secret: options.signingSecret,
+        signature: request.headers.get("x-absolutejs-signature"),
+        timestamp: request.headers.get("x-absolutejs-timestamp"),
+        toleranceMs: options.toleranceMs
+      });
+      if (!verification.ok) {
+        set.status = 401;
+        return {
+          ok: false,
+          reason: verification.reason
+        };
+      }
+    }
+    const envelope = JSON.parse(bodyText);
+    await options.onEnvelope?.({
+      envelope,
+      request
+    });
+    return {
+      eventId: envelope.event?.id,
+      ok: true,
+      type: envelope.event?.type
+    };
+  }, {
+    parse: "text"
+  });
+};
 // src/queue.ts
 var releaseLeaseScript = `
 if redis.call("GET", KEYS[1]) == ARGV[1] then
@@ -8187,6 +12054,8 @@ var shouldDeadLetterSinkEvent = (event, sinks, maxFailures) => typeof maxFailure
 var shouldDeadLetterTask = (task, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (task.processingAttempts ?? 0) >= maxFailures;
 var shouldProcessTraceDeliveryStatus = (status, allowed) => allowed.includes(status);
 var shouldDeadLetterTraceDelivery = (delivery, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (delivery.deliveryAttempts ?? 0) >= maxFailures;
+var shouldProcessHandoffDeliveryStatus = (status, allowed) => allowed.includes(status);
+var shouldDeadLetterHandoffDelivery = (delivery, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (delivery.deliveryAttempts ?? 0) >= maxFailures;
 var summarizeVoiceIntegrationEvents = (events, input = {}) => {
   const buildSummary = async () => {
     const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((event) => event.id) : []);
@@ -8268,6 +12137,48 @@ var summarizeVoiceTraceSinkDeliveries = (deliveries, input = {}) => {
   };
   return buildSummary();
 };
+var summarizeVoiceHandoffDeliveries = (deliveries, input = {}) => {
+  const buildSummary = async () => {
+    const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((delivery) => delivery.id) : []);
+    const byAction = new Map;
+    const summary = {
+      byAction: [],
+      deadLettered: 0,
+      delivered: 0,
+      failed: 0,
+      pending: 0,
+      retryEligible: 0,
+      skipped: 0,
+      total: deliveries.length
+    };
+    for (const delivery of deliveries) {
+      byAction.set(delivery.action, (byAction.get(delivery.action) ?? 0) + 1);
+      if (deadLetterIds.has(delivery.id)) {
+        summary.deadLettered += 1;
+      }
+      switch (delivery.deliveryStatus) {
+        case "delivered":
+          summary.delivered += 1;
+          break;
+        case "failed":
+          summary.failed += 1;
+          if ((delivery.deliveryAttempts ?? 0) > 0) {
+            summary.retryEligible += 1;
+          }
+          break;
+        case "skipped":
+          summary.skipped += 1;
+          break;
+        case "pending":
+          summary.pending += 1;
+          break;
+      }
+    }
+    summary.byAction = [...byAction.entries()].sort((left, right) => right[1] - left[1]);
+    return summary;
+  };
+  return buildSummary();
+};
 var summarizeVoiceOpsTaskQueue = (tasks, input = {}) => {
   const buildSummary = async () => {
     const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((task) => task.id) : []);
@@ -8697,6 +12608,108 @@ var createVoiceTraceSinkDeliveryWorkerLoop = (options) => {
     tick
   };
 };
+var createVoiceHandoffDeliveryWorker = (options) => {
+  const allowedStatuses = options.statuses ?? ["pending", "failed"];
+  const leaseMs = Math.max(1, options.leaseMs ?? 30000);
+  return {
+    drain: async () => {
+      const result = {
+        alreadyProcessed: 0,
+        attempted: 0,
+        deadLettered: 0,
+        delivered: 0,
+        failed: 0,
+        skipped: 0
+      };
+      const deliveries = [...await options.deliveries.list()].sort((left, right) => left.createdAt - right.createdAt);
+      for (const delivery of deliveries) {
+        if (!shouldProcessHandoffDeliveryStatus(delivery.deliveryStatus, allowedStatuses)) {
+          continue;
+        }
+        if (shouldDeadLetterHandoffDelivery(delivery, options.maxFailures)) {
+          await options.deadLetters?.set(delivery.id, delivery);
+          await options.onDeadLetter?.(delivery);
+          result.deadLettered += 1;
+          continue;
+        }
+        const claimed = await options.leases.claim({
+          leaseMs,
+          taskId: delivery.id,
+          workerId: options.workerId
+        });
+        if (!claimed) {
+          continue;
+        }
+        try {
+          const idempotencyKey = `${delivery.id}:handoff`;
+          if (options.idempotency && await options.idempotency.has(idempotencyKey)) {
+            result.alreadyProcessed += 1;
+            continue;
+          }
+          result.attempted += 1;
+          const updatedDelivery = await deliverVoiceHandoffDelivery({
+            adapters: options.adapters,
+            api: options.api,
+            delivery,
+            failMode: options.failMode
+          });
+          await options.deliveries.set(updatedDelivery.id, updatedDelivery);
+          if (updatedDelivery.deliveryStatus === "delivered" || updatedDelivery.deliveryStatus === "skipped") {
+            await options.idempotency?.set(idempotencyKey, {
+              ttlSeconds: options.idempotencyTtlSeconds
+            });
+          }
+          if (updatedDelivery.deliveryStatus === "delivered") {
+            result.delivered += 1;
+          } else if (updatedDelivery.deliveryStatus === "skipped") {
+            result.skipped += 1;
+          } else if (updatedDelivery.deliveryStatus === "failed") {
+            result.failed += 1;
+            if (shouldDeadLetterHandoffDelivery(updatedDelivery, options.maxFailures)) {
+              await options.deadLetters?.set(updatedDelivery.id, updatedDelivery);
+              await options.onDeadLetter?.(updatedDelivery);
+              result.deadLettered += 1;
+            }
+          }
+        } finally {
+          await options.leases.release({
+            taskId: delivery.id,
+            workerId: options.workerId
+          });
+        }
+      }
+      return result;
+    }
+  };
+};
+var createVoiceHandoffDeliveryWorkerLoop = (options) => {
+  const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? 1000);
+  let timer;
+  let running = false;
+  const tick = async () => options.worker.drain();
+  return {
+    isRunning: () => running,
+    start: () => {
+      if (timer) {
+        return;
+      }
+      running = true;
+      timer = setInterval(() => {
+        tick().catch((error) => {
+          options.onError?.(error);
+        });
+      }, pollIntervalMs);
+    },
+    stop: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+      running = false;
+    },
+    tick
+  };
+};
 var createVoiceOpsTaskWorker = (options) => {
   const leaseMs = Math.max(1, options.leaseMs ?? 30000);
   const getTask = async (taskId) => {
@@ -8832,10 +12845,10 @@ var createVoiceOpsTaskProcessorWorker = (options) => ({
         result.completed += 1;
       } catch (error) {
         await options.onError?.(error, task);
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage3 = error instanceof Error ? error.message : String(error);
         const failedTask = failVoiceOpsTask(task, {
           actor: task.claimedBy ?? "ops-worker",
-          error: errorMessage
+          error: errorMessage3
         });
         if (shouldDeadLetterTask(failedTask, options.maxFailures)) {
           const deadLetterTask = deadLetterVoiceOpsTask(failedTask, {
@@ -9648,7 +13661,7 @@ var createVoiceSTTRoutingCorrectionHandler = (mode = "generic") => {
 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 escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var normalizeOnTurn2 = (handler) => {
   if (handler.length > 1) {
     const directHandler = handler;
@@ -9844,8 +13857,8 @@ var createTwilioSocketAdapter = (socket, getState) => ({
   }
 });
 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>`;
+  const parameters = Object.entries(options.parameters ?? {}).filter((entry) => entry[1] !== undefined).map(([name, value]) => `<Parameter name="${escapeXml2(name)}" value="${escapeXml2(String(value))}" />`).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapeXml2(options.streamUrl)}"${options.track ? ` track="${escapeXml2(options.track)}"` : ""}${options.streamName ? ` name="${escapeXml2(options.streamName)}"` : ""}>${parameters}</Stream></Connect></Response>`;
 };
 var createTwilioMediaStreamBridge = (socket, options) => {
   const runtimePreset = resolveVoiceRuntimePreset(options.preset);
@@ -10081,26 +14094,41 @@ export {
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
   voice,
+  verifyVoiceOpsWebhookSignature,
+  validateVoiceWorkflowRouteResult,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
+  summarizeVoiceSessions,
+  summarizeVoiceSessionReplay,
+  summarizeVoiceRoutingDecision,
+  summarizeVoiceProviderHealth,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceHandoffHealth,
+  summarizeVoiceHandoffDeliveries,
   summarizeVoiceAssistantRuns,
+  summarizeVoiceAssistantHealth,
+  summarizeVoiceAppKitStatus,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
+  runVoiceSessionEvals,
+  runVoiceScenarioFixtureEvals,
+  runVoiceScenarioEvals,
   resolveVoiceTraceRedactionOptions,
   resolveVoiceSTTRoutingStrategy,
   resolveVoiceRuntimePreset,
+  resolveVoiceProviderRoutingPolicyPreset,
   resolveVoiceOutcomeRecipe,
   resolveVoiceOpsTaskPolicy,
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceDiagnosticsTraceFilter,
   resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
@@ -10108,15 +14136,28 @@ export {
   reopenVoiceOpsTask,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
+  renderVoiceSessionsHTML,
+  renderVoiceScenarioFixtureEvalHTML,
+  renderVoiceScenarioEvalHTML,
+  renderVoiceResilienceHTML,
+  renderVoiceQualityHTML,
+  renderVoiceProviderHealthHTML,
+  renderVoiceOpsConsoleHTML,
+  renderVoiceHandoffHealthHTML,
+  renderVoiceEvalHTML,
+  renderVoiceEvalBaselineHTML,
   renderVoiceCallReviewMarkdown,
   renderVoiceCallReviewHTML,
+  renderVoiceAssistantHealthHTML,
   redactVoiceTraceText,
   redactVoiceTraceEvents,
   redactVoiceTraceEvent,
+  recordVoiceWorkflowContractTrace,
   recordVoiceRuntimeOps,
   pruneVoiceTraceEvents,
   matchesVoiceOpsTaskAssignmentRule,
   markVoiceOpsTaskSLABreached,
+  listVoiceRoutingEvents,
   listVoiceOpsTasks,
   isVoiceOpsTaskOverdue,
   heartbeatVoiceOpsTask,
@@ -10125,17 +14166,26 @@ export {
   failVoiceOpsTask,
   exportVoiceTrace,
   evaluateVoiceTrace,
+  evaluateVoiceQuality,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
   deliverVoiceIntegrationEventToSinks,
   deliverVoiceIntegrationEvent,
+  deliverVoiceHandoffDelivery,
+  deliverVoiceHandoff,
   decodeTwilioMulawBase64,
   deadLetterVoiceOpsTask,
   createVoiceZendeskTicketUpdateSink,
   createVoiceZendeskTicketSyncSinks,
   createVoiceZendeskTicketSink,
+  createVoiceWorkflowScenario,
+  createVoiceWorkflowContractPreset,
+  createVoiceWorkflowContractHandler,
+  createVoiceWorkflowContract,
+  createVoiceWebhookHandoffAdapter,
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
+  createVoiceTwilioRedirectHandoffAdapter,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
   createVoiceTraceSinkDeliveryWorker,
@@ -10147,9 +14197,17 @@ export {
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
+  createVoiceTTSProviderRouter,
+  createVoiceSessionsJSONHandler,
+  createVoiceSessionsHTMLHandler,
+  createVoiceSessionReplayRoutes,
+  createVoiceSessionReplayJSONHandler,
+  createVoiceSessionReplayHTMLHandler,
   createVoiceSessionRecord,
+  createVoiceSessionListRoutes,
   createVoiceSession,
   createVoiceSTTRoutingCorrectionHandler,
+  createVoiceSTTProviderRouter,
   createVoiceSQLiteTraceSinkDeliveryStore,
   createVoiceSQLiteTraceEventStore,
   createVoiceSQLiteTaskStore,
@@ -10159,9 +14217,16 @@ export {
   createVoiceSQLiteIntegrationEventStore,
   createVoiceSQLiteExternalObjectMapStore,
   createVoiceS3ReviewStore,
+  createVoiceRoutingDecisionSummary,
   createVoiceReviewSavedEvent,
+  createVoiceResilienceRoutes,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
+  createVoiceQualityRoutes,
+  createVoiceProviderRouter,
+  createVoiceProviderHealthRoutes,
+  createVoiceProviderHealthJSONHandler,
+  createVoiceProviderHealthHTMLHandler,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
   createVoicePostgresTaskStore,
@@ -10170,13 +14235,18 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOpsWebhookSink,
+  createVoiceOpsWebhookReceiverRoutes,
+  createVoiceOpsWebhookEnvelope,
   createVoiceOpsTaskWorker,
   createVoiceOpsTaskProcessorWorkerLoop,
   createVoiceOpsTaskProcessorWorker,
   createVoiceOpsRuntime,
+  createVoiceOpsConsoleRoutes,
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryHandoffDeliveryStore,
   createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
@@ -10189,18 +14259,28 @@ export {
   createVoiceHubSpotTaskSyncSinks,
   createVoiceHubSpotTaskSink,
   createVoiceHelpdeskTicketSink,
+  createVoiceHandoffHealthRoutes,
+  createVoiceHandoffHealthJSONHandler,
+  createVoiceHandoffHealthHTMLHandler,
+  createVoiceHandoffDeliveryWorkerLoop,
+  createVoiceHandoffDeliveryWorker,
+  createVoiceHandoffDeliveryRecord,
   createVoiceFileTraceSinkDeliveryStore,
   createVoiceFileTraceEventStore,
   createVoiceFileTaskStore,
   createVoiceFileSessionStore,
+  createVoiceFileScenarioFixtureStore,
   createVoiceFileRuntimeStorage,
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileEvalBaselineStore,
   createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
+  createVoiceEvalRoutes,
+  createVoiceDiagnosticsRoutes,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
@@ -10208,7 +14288,12 @@ export {
   createVoiceCRMActivitySink,
   createVoiceAssistantMemoryRecord,
   createVoiceAssistantMemoryHandle,
+  createVoiceAssistantHealthRoutes,
+  createVoiceAssistantHealthJSONHandler,
+  createVoiceAssistantHealthHTMLHandler,
   createVoiceAssistant,
+  createVoiceAppKitRoutes,
+  createVoiceAppKit,
   createVoiceAgentTool,
   createVoiceAgentSquad,
   createVoiceAgent,
@@ -10229,13 +14314,17 @@ export {
   createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
+  compareVoiceEvalBaseline,
   claimVoiceOpsTask,
   buildVoiceTraceReplay,
   buildVoiceOpsTaskFromSLABreach,
   buildVoiceOpsTaskFromReview,
+  buildVoiceOpsConsoleReport,
+  buildVoiceDiagnosticsMarkdown,
   assignVoiceOpsTask,
   applyVoiceOpsTaskPolicy,
   applyVoiceOpsTaskAssignmentRule,
+  applyVoiceHandoffDeliveryResult,
   applyRiskTieredPhraseHintCorrections,
   applyPhraseHintCorrections,
   TURN_PROFILE_DEFAULTS