@absolutejs/voice 0.0.22-beta.67 → 0.0.22-beta.670

package/dist/drizzle/index.js

@@ -0,0 +1,3060 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __require = import.meta.require;
+
+// src/drizzle/assistantMemory.ts
+import { and, desc, eq } from "drizzle-orm";
+import { bigint, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+
+// src/core/assistantMemory.ts
+var createMemoryId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
+var createVoiceAssistantMemoryHandle = async (input) => {
+  const namespace = await resolveVoiceAssistantMemoryNamespace({
+    assistantId: input.assistantId,
+    context: input.context,
+    memory: input.memory,
+    session: input.session
+  });
+  const trace = async (event) => {
+    await input.trace?.append({
+      at: Date.now(),
+      payload: {
+        assistantId: input.assistantId,
+        namespace,
+        ...event
+      },
+      scenarioId: input.session.scenarioId,
+      sessionId: input.session.id,
+      type: "assistant.memory"
+    });
+  };
+  return {
+    namespace,
+    delete: async (key) => {
+      await input.memory.store.delete({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "delete",
+        key
+      });
+    },
+    get: async (key) => {
+      const record = await input.memory.store.get({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "get",
+        found: Boolean(record),
+        key
+      });
+      return record?.value;
+    },
+    list: async () => {
+      const records = await input.memory.store.list({
+        assistantId: input.assistantId,
+        namespace
+      });
+      await trace({
+        action: "list",
+        count: records.length
+      });
+      return records;
+    },
+    set: async (key, value, metadata) => {
+      const record = await input.memory.store.set({
+        assistantId: input.assistantId,
+        key,
+        metadata,
+        namespace,
+        value
+      });
+      await trace({
+        action: "set",
+        key
+      });
+      return record;
+    }
+  };
+};
+var createVoiceAssistantMemoryRecord = (input) => {
+  const now = Date.now();
+  return {
+    ...input,
+    createdAt: input.createdAt ?? input.updatedAt ?? now,
+    updatedAt: input.updatedAt ?? now
+  };
+};
+var createVoiceMemoryAssistantMemoryStore = () => {
+  const records = new Map;
+  return {
+    delete: async (input) => {
+      records.delete(createMemoryId(input));
+    },
+    get: async (input) => records.get(createMemoryId(input)),
+    list: async (input) => [...records.values()].filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt),
+    set: async (input) => {
+      const id = createMemoryId(input);
+      const existing = records.get(id);
+      const record = createVoiceAssistantMemoryRecord({
+        ...input,
+        createdAt: input.createdAt ?? existing?.createdAt,
+        updatedAt: input.updatedAt
+      });
+      records.set(id, record);
+      return record;
+    }
+  };
+};
+var resolveVoiceAssistantMemoryNamespace = async (input) => typeof input.memory.namespace === "function" ? await input.memory.namespace(input) : input.memory.namespace;
+
+// src/drizzle/assistantMemory.ts
+var voiceAssistantMemoryTable = pgTable("voice_assistant_memory", {
+  assistantId: text("assistant_id").notNull(),
+  id: text("id").primaryKey(),
+  key: text("key").notNull(),
+  namespace: text("namespace").notNull(),
+  payload: jsonb("payload").notNull(),
+  sortAt: bigint("sort_at", { mode: "number" }).notNull()
+});
+var voiceAssistantMemoryId = (input) => JSON.stringify([input.assistantId, input.namespace, input.key]);
+var createDrizzleAssistantMemoryStore = (db) => {
+  const get = async (input) => {
+    const rows = await db.select({ payload: voiceAssistantMemoryTable.payload }).from(voiceAssistantMemoryTable).where(eq(voiceAssistantMemoryTable.id, voiceAssistantMemoryId(input))).limit(1);
+    return rows[0]?.payload;
+  };
+  return {
+    get,
+    delete: async (input) => {
+      await db.delete(voiceAssistantMemoryTable).where(eq(voiceAssistantMemoryTable.id, voiceAssistantMemoryId(input)));
+    },
+    list: async (input) => {
+      const rows = await db.select({ payload: voiceAssistantMemoryTable.payload }).from(voiceAssistantMemoryTable).where(input.namespace === undefined ? eq(voiceAssistantMemoryTable.assistantId, input.assistantId) : and(eq(voiceAssistantMemoryTable.assistantId, input.assistantId), eq(voiceAssistantMemoryTable.namespace, input.namespace))).orderBy(desc(voiceAssistantMemoryTable.sortAt));
+      return rows.map((row) => row.payload);
+    },
+    set: async (input) => {
+      const existing = await get(input);
+      const record = createVoiceAssistantMemoryRecord({
+        ...input,
+        createdAt: input.createdAt ?? existing?.createdAt,
+        updatedAt: input.updatedAt
+      });
+      await db.insert(voiceAssistantMemoryTable).values({
+        assistantId: record.assistantId,
+        id: voiceAssistantMemoryId(record),
+        key: record.key,
+        namespace: record.namespace,
+        payload: record,
+        sortAt: record.updatedAt
+      }).onConflictDoUpdate({
+        set: {
+          payload: record,
+          sortAt: record.updatedAt
+        },
+        target: voiceAssistantMemoryTable.id
+      });
+      return record;
+    }
+  };
+};
+var createVoiceDrizzleAssistantMemoryStore = (options) => createDrizzleAssistantMemoryStore(options.db);
+
+// src/drizzle/shared.ts
+import { desc as desc2, eq as eq2 } from "drizzle-orm";
+import {
+  bigint as bigint2,
+  jsonb as jsonb2,
+  pgTable as pgTable2,
+  text as text2
+} from "drizzle-orm/pg-core";
+var voiceDocumentTable = (name) => pgTable2(name, {
+  id: text2("id").primaryKey(),
+  payload: jsonb2("payload").notNull(),
+  sortAt: bigint2("sort_at", { mode: "number" }).notNull()
+});
+var createVoiceDrizzleRecordStore = (input) => {
+  const get = async (id) => {
+    const rows = await input.db.select({ id: input.table.id, payload: input.table.payload }).from(input.table).where(eq2(input.table.id, id)).limit(1);
+    const row = rows[0];
+    return row === undefined ? undefined : input.decorate(row.id, row.payload);
+  };
+  const list = async () => {
+    const rows = await input.db.select({ id: input.table.id, payload: input.table.payload }).from(input.table).orderBy(desc2(input.table.sortAt), desc2(input.table.id));
+    return rows.map((row) => input.decorate(row.id, row.payload));
+  };
+  const set = async (id, value) => {
+    const decorated = input.decorate(id, value);
+    await input.db.insert(input.table).values({
+      id,
+      payload: decorated,
+      sortAt: input.getSortAt(decorated)
+    }).onConflictDoUpdate({
+      set: {
+        payload: decorated,
+        sortAt: input.getSortAt(decorated)
+      },
+      target: input.table.id
+    });
+  };
+  const remove = async (id) => {
+    await input.db.delete(input.table).where(eq2(input.table.id, id));
+  };
+  return { get, list, remove, set };
+};
+
+// src/drizzle/eval.ts
+var voiceEvalBaselineTable = voiceDocumentTable("voice_eval_baseline");
+var VOICE_EVAL_BASELINE_ID = "baseline";
+var createDrizzleEvalBaselineStore = (db) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (_id, value) => value,
+    getSortAt: (value) => value.checkedAt,
+    table: voiceEvalBaselineTable
+  });
+  return {
+    get: async () => store.get(VOICE_EVAL_BASELINE_ID),
+    set: async (report) => {
+      await store.set(VOICE_EVAL_BASELINE_ID, report);
+    }
+  };
+};
+var createVoiceDrizzleEvalBaselineStore = (options) => createDrizzleEvalBaselineStore(options.db);
+
+// src/drizzle/handoff.ts
+var voiceHandoffDeliveriesTable = voiceDocumentTable("voice_handoff_deliveries");
+var createDrizzleHandoffDeliveryStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (_id, value) => value,
+  getSortAt: (value) => value.createdAt,
+  table: voiceHandoffDeliveriesTable
+});
+var createVoiceDrizzleHandoffDeliveryStore = (options) => createDrizzleHandoffDeliveryStore(options.db);
+
+// src/drizzle/incidentBundle.ts
+var voiceIncidentBundlesTable = voiceDocumentTable("voice_incident_bundles");
+var matchesIncidentBundleFilter = (artifact, filter) => {
+  if (filter.sessionId && artifact.sessionId !== filter.sessionId) {
+    return false;
+  }
+  if (typeof filter.expiredAt === "number" && (artifact.expiresAt === undefined || artifact.expiresAt > filter.expiredAt)) {
+    return false;
+  }
+  return true;
+};
+var createVoiceDrizzleIncidentBundleStore = (options) => {
+  const store = createVoiceDrizzleRecordStore({
+    db: options.db,
+    decorate: (id, value) => ({
+      ...value,
+      id
+    }),
+    getSortAt: (value) => value.createdAt,
+    table: voiceIncidentBundlesTable
+  });
+  return {
+    get: store.get,
+    remove: store.remove,
+    set: store.set,
+    list: async (filter = {}) => (await store.list()).filter((artifact) => matchesIncidentBundleFilter(artifact, filter))
+  };
+};
+
+// src/drizzle/observabilityExport.ts
+var voiceObservabilityExportDeliveryReceiptsTable = voiceDocumentTable("voice_observability_export_receipts");
+var createVoiceDrizzleObservabilityExportDeliveryReceiptStore = (options) => createVoiceDrizzleRecordStore({
+  db: options.db,
+  decorate: (id, value) => ({
+    ...value,
+    id
+  }),
+  getSortAt: (value) => value.checkedAt,
+  table: voiceObservabilityExportDeliveryReceiptsTable
+});
+
+// src/drizzle/proofTrends.ts
+var voiceRealCallProfileEvidenceTable = voiceDocumentTable("voice_real_call_profile_evidence");
+var voiceRealCallProfileRecoveryJobsTable = voiceDocumentTable("voice_real_call_profile_recovery_jobs");
+var parseRealCallProfileEvidenceBoundary = (value) => {
+  if (value === undefined) {
+    return;
+  }
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return Date.parse(value);
+};
+var readRealCallProfileEvidenceSortTime = (evidence, fallback) => Date.parse(evidence.generatedAt ?? fallback) || Date.parse(fallback);
+var matchesRealCallProfileEvidenceListOptions = (record, input) => {
+  const evidenceTime = readRealCallProfileEvidenceSortTime(record, record.createdAt);
+  const since = parseRealCallProfileEvidenceBoundary(input.since);
+  const until = parseRealCallProfileEvidenceBoundary(input.until);
+  return (!input.profileId || record.profileId === input.profileId) && (!input.sessionId || record.sessionId === input.sessionId) && (since === undefined || Number.isNaN(since) || evidenceTime >= since) && (until === undefined || Number.isNaN(until) || evidenceTime <= until);
+};
+var matchesRealCallProfileRecoveryJobListOptions = (job, input) => (!input.actionId || job.actionId === input.actionId) && (!input.status || job.status === input.status);
+var createDrizzleRealCallProfileRecoveryJobStore = (db, options = {}) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (_id, value) => value,
+    getSortAt: (value) => Date.parse(value.updatedAt) || Date.now(),
+    table: voiceRealCallProfileRecoveryJobsTable
+  });
+  const now = () => (options.now ?? (() => new Date))().toISOString();
+  const createId = () => `${options.idPrefix ?? "voice-recovery-job"}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return {
+    get: store.get,
+    create: async (input) => {
+      const createdAt = input.createdAt ?? now();
+      const job = {
+        actionId: input.actionId,
+        createdAt,
+        id: input.id ?? createId(),
+        message: input.message,
+        status: input.status ?? "queued",
+        updatedAt: createdAt
+      };
+      await store.set(job.id, job);
+      return job;
+    },
+    list: async (input = {}) => {
+      const limit = Number.isFinite(input.limit) && input.limit !== undefined && input.limit > 0 ? Math.floor(input.limit) : 50;
+      return (await store.list()).filter((job) => matchesRealCallProfileRecoveryJobListOptions(job, input)).slice(0, limit);
+    },
+    update: async (id, update) => {
+      const existing = await store.get(id);
+      if (!existing) {
+        return;
+      }
+      const next = {
+        ...existing,
+        ...update,
+        updatedAt: update.updatedAt ?? now()
+      };
+      await store.set(id, next);
+      return next;
+    }
+  };
+};
+var createDrizzleRealCallProfileEvidenceStore = (db, options = {}) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (_id, value) => value,
+    getSortAt: (value) => readRealCallProfileEvidenceSortTime(value, value.createdAt),
+    table: voiceRealCallProfileEvidenceTable
+  });
+  const now = () => (options.now ?? (() => new Date))().toISOString();
+  const createId = () => `${options.idPrefix ?? "voice-profile-evidence"}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return {
+    get: store.get,
+    remove: store.remove,
+    append: async (input) => {
+      const record = {
+        ...input,
+        createdAt: input.createdAt ?? now(),
+        id: input.id ?? createId()
+      };
+      await store.set(record.id, record);
+      return record;
+    },
+    list: async (input = {}) => {
+      const limit = Number.isFinite(input.limit) && input.limit !== undefined && input.limit > 0 ? Math.floor(input.limit) : 500;
+      return (await store.list()).filter((record) => matchesRealCallProfileEvidenceListOptions(record, input)).slice(0, limit);
+    }
+  };
+};
+var createVoiceDrizzleRealCallProfileEvidenceStore = (options) => createDrizzleRealCallProfileEvidenceStore(options.db, {
+  idPrefix: options.idPrefix,
+  now: options.now
+});
+var createVoiceDrizzleRealCallProfileRecoveryJobStore = (options) => createDrizzleRealCallProfileRecoveryJobStore(options.db, {
+  idPrefix: options.idPrefix,
+  now: options.now
+});
+
+// src/core/audit.ts
+var includes = (filter, value) => {
+  if (!filter) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  return Array.isArray(filter) ? filter.includes(value) : filter === value;
+};
+var createVoiceAuditEvent = (event) => ({
+  ...event,
+  at: event.at ?? Date.now(),
+  id: event.id ?? crypto.randomUUID()
+});
+var createVoiceAuditLogger = (store) => ({
+  handoff: (input) => recordVoiceHandoffAuditEvent({ ...input, store }),
+  operatorAction: (input) => recordVoiceOperatorAuditEvent({ ...input, store }),
+  providerCall: (input) => recordVoiceProviderAuditEvent({ ...input, store }),
+  record: (event) => recordVoiceAuditEvent(store, event),
+  retention: (input) => recordVoiceRetentionAuditEvent({ ...input, store }),
+  toolCall: (input) => recordVoiceToolAuditEvent({ ...input, store })
+});
+var createVoiceMemoryAuditEventStore = () => {
+  const events = new Map;
+  return {
+    append: (event) => {
+      const stored = createVoiceAuditEvent(event);
+      events.set(stored.id, stored);
+      return stored;
+    },
+    get: (id) => events.get(id),
+    list: (filter) => filterVoiceAuditEvents([...events.values()], filter)
+  };
+};
+var createVoiceScopedAuditEventStore = (store, scope) => {
+  const upstreamFilter = (filter = {}) => {
+    const next = { ...filter };
+    delete next.limit;
+    if (scope.actorId !== undefined) {
+      delete next.actorId;
+    }
+    if (scope.outcome !== undefined) {
+      delete next.outcome;
+    }
+    if (scope.resourceId !== undefined) {
+      delete next.resourceId;
+    }
+    if (scope.resourceType !== undefined) {
+      delete next.resourceType;
+    }
+    if (scope.sessionId !== undefined) {
+      delete next.sessionId;
+    }
+    if (scope.traceId !== undefined) {
+      delete next.traceId;
+    }
+    if (scope.type !== undefined) {
+      delete next.type;
+    }
+    return next;
+  };
+  const scopedFilter = (filter = {}) => ({
+    ...filter,
+    ...scope
+  });
+  return {
+    append: (event) => store.append(event),
+    get: (id) => store.get(id),
+    list: async (filter) => filterVoiceAuditEvents(await store.list(upstreamFilter(filter)), scopedFilter(filter))
+  };
+};
+var filterVoiceAuditEvents = (events, filter = {}) => {
+  const sorted = events.filter((event) => {
+    if (!includes(filter.type, event.type)) {
+      return false;
+    }
+    if (!includes(filter.outcome, event.outcome)) {
+      return false;
+    }
+    if (filter.actorId && event.actor?.id !== filter.actorId) {
+      return false;
+    }
+    if (filter.resourceId && event.resource?.id !== filter.resourceId) {
+      return false;
+    }
+    if (filter.resourceType && event.resource?.type !== filter.resourceType) {
+      return false;
+    }
+    if (filter.sessionId && event.sessionId !== filter.sessionId) {
+      return false;
+    }
+    if (filter.traceId && event.traceId !== filter.traceId) {
+      return false;
+    }
+    if (typeof filter.after === "number" && event.at <= filter.after) {
+      return false;
+    }
+    if (typeof filter.afterOrAt === "number" && event.at < filter.afterOrAt) {
+      return false;
+    }
+    if (typeof filter.before === "number" && event.at >= filter.before) {
+      return false;
+    }
+    if (typeof filter.beforeOrAt === "number" && event.at > filter.beforeOrAt) {
+      return false;
+    }
+    return true;
+  }).sort((left, right) => left.at - right.at || left.id.localeCompare(right.id));
+  return typeof filter.limit === "number" && filter.limit >= 0 ? sorted.slice(0, filter.limit) : sorted;
+};
+var recordVoiceAuditEvent = (store, event) => store.append(createVoiceAuditEvent(event));
+var recordVoiceHandoffAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: "handoff",
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    fromAgentId: input.fromAgentId,
+    reason: input.reason,
+    target: input.target,
+    toAgentId: input.toAgentId
+  },
+  resource: {
+    id: input.toAgentId ?? input.target,
+    type: "handoff"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "handoff"
+});
+var recordVoiceOperatorAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: input.action,
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome ?? "success",
+  payload: input.payload,
+  resource: input.resource,
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "operator.action"
+});
+var recordVoiceProviderAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: `${input.kind}.provider.call`,
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    cost: input.cost,
+    elapsedMs: input.elapsedMs,
+    error: input.error,
+    kind: input.kind,
+    model: input.model,
+    provider: input.provider
+  },
+  resource: {
+    id: input.provider,
+    type: "provider"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "provider.call"
+});
+var recordVoiceRetentionAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: input.dryRun ? "retention.plan" : "retention.apply",
+  actor: input.actor ?? {
+    id: "voice-retention",
+    kind: "system"
+  },
+  metadata: input.metadata,
+  outcome: "success",
+  payload: {
+    deletedCount: input.report.deletedCount,
+    dryRun: input.dryRun,
+    scopes: input.report.scopes
+  },
+  resource: {
+    type: "retention-policy"
+  },
+  type: "retention.policy"
+});
+var recordVoiceToolAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: "tool.call",
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    elapsedMs: input.elapsedMs,
+    error: input.error,
+    toolCallId: input.toolCallId,
+    toolName: input.toolName
+  },
+  resource: {
+    id: input.toolName,
+    type: "tool"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "tool.call"
+});
+
+// src/core/ops.ts
+var createVoiceExternalObjectMap = (input) => {
+  const at = input.at ?? Date.now();
+  return {
+    createdAt: at,
+    externalId: input.externalId,
+    id: createVoiceExternalObjectMapId(input),
+    provider: input.provider,
+    sinkId: input.sinkId,
+    sourceId: input.sourceId,
+    sourceType: input.sourceType,
+    updatedAt: at
+  };
+};
+var createVoiceExternalObjectMapId = (input) => [
+  input.provider,
+  input.sinkId ?? "default",
+  encodeURIComponent(input.sourceId)
+].join(":");
+var sleep = async (delayMs) => {
+  if (delayMs <= 0) {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+};
+var toHex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signVoiceIntegrationWebhookBody = 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 payload = encoder.encode(`${input.timestamp}.${input.body}`);
+  const signature = await crypto.subtle.sign("HMAC", key, payload);
+  return `sha256=${toHex(new Uint8Array(signature))}`;
+};
+var createVoiceWebhookDeliveryError = (input) => {
+  if (input.response) {
+    const statusText = input.response.statusText?.trim();
+    return `Attempt ${input.attempt} failed with webhook response ${input.response.status}${statusText ? ` ${statusText}` : ""}.`;
+  }
+  if (input.error instanceof Error) {
+    return `Attempt ${input.attempt} failed: ${input.error.message}`;
+  }
+  return `Attempt ${input.attempt} failed: ${String(input.error)}`;
+};
+var deliverVoiceIntegrationEvent = async (input) => {
+  const previousAttempts = input.event.deliveryAttempts ?? 0;
+  const matchesConfiguredTypes = input.webhook.eventTypes === undefined ? true : input.webhook.eventTypes.includes(input.event.type);
+  if (!matchesConfiguredTypes) {
+    return {
+      ...input.event,
+      deliveryAttempts: 0,
+      deliveryError: undefined,
+      deliveryStatus: "skipped"
+    };
+  }
+  const fetchImpl = input.webhook.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    return {
+      ...input.event,
+      deliveredTo: input.webhook.url,
+      deliveryAttempts: 0,
+      deliveryError: "Webhook delivery failed: fetch is not available in this runtime.",
+      deliveryStatus: "failed"
+    };
+  }
+  const maxRetries = Math.max(0, input.webhook.retries ?? 0);
+  const backoffMs = Math.max(0, input.webhook.backoffMs ?? 250);
+  const timeoutMs = Math.max(0, input.webhook.timeoutMs ?? 1e4);
+  const body = JSON.stringify({
+    createdAt: input.event.createdAt,
+    id: input.event.id,
+    payload: input.event.payload,
+    type: input.event.type
+  });
+  let lastError = "Webhook delivery failed.";
+  for (let attempt = 1;attempt <= maxRetries + 1; attempt += 1) {
+    let controller;
+    let timeout;
+    try {
+      const headers = {
+        "content-type": "application/json",
+        ...input.webhook.headers
+      };
+      if (input.webhook.signingSecret) {
+        const timestamp = String(Date.now());
+        headers["x-absolutejs-timestamp"] = timestamp;
+        headers["x-absolutejs-signature"] = await signVoiceIntegrationWebhookBody({
+          body,
+          secret: input.webhook.signingSecret,
+          timestamp
+        });
+      }
+      controller = timeoutMs > 0 ? new AbortController : undefined;
+      const activeController = controller;
+      timeout = activeController && timeoutMs > 0 ? setTimeout(() => activeController.abort(), timeoutMs) : undefined;
+      const response = await fetchImpl(input.webhook.url, {
+        body,
+        headers,
+        method: "POST",
+        signal: controller?.signal
+      });
+      if (response.ok) {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        return {
+          ...input.event,
+          deliveredAt: Date.now(),
+          deliveredTo: input.webhook.url,
+          deliveryAttempts: previousAttempts + attempt,
+          deliveryError: undefined,
+          deliveryStatus: "delivered"
+        };
+      }
+      lastError = createVoiceWebhookDeliveryError({
+        attempt,
+        error: new Error(`HTTP ${response.status}`),
+        response
+      });
+    } catch (error) {
+      lastError = createVoiceWebhookDeliveryError({
+        attempt,
+        error
+      });
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+    if (attempt <= maxRetries) {
+      await sleep(backoffMs * attempt);
+    }
+  }
+  return {
+    ...input.event,
+    deliveredTo: input.webhook.url,
+    deliveryAttempts: previousAttempts + maxRetries + 1,
+    deliveryError: lastError,
+    deliveryStatus: "failed"
+  };
+};
+var ensureTaskHistory = (task, entry) => ({
+  ...task,
+  history: [
+    ...task.history ?? [],
+    {
+      ...entry,
+      at: entry.at ?? Date.now()
+    }
+  ],
+  updatedAt: Date.now()
+});
+var buildVoiceOpsTaskFromReview = (review) => {
+  const createdAt = review.generatedAt ?? Date.now();
+  const common = {
+    createdAt,
+    history: [
+      {
+        actor: "system",
+        at: createdAt,
+        detail: review.postCall?.summary,
+        type: "created"
+      }
+    ],
+    id: `${review.id}:ops`,
+    intakeId: review.id,
+    outcome: review.summary.outcome,
+    recommendedAction: review.postCall?.recommendedAction ?? "Review the voice artifact and decide the next operator action.",
+    reviewId: review.id,
+    status: "open",
+    target: review.postCall?.target,
+    updatedAt: createdAt
+  };
+  switch (review.summary.outcome) {
+    case "voicemail":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "Caller reached voicemail and needs a callback follow-up.",
+        kind: "callback",
+        title: review.postCall?.target ? `Call back voicemail from ${review.postCall.target}` : "Call back voicemail lead"
+      };
+    case "no-answer":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "Live contact was not established and should be retried.",
+        kind: "callback",
+        title: "Retry no-answer call"
+      };
+    case "escalated":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The automated path escalated this call for human review.",
+        kind: "escalation",
+        title: "Review escalated call"
+      };
+    case "transferred":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The call was transferred and should be verified downstream.",
+        kind: "transfer-check",
+        title: review.postCall?.target ? `Verify transfer to ${review.postCall.target}` : "Verify call transfer"
+      };
+    case "failed":
+      return {
+        ...common,
+        description: review.postCall?.summary ?? "The call failed and needs operator review before retry.",
+        kind: "retry-review",
+        title: "Inspect failed call before retry"
+      };
+    default:
+      return null;
+  }
+};
+var withVoiceIntegrationEventId = (id, event) => ({
+  ...event,
+  id
+});
+var withVoiceOpsTaskId = (id, task) => ({
+  ...task,
+  id
+});
+var DEFAULT_VOICE_OPS_TASK_POLICIES = {
+  escalated: {
+    dueInMs: 10 * 60000,
+    name: "escalation-rapid-response",
+    priority: "urgent"
+  },
+  failed: {
+    dueInMs: 15 * 60000,
+    name: "failed-call-review",
+    priority: "high"
+  },
+  "no-answer": {
+    dueInMs: 2 * 60 * 60000,
+    name: "no-answer-retry",
+    priority: "normal"
+  },
+  transferred: {
+    dueInMs: 20 * 60000,
+    name: "transfer-verification",
+    priority: "normal"
+  },
+  voicemail: {
+    dueInMs: 30 * 60000,
+    name: "voicemail-callback",
+    priority: "high"
+  }
+};
+var applyVoiceOpsTaskAssignmentRule = (task, rule, input = {}) => {
+  const updatedTask = {
+    ...task,
+    assignee: rule.assign ?? task.assignee,
+    priority: rule.priority ?? task.priority,
+    queue: rule.queue ?? task.queue,
+    recommendedAction: rule.recommendedAction ?? task.recommendedAction,
+    title: rule.title ?? task.title
+  };
+  return ensureTaskHistory(updatedTask, {
+    actor: input.actor ?? "system",
+    at: input.at,
+    detail: input.detail ?? rule.description ?? (rule.name ? `Applied assignment rule ${rule.name}` : "Applied assignment rule"),
+    type: "assigned"
+  });
+};
+var applyVoiceOpsTaskPolicy = (task, policy, input = {}) => {
+  const at = input.at ?? Date.now();
+  const updatedTask = {
+    ...task,
+    assignee: policy.assignee ?? task.assignee,
+    dueAt: typeof policy.dueInMs === "number" ? at + Math.max(0, policy.dueInMs) : task.dueAt,
+    policyName: policy.name ?? task.policyName,
+    priority: policy.priority ?? task.priority,
+    queue: policy.queue ?? task.queue,
+    recommendedAction: policy.recommendedAction ?? task.recommendedAction,
+    target: policy.target ?? task.target,
+    title: policy.title ?? task.title
+  };
+  return ensureTaskHistory(updatedTask, {
+    actor: input.actor ?? "system",
+    at,
+    detail: input.detail ?? (policy.name ? `Applied ops policy ${policy.name}` : "Applied ops task policy"),
+    type: "policy-applied"
+  });
+};
+var assignVoiceOpsTask = (task, owner, input = {}) => {
+  const normalizedOwner = owner.trim() || "ops";
+  return ensureTaskHistory({
+    ...task,
+    assignee: normalizedOwner
+  }, {
+    actor: input.actor ?? normalizedOwner,
+    at: input.at,
+    detail: `Assigned to ${normalizedOwner}`,
+    type: "assigned"
+  });
+};
+var buildVoiceOpsTaskFromSLABreach = (task, policy = {}) => {
+  const createdAt = task.slaBreachedAt ?? Date.now();
+  const followUp = withVoiceOpsTaskId(`${task.id}:sla`, {
+    assignee: policy.assignee ?? task.assignee,
+    createdAt,
+    description: policy.description ?? `Task ${task.id} breached its SLA and needs operator follow-up.`,
+    dueAt: typeof policy.dueInMs === "number" ? createdAt + Math.max(0, policy.dueInMs) : undefined,
+    history: [
+      {
+        actor: "system",
+        at: createdAt,
+        detail: policy.name ?? (task.policyName ? `Created from SLA breach on policy ${task.policyName}` : "Created from SLA breach"),
+        type: "created"
+      }
+    ],
+    kind: task.kind,
+    intakeId: task.intakeId,
+    outcome: task.outcome,
+    priority: policy.priority ?? "urgent",
+    policyName: policy.name ?? `${task.policyName ?? task.kind}:sla`,
+    queue: policy.queue ?? task.queue,
+    recommendedAction: policy.recommendedAction ?? `Review overdue task ${task.id} and decide the next operator action.`,
+    reviewId: task.reviewId,
+    status: "open",
+    target: task.target,
+    title: policy.title ?? `SLA follow-up for ${task.title}`,
+    updatedAt: createdAt
+  });
+  return followUp;
+};
+var claimVoiceOpsTask = (task, workerId, input = {
+  leaseMs: 30000
+}) => {
+  const at = input.at ?? Date.now();
+  const leaseMs = Math.max(1, input.leaseMs);
+  return ensureTaskHistory({
+    ...task,
+    claimExpiresAt: at + leaseMs,
+    claimedAt: at,
+    claimedBy: workerId,
+    status: task.status === "done" ? task.status : "in-progress"
+  }, {
+    actor: input.actor ?? workerId,
+    at,
+    detail: input.detail ?? `Claimed by ${workerId}`,
+    type: "claimed"
+  });
+};
+var completeVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  claimExpiresAt: undefined,
+  claimedAt: undefined,
+  claimedBy: undefined,
+  lastProcessedAt: input.at ?? Date.now(),
+  processingError: undefined,
+  status: "done"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Marked done",
+  type: "completed"
+});
+var createVoiceCallCompletedEvent = (input) => createVoiceIntegrationEvent("call.completed", {
+  call: input.session.call,
+  disposition: input.disposition ?? input.session.call?.disposition,
+  scenarioId: input.session.scenarioId,
+  sessionId: input.session.id,
+  sessionSummary: input.sessionSummary,
+  status: input.session.status,
+  turnCount: input.session.turns.length
+}, {
+  id: `${input.session.id}:call.completed`
+});
+var createVoiceIntegrationEvent = (type, payload, input = {}) => ({
+  createdAt: input.createdAt ?? Date.now(),
+  id: input.id ?? crypto.randomUUID(),
+  payload,
+  type
+});
+var createVoiceReviewSavedEvent = (review) => createVoiceIntegrationEvent("review.saved", {
+  elapsedMs: review.summary.elapsedMs,
+  firstTurnLatencyMs: review.summary.firstTurnLatencyMs,
+  outcome: review.summary.outcome,
+  postCall: review.postCall,
+  reviewId: review.id,
+  title: review.title
+}, {
+  id: `${review.id}:review.saved`
+});
+var createVoiceTaskCreatedEvent = (task) => createVoiceIntegrationEvent("task.created", {
+  assignee: task.assignee,
+  dueAt: task.dueAt,
+  kind: task.kind,
+  outcome: task.outcome,
+  priority: task.priority,
+  queue: task.queue,
+  recommendedAction: task.recommendedAction,
+  reviewId: task.reviewId,
+  status: task.status,
+  target: task.target,
+  taskId: task.id,
+  title: task.title
+}, {
+  id: `${task.id}:task.created:${task.updatedAt}`
+});
+var createVoiceTaskSLABreachedEvent = (task) => createVoiceIntegrationEvent("task.sla_breached", {
+  assignee: task.assignee,
+  dueAt: task.dueAt,
+  kind: task.kind,
+  outcome: task.outcome,
+  priority: task.priority,
+  queue: task.queue,
+  recommendedAction: task.recommendedAction,
+  reviewId: task.reviewId,
+  slaBreachedAt: task.slaBreachedAt,
+  status: task.status,
+  target: task.target,
+  taskId: task.id,
+  title: task.title
+}, {
+  id: `${task.id}:task.sla_breached:${task.slaBreachedAt ?? task.updatedAt}`
+});
+var createVoiceTaskUpdatedEvent = (task) => createVoiceIntegrationEvent("task.updated", {
+  assignee: task.assignee,
+  dueAt: task.dueAt,
+  history: task.history,
+  kind: task.kind,
+  outcome: task.outcome,
+  priority: task.priority,
+  queue: task.queue,
+  recommendedAction: task.recommendedAction,
+  reviewId: task.reviewId,
+  slaBreachedAt: task.slaBreachedAt,
+  status: task.status,
+  target: task.target,
+  taskId: task.id,
+  title: task.title,
+  updatedAt: task.updatedAt
+}, {
+  id: `${task.id}:task.updated:${task.updatedAt}`
+});
+var deadLetterVoiceOpsTask = (task, input = {}) => {
+  const at = input.at ?? Date.now();
+  return ensureTaskHistory({
+    ...task,
+    claimExpiresAt: undefined,
+    claimedAt: undefined,
+    claimedBy: undefined,
+    deadLetteredAt: at,
+    lastProcessedAt: at,
+    status: "open"
+  }, {
+    actor: input.actor ?? task.assignee ?? "ops",
+    at,
+    detail: input.detail ?? "Task moved to dead-letter queue",
+    type: "dead-lettered"
+  });
+};
+var failVoiceOpsTask = (task, input = {}) => {
+  const at = input.at ?? Date.now();
+  const detail = input.detail ?? input.error ?? "Task processing failed";
+  return ensureTaskHistory({
+    ...task,
+    lastProcessedAt: at,
+    processingAttempts: (task.processingAttempts ?? 0) + 1,
+    processingError: input.error ?? detail,
+    status: task.status === "done" ? task.status : "open"
+  }, {
+    actor: input.actor ?? task.claimedBy ?? task.assignee ?? "ops",
+    at,
+    detail,
+    type: "failed"
+  });
+};
+var hasVoiceOpsTaskSLABreach = (task) => typeof task.slaBreachedAt === "number";
+var heartbeatVoiceOpsTask = (task, workerId, input = {
+  leaseMs: 30000
+}) => {
+  if (task.claimedBy && task.claimedBy !== workerId) {
+    throw new Error(`Cannot heartbeat task ${task.id}: claimed by ${task.claimedBy}, not ${workerId}.`);
+  }
+  const at = input.at ?? Date.now();
+  const leaseMs = Math.max(1, input.leaseMs);
+  return ensureTaskHistory({
+    ...task,
+    claimExpiresAt: at + leaseMs,
+    claimedAt: task.claimedAt ?? at,
+    claimedBy: workerId
+  }, {
+    actor: input.actor ?? workerId,
+    at,
+    detail: input.detail ?? `Heartbeat from ${workerId}`,
+    type: "heartbeat"
+  });
+};
+var isVoiceOpsTaskOverdue = (task, input = {}) => typeof task.dueAt === "number" && task.status !== "done" && task.dueAt <= (input.at ?? Date.now());
+var listVoiceOpsTasks = (tasks) => [...tasks].sort((left, right) => right.createdAt - left.createdAt);
+var markVoiceOpsTaskSLABreached = (task, input = {}) => {
+  const at = input.at ?? Date.now();
+  if (hasVoiceOpsTaskSLABreach(task)) {
+    return task;
+  }
+  return ensureTaskHistory({
+    ...task,
+    slaBreachedAt: at
+  }, {
+    actor: input.actor ?? "system",
+    at,
+    detail: input.detail ?? "Task breached its SLA",
+    type: "sla-breached"
+  });
+};
+var matchesVoiceOpsTaskAssignmentRule = (task, rule) => {
+  const { when } = rule;
+  if (!when) {
+    return true;
+  }
+  if (when.assignee !== undefined && task.assignee !== when.assignee) {
+    return false;
+  }
+  if (when.kind !== undefined && task.kind !== when.kind) {
+    return false;
+  }
+  if (when.outcome !== undefined && task.outcome !== when.outcome) {
+    return false;
+  }
+  if (when.policyName !== undefined && task.policyName !== when.policyName) {
+    return false;
+  }
+  if (when.priority !== undefined && task.priority !== when.priority) {
+    return false;
+  }
+  if (when.queue !== undefined && task.queue !== when.queue) {
+    return false;
+  }
+  if (when.status !== undefined && task.status !== when.status) {
+    return false;
+  }
+  return true;
+};
+var reopenVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  claimExpiresAt: undefined,
+  claimedAt: undefined,
+  claimedBy: undefined,
+  deadLetteredAt: undefined,
+  processingError: undefined,
+  status: "open"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Task reopened",
+  type: "reopened"
+});
+var requeueVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  claimExpiresAt: undefined,
+  claimedAt: undefined,
+  claimedBy: undefined,
+  processingError: undefined,
+  status: "open"
+}, {
+  actor: input.actor ?? task.claimedBy ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Task requeued",
+  type: "requeued"
+});
+var resolveVoiceOpsTaskAgeBucket = (task, input = {}) => {
+  const at = input.at ?? Date.now();
+  const freshMs = Math.max(0, input.agingMs ?? 30 * 60000);
+  const staleMs = Math.max(freshMs, input.staleMs ?? 4 * 60 * 60000);
+  const dueSoonMs = Math.max(0, input.dueSoonMs ?? 15 * 60000);
+  const ageMs = Math.max(0, at - task.createdAt);
+  if (isVoiceOpsTaskOverdue(task, { at })) {
+    return ageMs >= staleMs ? "stale" : "overdue";
+  }
+  if (typeof task.dueAt === "number" && task.status !== "done" && task.dueAt - at <= dueSoonMs) {
+    return "due-soon";
+  }
+  if (ageMs >= staleMs) {
+    return "stale";
+  }
+  if (ageMs >= freshMs) {
+    return "aging";
+  }
+  return "fresh";
+};
+var resolveVoiceOpsTaskAssignment = (input) => input.rules?.find((rule) => matchesVoiceOpsTaskAssignmentRule(input.task, rule));
+var resolveVoiceOpsTaskPolicy = (input) => {
+  const { disposition } = input;
+  if (!disposition) {
+    return;
+  }
+  const defaultPolicy = DEFAULT_VOICE_OPS_TASK_POLICIES[disposition];
+  const customPolicy = input.policies?.[disposition];
+  if (!defaultPolicy && !customPolicy) {
+    return;
+  }
+  return {
+    ...defaultPolicy,
+    ...customPolicy
+  };
+};
+var startVoiceOpsTask = (task, input = {}) => ensureTaskHistory({
+  ...task,
+  status: "in-progress"
+}, {
+  actor: input.actor ?? task.assignee ?? "ops",
+  at: input.at,
+  detail: input.detail ?? "Work started",
+  type: "started"
+});
+var summarizeVoiceOpsTaskAnalytics = (tasks, input = {}) => {
+  const at = input.at ?? Date.now();
+  const agingBuckets = new Map;
+  const assignees = new Map;
+  const workers = new Map;
+  let totalCompleted = 0;
+  let totalOverdue = 0;
+  for (const task of tasks) {
+    const bucket = resolveVoiceOpsTaskAgeBucket(task, { ...input, at });
+    agingBuckets.set(bucket, (agingBuckets.get(bucket) ?? 0) + 1);
+    if (task.assignee) {
+      const assignee = assignees.get(task.assignee) ?? {
+        claimed: 0,
+        completed: 0,
+        completionMsTotal: 0,
+        completionSamples: 0,
+        inProgress: 0,
+        open: 0,
+        overdue: 0,
+        total: 0
+      };
+      assignee.total += 1;
+      if (task.status === "open") {
+        assignee.open += 1;
+      } else if (task.status === "in-progress") {
+        assignee.inProgress += 1;
+      } else if (task.status === "done") {
+        assignee.completed += 1;
+      }
+      if (task.claimedBy && (!task.claimExpiresAt || task.claimExpiresAt > at)) {
+        assignee.claimed += 1;
+      }
+      if (isVoiceOpsTaskOverdue(task, { at })) {
+        assignee.overdue += 1;
+      }
+      const completedAt = task.history.findLast((entry) => entry.type === "completed")?.at;
+      if (task.status === "done" && typeof completedAt === "number") {
+        assignee.completionMsTotal += Math.max(0, completedAt - task.createdAt);
+        assignee.completionSamples += 1;
+      }
+      assignees.set(task.assignee, assignee);
+    }
+    if (isVoiceOpsTaskOverdue(task, { at })) {
+      totalOverdue += 1;
+    }
+    if (task.status === "done") {
+      totalCompleted += 1;
+    }
+    for (const entry of task.history) {
+      if (!["claimed", "heartbeat", "completed", "failed", "requeued"].includes(entry.type)) {
+        continue;
+      }
+      const worker = workers.get(entry.actor) ?? {
+        activeClaims: 0,
+        completed: 0,
+        failed: 0,
+        heartbeats: 0,
+        requeued: 0,
+        totalClaims: 0
+      };
+      if (entry.type === "claimed") {
+        worker.totalClaims += 1;
+      } else if (entry.type === "heartbeat") {
+        worker.heartbeats += 1;
+      } else if (entry.type === "completed") {
+        worker.completed += 1;
+      } else if (entry.type === "failed") {
+        worker.failed += 1;
+      } else if (entry.type === "requeued") {
+        worker.requeued += 1;
+      }
+      workers.set(entry.actor, worker);
+    }
+    if (task.claimedBy && (!task.claimExpiresAt || task.claimExpiresAt > at)) {
+      const worker = workers.get(task.claimedBy) ?? {
+        activeClaims: 0,
+        completed: 0,
+        failed: 0,
+        heartbeats: 0,
+        requeued: 0,
+        totalClaims: 0
+      };
+      worker.activeClaims += 1;
+      workers.set(task.claimedBy, worker);
+    }
+  }
+  return {
+    agingBuckets: [...agingBuckets.entries()].sort((left, right) => right[1] - left[1]),
+    assignees: [...assignees.entries()].map(([assignee, value]) => ({
+      assignee,
+      averageCompletionMs: value.completionSamples > 0 ? value.completionMsTotal / value.completionSamples : undefined,
+      claimed: value.claimed,
+      completed: value.completed,
+      inProgress: value.inProgress,
+      open: value.open,
+      overdue: value.overdue,
+      total: value.total
+    })).sort((left, right) => right.total - left.total),
+    totalCompleted,
+    totalOverdue,
+    totalTasks: tasks.length,
+    workers: [...workers.entries()].map(([workerId, value]) => ({
+      activeClaims: value.activeClaims,
+      completed: value.completed,
+      failed: value.failed,
+      heartbeats: value.heartbeats,
+      requeued: value.requeued,
+      totalClaims: value.totalClaims,
+      workerId
+    })).sort((left, right) => right.totalClaims - left.totalClaims)
+  };
+};
+var summarizeVoiceOpsTasks = (tasks) => {
+  const summary = {
+    byClaimedBy: new Map,
+    byKind: new Map,
+    byOutcome: new Map,
+    byPriority: new Map,
+    byQueue: new Map,
+    claimed: 0,
+    done: 0,
+    inProgress: 0,
+    open: 0,
+    overdue: 0,
+    topAssignees: new Map,
+    topQueues: new Map,
+    topTargets: new Map,
+    total: tasks.length
+  };
+  for (const task of tasks) {
+    if (task.status === "open") {
+      summary.open += 1;
+    } else if (task.status === "in-progress") {
+      summary.inProgress += 1;
+    } else if (task.status === "done") {
+      summary.done += 1;
+    }
+    if (task.claimedBy && (!task.claimExpiresAt || task.claimExpiresAt > Date.now())) {
+      summary.claimed += 1;
+      summary.byClaimedBy.set(task.claimedBy, (summary.byClaimedBy.get(task.claimedBy) ?? 0) + 1);
+    }
+    summary.byKind.set(task.kind, (summary.byKind.get(task.kind) ?? 0) + 1);
+    if (task.outcome) {
+      summary.byOutcome.set(task.outcome, (summary.byOutcome.get(task.outcome) ?? 0) + 1);
+    }
+    if (task.target) {
+      summary.topTargets.set(task.target, (summary.topTargets.get(task.target) ?? 0) + 1);
+    }
+    if (task.assignee) {
+      summary.topAssignees.set(task.assignee, (summary.topAssignees.get(task.assignee) ?? 0) + 1);
+    }
+    if (task.priority) {
+      summary.byPriority.set(task.priority, (summary.byPriority.get(task.priority) ?? 0) + 1);
+    }
+    if (task.queue) {
+      summary.byQueue.set(task.queue, (summary.byQueue.get(task.queue) ?? 0) + 1);
+      summary.topQueues.set(task.queue, (summary.topQueues.get(task.queue) ?? 0) + 1);
+    }
+    if (isVoiceOpsTaskOverdue(task)) {
+      summary.overdue += 1;
+    }
+  }
+  return {
+    byClaimedBy: [...summary.byClaimedBy.entries()].sort((left, right) => right[1] - left[1]),
+    byKind: [...summary.byKind.entries()].sort((left, right) => right[1] - left[1]),
+    byOutcome: [...summary.byOutcome.entries()].sort((left, right) => right[1] - left[1]),
+    byPriority: [...summary.byPriority.entries()].sort((left, right) => right[1] - left[1]),
+    byQueue: [...summary.byQueue.entries()].sort((left, right) => right[1] - left[1]),
+    claimed: summary.claimed,
+    done: summary.done,
+    inProgress: summary.inProgress,
+    open: summary.open,
+    overdue: summary.overdue,
+    topAssignees: [...summary.topAssignees.entries()].sort((left, right) => right[1] - left[1]),
+    topQueues: [...summary.topQueues.entries()].sort((left, right) => right[1] - left[1]),
+    topTargets: [...summary.topTargets.entries()].sort((left, right) => right[1] - left[1]),
+    total: summary.total
+  };
+};
+
+// src/core/store.ts
+var createId = () => crypto.randomUUID();
+var createVoiceSessionRecord = (id, scenarioId) => ({
+  committedTurnIds: [],
+  createdAt: Date.now(),
+  currentTurn: {
+    finalText: "",
+    lastSpeechAt: undefined,
+    lastTranscriptAt: undefined,
+    partialEndedAt: undefined,
+    partialStartedAt: undefined,
+    partialText: "",
+    silenceStartedAt: undefined,
+    transcripts: []
+  },
+  id,
+  scenarioId,
+  reconnect: { attempts: 0 },
+  status: "active",
+  transcripts: [],
+  turns: [],
+  lastCommittedTurn: {
+    committedAt: 0,
+    signature: "",
+    text: "",
+    transcriptIds: []
+  }
+});
+var resetVoiceSessionRecord = (id, existing, scenarioId) => ({
+  ...createVoiceSessionRecord(id, scenarioId),
+  metadata: existing?.metadata
+});
+var toVoiceSessionSummary = (session) => ({
+  createdAt: session.createdAt,
+  id: session.id,
+  lastActivityAt: session.lastActivityAt,
+  status: session.status,
+  turnCount: session.turns.length
+});
+
+// src/internal/html.ts
+var escapeHtml = (value) => String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+
+// src/core/trace.ts
+var createVoiceTraceEvent = (event) => ({
+  ...event,
+  at: event.at,
+  id: event.id ?? createVoiceTraceEventId({
+    at: event.at,
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    type: event.type
+  })
+});
+var createVoiceTraceEventId = (event) => [
+  event.sessionId,
+  event.turnId ?? "session",
+  event.type,
+  String(event.at ?? Date.now()),
+  crypto.randomUUID()
+].map(encodeURIComponent).join(":");
+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;
+  }
+  if (filter.turnId !== undefined && event.turnId !== filter.turnId) {
+    return false;
+  }
+  if (filter.scenarioId !== undefined && event.scenarioId !== filter.scenarioId) {
+    return false;
+  }
+  if (filter.traceId !== undefined && event.traceId !== filter.traceId) {
+    return false;
+  }
+  if (filter.type !== undefined) {
+    const types = Array.isArray(filter.type) ? filter.type : [filter.type];
+    if (!types.includes(event.type)) {
+      return false;
+    }
+  }
+  return true;
+};
+var createVoiceProofTraceStore = (options = {}) => {
+  const proofStore = options.proofStore ?? createVoiceMemoryTraceEventStore();
+  const scopedProofStore = options.scope ? createVoiceScopedTraceEventStore(proofStore, options.scope) : proofStore;
+  return {
+    append: async (event) => {
+      const stored = await proofStore.append(event);
+      await options.mirrorStore?.append(stored);
+      return stored;
+    },
+    get: async (id) => await proofStore.get(id) ?? await options.mirrorStore?.get(id),
+    list: (filter) => scopedProofStore.list(filter),
+    remove: async (id) => {
+      await Promise.all([
+        proofStore.remove(id),
+        options.mirrorStore?.remove(id) ?? Promise.resolve()
+      ]);
+    }
+  };
+};
+var createVoiceScopedTraceEventStore = (store, scope) => {
+  const upstreamFilter = (filter = {}) => {
+    const next = { ...filter };
+    delete next.limit;
+    if (scope.scenarioId !== undefined) {
+      delete next.scenarioId;
+    }
+    if (scope.sessionId !== undefined) {
+      delete next.sessionId;
+    }
+    if (scope.traceId !== undefined) {
+      delete next.traceId;
+    }
+    if (scope.turnId !== undefined) {
+      delete next.turnId;
+    }
+    if (scope.type !== undefined) {
+      delete next.type;
+    }
+    return next;
+  };
+  const scopedFilter = (filter = {}) => ({
+    ...filter,
+    ...scope
+  });
+  return {
+    append: (event) => store.append(event),
+    get: (id) => store.get(id),
+    list: async (filter) => filterVoiceTraceEvents(await store.list(upstreamFilter(filter)), scopedFilter(filter)),
+    remove: (id) => store.remove(id)
+  };
+};
+var filterVoiceTraceEvents = (events, filter = {}) => {
+  const sorted = events.filter((event) => matchesTraceFilter(event, filter)).sort((left, right) => left.at - right.at || left.id.localeCompare(right.id));
+  return typeof filter.limit === "number" && filter.limit >= 0 ? sorted.slice(0, filter.limit) : sorted;
+};
+var isPruneTimeMatch = (event, options) => {
+  if (typeof options.before === "number" && event.at >= options.before) {
+    return false;
+  }
+  if (typeof options.beforeOrAt === "number" && event.at > options.beforeOrAt) {
+    return false;
+  }
+  return true;
+};
+var pruneVoiceTraceEvents = async (options) => {
+  const events = await options.store.list(options.filter);
+  const deleted = selectVoiceTraceEventsForPrune(events, options);
+  if (!options.dryRun) {
+    await Promise.all(deleted.map((event) => options.store.remove(event.id)));
+  }
+  return {
+    deleted,
+    deletedCount: deleted.length,
+    dryRun: Boolean(options.dryRun),
+    scannedCount: events.length
+  };
+};
+var selectVoiceTraceEventsForPrune = (events, options = {}) => {
+  let candidates = filterVoiceTraceEvents(events, options.filter).filter((event) => isPruneTimeMatch(event, options));
+  if (typeof options.keepNewest === "number" && options.keepNewest >= 0) {
+    const newestIds = new Set([...candidates].sort((left, right) => right.at - left.at || right.id.localeCompare(left.id)).slice(0, options.keepNewest).map((event) => event.id));
+    candidates = candidates.filter((event) => !newestIds.has(event.id));
+  }
+  return typeof options.limit === "number" && options.limit >= 0 ? candidates.slice(0, options.limit) : candidates;
+};
+var sleep2 = async (delayMs) => {
+  if (delayMs <= 0) {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+};
+var toHex2 = (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), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const payload = encoder.encode(`${input.timestamp}.${input.body}`);
+  const signature = await crypto.subtle.sign("HMAC", key, payload);
+  return `sha256=${toHex2(new Uint8Array(signature))}`;
+};
+var createVoiceTraceSinkDeliveryError = (input) => {
+  if (input.response) {
+    const statusText = input.response.statusText?.trim();
+    return `Attempt ${input.attempt} failed with trace sink response ${input.response.status}${statusText ? ` ${statusText}` : ""}.`;
+  }
+  if (input.error instanceof Error) {
+    return `Attempt ${input.attempt} failed: ${input.error.message}`;
+  }
+  return `Attempt ${input.attempt} failed: ${String(input.error)}`;
+};
+var normalizeVoiceTraceS3KeyPrefix = (prefix) => prefix?.trim().replace(/^\/+|\/+$/g, "") ?? "voice/trace-deliveries";
+var createVoiceTraceS3ObjectKey = (prefix, events) => {
+  const firstEvent = events[0];
+  const safeSessionId = encodeURIComponent(firstEvent?.sessionId ?? "trace");
+  const safeEventId = encodeURIComponent(firstEvent?.id ?? crypto.randomUUID());
+  return `${prefix}/${safeSessionId}/${Date.now()}-${safeEventId}.json`;
+};
+var resolveVoiceS3DeliveredTo = (options, key) => {
+  const { bucket } = options;
+  return bucket ? `s3://${bucket}/${key}` : `s3://${key}`;
+};
+var aggregateVoiceTraceSinkDeliveryStatus = (deliveries) => {
+  const statuses = Object.values(deliveries).map((delivery) => delivery.status);
+  if (statuses.length === 0 || statuses.every((status) => status === "skipped")) {
+    return "skipped";
+  }
+  if (statuses.some((status) => status === "failed")) {
+    return "failed";
+  }
+  return "delivered";
+};
+var createVoiceTraceHTTPSink = (options) => ({
+  eventTypes: options.eventTypes,
+  id: options.id,
+  kind: options.kind ?? "http",
+  deliver: async ({ events }) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      return {
+        attempts: 0,
+        deliveredTo: options.url,
+        error: "Trace sink delivery failed: fetch is not available in this runtime.",
+        eventCount: events.length,
+        status: "failed"
+      };
+    }
+    const maxRetries = Math.max(0, options.retries ?? 0);
+    const backoffMs = Math.max(0, options.backoffMs ?? 250);
+    const timeoutMs = Math.max(0, options.timeoutMs ?? 1e4);
+    const payload = options.body ? await options.body({ events }) : {
+      eventCount: events.length,
+      events,
+      source: "absolutejs-voice"
+    };
+    const body = JSON.stringify(payload);
+    let lastError = "Trace sink delivery failed.";
+    for (let attempt = 1;attempt <= maxRetries + 1; attempt += 1) {
+      let controller;
+      let timeout;
+      try {
+        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 signVoiceTraceSinkBody({
+            body,
+            secret: options.signingSecret,
+            timestamp
+          });
+        }
+        controller = timeoutMs > 0 ? new AbortController : undefined;
+        if (controller && timeoutMs > 0) {
+          timeout = setTimeout(() => controller?.abort(), timeoutMs);
+        }
+        const response = await fetchImpl(options.url, {
+          body,
+          headers,
+          method: options.method ?? "POST",
+          signal: controller?.signal
+        });
+        if (response.ok) {
+          let responseBody;
+          try {
+            responseBody = await response.clone().json();
+          } catch {
+            responseBody = undefined;
+          }
+          return {
+            attempts: attempt,
+            deliveredAt: Date.now(),
+            deliveredTo: options.url,
+            eventCount: events.length,
+            responseBody,
+            status: "delivered"
+          };
+        }
+        lastError = createVoiceTraceSinkDeliveryError({
+          attempt,
+          response
+        });
+      } catch (error) {
+        lastError = createVoiceTraceSinkDeliveryError({
+          attempt,
+          error
+        });
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+      if (attempt <= maxRetries) {
+        await sleep2(backoffMs * attempt);
+      }
+    }
+    return {
+      attempts: maxRetries + 1,
+      deliveredTo: options.url,
+      error: lastError,
+      eventCount: events.length,
+      status: "failed"
+    };
+  }
+});
+var createVoiceTraceS3Sink = (options) => {
+  const client = options.client ?? new Bun.S3Client(options);
+  const keyPrefix = normalizeVoiceTraceS3KeyPrefix(options.keyPrefix);
+  return {
+    eventTypes: options.eventTypes,
+    id: options.id,
+    kind: options.kind ?? "s3",
+    deliver: async ({ events }) => {
+      const key = createVoiceTraceS3ObjectKey(keyPrefix, events);
+      const payload = options.body ? await options.body({ events, key }) : {
+        eventCount: events.length,
+        events,
+        key,
+        source: "absolutejs-voice"
+      };
+      try {
+        const file = client.file(key, options);
+        await file.write(JSON.stringify(payload), {
+          type: options.contentType ?? "application/json"
+        });
+        return {
+          attempts: 1,
+          deliveredAt: Date.now(),
+          deliveredTo: resolveVoiceS3DeliveredTo(options, key),
+          eventCount: events.length,
+          responseBody: { key },
+          status: "delivered"
+        };
+      } catch (error) {
+        return {
+          attempts: 1,
+          deliveredTo: resolveVoiceS3DeliveredTo(options, key),
+          error: error instanceof Error ? error.message : String(error),
+          eventCount: events.length,
+          status: "failed"
+        };
+      }
+    }
+  };
+};
+var createVoiceTraceSinkStore = (options) => {
+  const deliver = async (event) => {
+    const result = await deliverVoiceTraceEventsToSinks({
+      events: [event],
+      redact: options.redact,
+      sinks: options.sinks
+    });
+    await options.onDelivery?.(result);
+  };
+  return {
+    append: async (event) => {
+      const stored = await options.store.append(event);
+      if (options.deliveryQueue) {
+        const delivery2 = createVoiceTraceSinkDeliveryRecord({
+          events: [stored]
+        });
+        await options.deliveryQueue.set(delivery2.id, delivery2);
+        return stored;
+      }
+      const delivery = deliver(stored);
+      if (options.awaitDelivery) {
+        await delivery;
+      } else {
+        delivery.catch((error) => {
+          options.onError?.(error);
+        });
+      }
+      return stored;
+    },
+    get: (id) => options.store.get(id),
+    list: (filter) => options.store.list(filter),
+    remove: (id) => options.store.remove(id)
+  };
+};
+var deliverVoiceTraceEventsToSinks = async (input) => {
+  const events = input.redact ? redactVoiceTraceEvents(input.events, input.redact) : input.events;
+  const sinkDeliveries = {};
+  for (const sink of input.sinks) {
+    const sinkEvents = sink.eventTypes?.length ? events.filter((event) => sink.eventTypes?.includes(event.type)) : events;
+    if (sinkEvents.length === 0) {
+      sinkDeliveries[sink.id] = {
+        attempts: 0,
+        eventCount: 0,
+        status: "skipped"
+      };
+      continue;
+    }
+    try {
+      sinkDeliveries[sink.id] = await sink.deliver({
+        events: sinkEvents
+      });
+    } catch (error) {
+      sinkDeliveries[sink.id] = {
+        attempts: 1,
+        error: error instanceof Error ? error.message : String(error),
+        eventCount: sinkEvents.length,
+        status: "failed"
+      };
+    }
+  }
+  return {
+    deliveredAt: Date.now(),
+    eventCount: events.length,
+    sinkDeliveries,
+    status: aggregateVoiceTraceSinkDeliveryStatus(sinkDeliveries)
+  };
+};
+var normalizeVoiceProfileTraceTaggerProfile = (profile) => typeof profile === "string" ? { id: profile } : profile?.id ? profile : undefined;
+var createVoiceMemoryTraceEventStore = () => {
+  const events = new Map;
+  const append = async (event) => {
+    const stored = createVoiceTraceEvent(event);
+    events.set(stored.id, stored);
+    return stored;
+  };
+  const get = async (id) => events.get(id);
+  const list = async (filter) => filterVoiceTraceEvents([...events.values()], filter);
+  const remove = async (id) => {
+    events.delete(id);
+  };
+  return { append, get, list, remove };
+};
+var createVoiceMemoryTraceSinkDeliveryStore = () => {
+  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 createVoiceProfileTraceTagger = (options) => {
+  const profiles = new Map((options.profiles ?? []).map((profile) => [profile.id, profile]));
+  const defaultProfile = normalizeVoiceProfileTraceTaggerProfile(options.defaultProfile);
+  const resolveProfile = async (event) => {
+    const resolved = normalizeVoiceProfileTraceTaggerProfile(await options.resolveProfile?.(event));
+    const profile = resolved ?? defaultProfile;
+    return profile ? profiles.get(profile.id) ?? profile : undefined;
+  };
+  return {
+    append: async (event) => {
+      const profile = await resolveProfile(event);
+      if (!profile) {
+        return options.store.append(event);
+      }
+      const metadata = {
+        ...event.metadata ?? {},
+        benchmarkProfileId: profile.id,
+        profileDescription: event.metadata?.profileDescription ?? profile.description,
+        profileId: profile.id,
+        profileLabel: event.metadata?.profileLabel ?? profile.label
+      };
+      const payload = event.payload && typeof event.payload === "object" ? {
+        ...event.payload,
+        benchmarkProfileId: event.payload.benchmarkProfileId ?? profile.id,
+        profileDescription: event.payload.profileDescription ?? profile.description,
+        profileId: event.payload.profileId ?? profile.id,
+        profileLabel: event.payload.profileLabel ?? profile.label
+      } : event.payload;
+      return options.store.append({
+        ...event,
+        metadata,
+        payload
+      });
+    },
+    get: (id) => options.store.get(id),
+    list: (filter) => options.store.list(filter),
+    remove: (id) => options.store.remove(id)
+  };
+};
+var exportVoiceTrace = async (input) => {
+  const events = await input.store.list(input.filter);
+  return {
+    exportedAt: Date.now(),
+    events: input.redact ? redactVoiceTraceEvents(events, input.redact) : events,
+    filter: input.filter,
+    redacted: Boolean(input.redact)
+  };
+};
+var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var formatTraceValue = (value) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var DEFAULT_REDACTION_KEYS = [
+  "apiKey",
+  "authorization",
+  "creditCard",
+  "email",
+  "externalId",
+  "password",
+  "phone",
+  "secret",
+  "ssn",
+  "token"
+];
+var DEFAULT_REDACTION_TEXT_KEYS = [
+  "assistantText",
+  "content",
+  "error",
+  "reason",
+  "summary",
+  "text"
+];
+var EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+var PHONE_PATTERN = /(?<!\d)(?:\+?1[\s.-]?)?(?:\(?\d{3}\)?[\s.-]?)\d{3}[\s.-]?\d{4}(?!\d)/g;
+var normalizeRedactionKey = (key) => key.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+var resolveVoiceTraceRedactionOptions = (options = {}) => ({
+  keys: typeof options === "boolean" ? DEFAULT_REDACTION_KEYS : options.keys ?? DEFAULT_REDACTION_KEYS,
+  redactEmails: typeof options === "boolean" ? true : options.redactEmails ?? true,
+  redactPhoneNumbers: typeof options === "boolean" ? true : options.redactPhoneNumbers ?? true,
+  redactText: typeof options === "boolean" ? true : options.redactText ?? true,
+  replacement: typeof options === "boolean" ? "[redacted]" : options.replacement ?? "[redacted]",
+  textKeys: typeof options === "boolean" ? DEFAULT_REDACTION_TEXT_KEYS : options.textKeys ?? DEFAULT_REDACTION_TEXT_KEYS
+});
+var resolveReplacement = (input) => typeof input.options.replacement === "function" ? input.options.replacement({
+  key: input.key,
+  path: input.path,
+  value: input.value
+}) : input.options.replacement;
+var redactVoiceTraceText = (value, options = {}, input = {}) => {
+  const resolved = resolveVoiceTraceRedactionOptions(options);
+  let redacted = value;
+  const replacement = resolveReplacement({
+    key: input.key,
+    options: resolved,
+    path: input.path ?? [],
+    value
+  });
+  if (resolved.redactEmails) {
+    redacted = redacted.replace(EMAIL_PATTERN, replacement);
+  }
+  if (resolved.redactPhoneNumbers) {
+    redacted = redacted.replace(PHONE_PATTERN, replacement);
+  }
+  return redacted;
+};
+var redactTraceValue = (value, options, path) => {
+  const key = path.at(-1);
+  const normalizedKey = key ? normalizeRedactionKey(key) : undefined;
+  const sensitiveKeys = new Set(options.keys.map(normalizeRedactionKey));
+  const textKeys = new Set(options.textKeys.map(normalizeRedactionKey));
+  if (normalizedKey && sensitiveKeys.has(normalizedKey) && (value === null || ["boolean", "number", "string", "undefined"].includes(typeof value))) {
+    return resolveReplacement({
+      key,
+      options,
+      path,
+      value: String(value ?? "")
+    });
+  }
+  if (typeof value === "string") {
+    const shouldRedactText = options.redactText && (!normalizedKey || textKeys.has(normalizedKey) || path.length === 0);
+    return shouldRedactText ? redactVoiceTraceText(value, options, {
+      key,
+      path
+    }) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactTraceValue(item, options, [...path, String(index)]));
+  }
+  if (typeof value === "object" && value) {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
+      entryKey,
+      redactTraceValue(entryValue, options, [...path, entryKey])
+    ]));
+  }
+  return value;
+};
+var evaluateVoiceTrace = (events, options = {}) => {
+  const summary = summarizeVoiceTrace(events);
+  const issues = [];
+  const maxHandoffs = options.maxHandoffs ?? 3;
+  const maxToolErrors = options.maxToolErrors ?? 0;
+  const maxModelCallsPerTurn = options.maxModelCallsPerTurn ?? 6;
+  const turnCountForRatio = Math.max(1, summary.turnCount);
+  if (options.requireCompletedCall !== false && !summary.endedAt) {
+    issues.push({
+      code: "call-not-ended",
+      message: "Trace does not include a call end lifecycle event.",
+      severity: "warning"
+    });
+  }
+  if (summary.failed) {
+    issues.push({
+      code: "session-error",
+      message: "Trace contains a session error or failed call disposition.",
+      severity: "error"
+    });
+  }
+  if (options.requireTranscript !== false && summary.transcriptCount === 0) {
+    issues.push({
+      code: "missing-transcript",
+      message: "Trace does not include any transcript events.",
+      severity: "error"
+    });
+  }
+  if (options.requireTurn !== false && summary.turnCount === 0) {
+    issues.push({
+      code: "missing-turn",
+      message: "Trace does not include any committed turns.",
+      severity: "error"
+    });
+  }
+  if (options.requireAssistantReply !== false && summary.turnCount > 0 && summary.assistantReplyCount === 0) {
+    issues.push({
+      code: "missing-assistant-reply",
+      message: "Trace has committed turns but no assistant replies.",
+      severity: "warning"
+    });
+  }
+  if (summary.toolErrorCount > maxToolErrors) {
+    issues.push({
+      code: "tool-errors",
+      message: `Trace has ${summary.toolErrorCount} tool error(s), above the allowed ${maxToolErrors}.`,
+      severity: "error"
+    });
+  }
+  if (summary.handoffCount > maxHandoffs) {
+    issues.push({
+      code: "too-many-handoffs",
+      message: `Trace has ${summary.handoffCount} handoff(s), above the allowed ${maxHandoffs}.`,
+      severity: "warning"
+    });
+  }
+  if (summary.modelCallCount / turnCountForRatio > maxModelCallsPerTurn) {
+    issues.push({
+      code: "too-many-model-calls",
+      message: `Trace averages more than ${maxModelCallsPerTurn} model calls per committed turn.`,
+      severity: "warning"
+    });
+  }
+  return {
+    issues,
+    pass: !issues.some((issue) => issue.severity === "error"),
+    summary
+  };
+};
+var redactVoiceTraceEvent = (event, options = {}) => {
+  const resolved = resolveVoiceTraceRedactionOptions(options);
+  return {
+    ...event,
+    metadata: redactTraceValue(event.metadata, resolved, [
+      "metadata"
+    ]),
+    payload: redactTraceValue(event.payload, resolved, [
+      "payload"
+    ])
+  };
+};
+var redactVoiceTraceEvents = (events, options = {}) => events.map((event) => redactVoiceTraceEvent(event, options));
+var summarizeVoiceTrace = (events) => {
+  const sorted = filterVoiceTraceEvents(events);
+  const firstEvent = sorted[0];
+  const lastEvent = sorted.at(-1);
+  const lifecycleEvents = sorted.filter((event) => event.type === "call.lifecycle");
+  const startEvent = lifecycleEvents.find((event) => event.payload.type === "start");
+  const endEvent = lifecycleEvents.toReversed().find((event) => event.payload.type === "end");
+  const costEvents = sorted.filter((event) => event.type === "turn.cost");
+  const toolEvents = sorted.filter((event) => event.type === "agent.tool");
+  const startedAt = startEvent?.at ?? firstEvent?.at;
+  const endedAt = endEvent?.at ?? lastEvent?.at;
+  const failed = sorted.some((event) => event.type === "session.error") || endEvent?.payload.disposition === "failed";
+  return {
+    assistantReplyCount: sorted.filter((event) => event.type === "turn.assistant").length,
+    callDurationMs: startedAt !== undefined && endedAt !== undefined ? Math.max(0, endedAt - startedAt) : undefined,
+    cost: {
+      estimatedRelativeCostUnits: costEvents.reduce((total, event) => total + toNumber(event.payload.estimatedRelativeCostUnits), 0),
+      totalBillableAudioMs: costEvents.reduce((total, event) => total + toNumber(event.payload.totalBillableAudioMs), 0)
+    },
+    endedAt,
+    errorCount: sorted.filter((event) => event.type === "session.error").length,
+    eventCount: sorted.length,
+    failed,
+    handoffCount: sorted.filter((event) => event.type === "agent.handoff").length,
+    modelCallCount: sorted.filter((event) => event.type === "agent.model").length,
+    sessionId: firstEvent?.sessionId,
+    startedAt,
+    toolCallCount: toolEvents.length,
+    toolErrorCount: toolEvents.filter((event) => event.payload.status === "error").length,
+    traceId: firstEvent?.traceId,
+    transcriptCount: sorted.filter((event) => event.type === "turn.transcript").length,
+    turnCount: sorted.filter((event) => event.type === "turn.committed").length
+  };
+};
+var renderTraceEventMarkdown = (event, startedAt) => {
+  const offset = startedAt === undefined ? `${event.at}` : `+${Math.max(0, event.at - startedAt)}ms`;
+  const label = `- ${offset} [${event.type}]`;
+  switch (event.type) {
+    case "turn.transcript":
+      return `${label} ${event.payload.isFinal ? "final" : "partial"} "${formatTraceValue(event.payload.text)}"`;
+    case "turn.committed":
+      return `${label} committed "${formatTraceValue(event.payload.text)}"`;
+    case "turn.assistant":
+      return event.payload.text ? `${label} assistant "${formatTraceValue(event.payload.text)}"` : `${label} ${formatTraceValue(event.payload.status)}`;
+    case "agent.tool":
+      return `${label} ${formatTraceValue(event.payload.toolName)} ${formatTraceValue(event.payload.status)}`;
+    case "agent.context":
+      return `${label} ${formatTraceValue(event.payload.fromAgentId)} -> ${formatTraceValue(event.payload.targetAgentId)} ${formatTraceValue(event.payload.status)}`;
+    case "agent.handoff":
+      return `${label} ${formatTraceValue(event.payload.fromAgentId)} -> ${formatTraceValue(event.payload.targetAgentId)}`;
+    case "session.error":
+      return `${label} ${formatTraceValue(event.payload.error)}`;
+    case "call.lifecycle":
+      return `${label} ${formatTraceValue(event.payload.type)} ${formatTraceValue(event.payload.disposition)}`.trim();
+    default:
+      return `${label} ${formatTraceValue(event.payload)}`;
+  }
+};
+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 renderVoiceTraceHTML = (events, options = {}) => {
+  const markdown = renderVoiceTraceMarkdown(events, options);
+  const renderEvents = options.redact ? redactVoiceTraceEvents(events, options.redact) : events;
+  const summary = summarizeVoiceTrace(renderEvents);
+  const evaluation = evaluateVoiceTrace(renderEvents, options.evaluation);
+  const eventRows = filterVoiceTraceEvents(renderEvents).map((event) => {
+    const offset = summary.startedAt === undefined ? event.at : Math.max(0, event.at - summary.startedAt);
+    return [
+      "<tr>",
+      `<td>${escapeHtml(String(offset))}</td>`,
+      `<td>${escapeHtml(event.type)}</td>`,
+      `<td>${escapeHtml(event.turnId ?? "")}</td>`,
+      `<td><code>${escapeHtml(JSON.stringify(event.payload))}</code></td>`,
+      "</tr>"
+    ].join("");
+  }).join(`
+`);
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8" />',
+    '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    `<title>${escapeHtml(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}",
+    ".summary{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:.75rem;margin:1rem 0}",
+    ".card{background:white;border:1px solid #ded9cc;border-radius:12px;padding:1rem}",
+    ".pass{color:#126b3a}.fail{color:#9d2222}",
+    "table{border-collapse:collapse;width:100%;background:white;border:1px solid #ded9cc}",
+    "th,td{border-bottom:1px solid #eee8dc;padding:.65rem;text-align:left;vertical-align:top}",
+    "code{white-space:pre-wrap;word-break:break-word}",
+    "pre{background:#181713;color:#f8f7f2;padding:1rem;border-radius:12px;overflow:auto}",
+    "</style>",
+    "</head>",
+    "<body><main>",
+    `<h1>${escapeHtml(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>`,
+    `<div class="card"><strong>Turns</strong><br>${summary.turnCount}</div>`,
+    `<div class="card"><strong>Transcripts</strong><br>${summary.transcriptCount}</div>`,
+    `<div class="card"><strong>Tool errors</strong><br>${summary.toolErrorCount}</div>`,
+    `<div class="card"><strong>Cost units</strong><br>${summary.cost.estimatedRelativeCostUnits}</div>`,
+    "</section>",
+    "<h2>Timeline</h2>",
+    "<table><thead><tr><th>Offset ms</th><th>Type</th><th>Turn</th><th>Payload</th></tr></thead><tbody>",
+    eventRows,
+    "</tbody></table>",
+    "<h2>Markdown Export</h2>",
+    `<pre>${escapeHtml(markdown)}</pre>`,
+    "</main></body></html>"
+  ].join(`
+`);
+};
+var renderVoiceTraceMarkdown = (events, options = {}) => {
+  const sorted = filterVoiceTraceEvents(options.redact ? redactVoiceTraceEvents(events, options.redact) : events);
+  const summary = summarizeVoiceTrace(sorted);
+  const evaluation = evaluateVoiceTrace(sorted, options.evaluation);
+  const lines = [
+    `# ${options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim()}`,
+    "",
+    `Pass: ${evaluation.pass ? "yes" : "no"}`,
+    `Session: ${summary.sessionId ?? "unknown"}`,
+    `Events: ${summary.eventCount}`,
+    `Turns: ${summary.turnCount}`,
+    `Transcripts: ${summary.transcriptCount}`,
+    `Assistant replies: ${summary.assistantReplyCount}`,
+    `Model calls: ${summary.modelCallCount}`,
+    `Tool calls: ${summary.toolCallCount}`,
+    `Handoffs: ${summary.handoffCount}`,
+    `Errors: ${summary.errorCount}`,
+    `Estimated cost units: ${summary.cost.estimatedRelativeCostUnits}`,
+    ""
+  ];
+  if (evaluation.issues.length > 0) {
+    lines.push("## Issues", "");
+    for (const issue of evaluation.issues) {
+      lines.push(`- [${issue.severity}] ${issue.code}: ${issue.message}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Timeline", "");
+  for (const event of sorted) {
+    lines.push(renderTraceEventMarkdown(event, summary.startedAt));
+  }
+  return lines.join(`
+`);
+};
+
+// src/testing/review.ts
+var roundMetric = (value) => typeof value === "number" ? Math.round(value * 100) / 100 : undefined;
+var formatMetric = (label, value, unit = "ms") => typeof value === "number" ? `${label}: ${roundMetric(value)}${unit}` : undefined;
+var findTimelineEvent = (timeline, event, source) => timeline.find((entry) => entry.event === event && (source === undefined || entry.source === source));
+var formatTimelineText = (entry) => {
+  const parts = [`- ${entry.atMs}ms`, `[${entry.source}]`, entry.event];
+  if (entry.text) {
+    parts.push(`"${entry.text}"`);
+  }
+  if (entry.reason) {
+    parts.push(`reason=${entry.reason}`);
+  }
+  if (typeof entry.bytes === "number") {
+    parts.push(`bytes=${entry.bytes}`);
+  }
+  if (typeof entry.confidence === "number") {
+    parts.push(`confidence=${roundMetric(entry.confidence)}`);
+  }
+  if (entry.name) {
+    parts.push(`name=${entry.name}`);
+  }
+  return parts.join(" ");
+};
+var isLowSignalTimelineEvent = (entry) => entry.event === "inbound-media" || entry.event === "inbound-silence-pad" || entry.event === "stt-send" || entry.event === "tts-audio";
+var summarizeTimelineTraffic = (timeline) => {
+  const summaries = new Map;
+  for (const entry of timeline) {
+    const label = entry.event === "inbound-media" ? "inbound media chunks" : entry.event === "inbound-silence-pad" ? "inbound silence padding" : entry.event === "stt-send" ? "STT audio sends" : entry.event === "tts-audio" ? "post-first TTS audio chunks" : undefined;
+    if (!label) {
+      continue;
+    }
+    const summary = summaries.get(label) ?? {
+      audioMs: 0,
+      bytes: 0,
+      count: 0,
+      label
+    };
+    summary.count += 1;
+    summary.bytes += typeof entry.bytes === "number" ? entry.bytes : 0;
+    summary.audioMs = (summary.audioMs ?? 0) + (typeof entry.chunkDurationMs === "number" ? entry.chunkDurationMs : 0);
+    summaries.set(label, summary);
+  }
+  return [...summaries.values()];
+};
+var compactTimeline = (timeline) => {
+  const rows = [];
+  let index = 0;
+  while (index < timeline.length) {
+    const current = timeline[index];
+    if (!current) {
+      break;
+    }
+    const isBurstEvent = isLowSignalTimelineEvent(current) || current.event === "media" && current.source === "twilio";
+    if (!isBurstEvent) {
+      rows.push(formatTimelineText(current));
+      index += 1;
+      continue;
+    }
+    let endIndex = index;
+    let totalBytes = typeof current.bytes === "number" ? current.bytes : 0;
+    let totalChunkDurationMs = typeof current.chunkDurationMs === "number" ? current.chunkDurationMs : 0;
+    while (endIndex + 1 < timeline.length) {
+      const next = timeline[endIndex + 1];
+      if (!next) {
+        break;
+      }
+      if (next.event !== current.event || next.source !== current.source) {
+        break;
+      }
+      totalBytes += typeof next.bytes === "number" ? next.bytes : 0;
+      totalChunkDurationMs += typeof next.chunkDurationMs === "number" ? next.chunkDurationMs : 0;
+      endIndex += 1;
+    }
+    const startAt = current.atMs;
+    const endAt = timeline[endIndex]?.atMs ?? current.atMs;
+    const count = endIndex - index + 1;
+    const parts = [
+      `- ${startAt}-${endAt}ms`,
+      `[${current.source}]`,
+      `${current.event} x${count}`
+    ];
+    if (totalBytes > 0) {
+      parts.push(`bytes=${totalBytes}`);
+    }
+    if (totalChunkDurationMs > 0) {
+      parts.push(`audio=${roundMetric(totalChunkDurationMs)}ms`);
+    }
+    rows.push(parts.join(" "));
+    index = endIndex + 1;
+  }
+  return rows;
+};
+var createVoiceCallReviewFromLiveTelephonyReport = (report, options = {}) => {
+  const fixture = report.fixtures?.[0];
+  if (!fixture) {
+    throw new Error("Live telephony review requires at least one fixture result.");
+  }
+  const timeline = [...report.trace ?? []].sort((left, right) => left.atMs - right.atMs);
+  const firstPartial = findTimelineEvent(timeline, "partial", "stt");
+  const commitEvent = findTimelineEvent(timeline, "commit", "turn");
+  const firstTtsAudio = findTimelineEvent(timeline, "tts-first-audio", "benchmark");
+  const firstOutboundMedia = findTimelineEvent(timeline, "media", "twilio");
+  const bargeInEvent = findTimelineEvent(timeline, "barge-in", "benchmark");
+  const clearEvent = findTimelineEvent(timeline, "clear", "twilio");
+  const lastSttText = [...timeline].reverse().find((entry) => entry.source === "stt" && (entry.event === "partial" || entry.event === "final") && typeof entry.text === "string" && entry.text.length > 0)?.text ?? undefined;
+  const latencyBreakdown = [
+    typeof firstPartial?.atMs === "number" ? {
+      label: "start to first partial",
+      valueMs: firstPartial.atMs
+    } : undefined,
+    typeof firstPartial?.atMs === "number" && typeof commitEvent?.atMs === "number" ? {
+      label: "first partial to commit",
+      valueMs: commitEvent.atMs - firstPartial.atMs
+    } : undefined,
+    typeof commitEvent?.atMs === "number" && typeof firstTtsAudio?.atMs === "number" ? {
+      label: "commit to first TTS audio",
+      valueMs: firstTtsAudio.atMs - commitEvent.atMs
+    } : undefined,
+    typeof commitEvent?.atMs === "number" && typeof firstOutboundMedia?.atMs === "number" ? {
+      label: "commit to first outbound media",
+      valueMs: firstOutboundMedia.atMs - commitEvent.atMs
+    } : undefined,
+    typeof bargeInEvent?.atMs === "number" && typeof clearEvent?.atMs === "number" ? {
+      label: "barge-in to clear",
+      valueMs: clearEvent.atMs - bargeInEvent.atMs
+    } : undefined
+  ].filter((value) => value !== undefined && value.valueMs >= 0);
+  const notes = [
+    report.variant?.description,
+    firstPartial?.text ? `First partial: "${firstPartial.text}"` : undefined,
+    lastSttText ? `Last STT text: "${lastSttText}"` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return {
+    config: {
+      preset: options.preset,
+      stt: report.variant ? {
+        description: report.variant.description,
+        id: report.variant.id,
+        model: report.variant.model
+      } : undefined,
+      tts: report.ttsConfig,
+      turnDetection: report.turnDetectionConfig
+    },
+    errors: fixture.errors ?? [],
+    expectedText: fixture.expectedText,
+    fixtureId: fixture.fixtureId,
+    generatedAt: report.generatedAt,
+    latencyBreakdown,
+    notes,
+    path: options.path,
+    summary: {
+      clearLatencyMs: roundMetric(fixture.clearLatencyMs),
+      elapsedMs: roundMetric(fixture.elapsedMs),
+      firstOutboundMediaLatencyMs: roundMetric(fixture.firstOutboundMediaLatencyMs),
+      firstTurnLatencyMs: roundMetric(fixture.firstTurnLatencyMs),
+      markLatencyMs: roundMetric(fixture.markLatencyMs),
+      outboundMediaCount: fixture.outboundMediaCount,
+      pass: fixture.passes,
+      termRecall: roundMetric(fixture.termRecall),
+      turnCount: fixture.turnCount,
+      wordErrorRate: roundMetric(fixture.wordErrorRate)
+    },
+    title: fixture.title ?? "Voice Call Review",
+    timeline,
+    transcript: {
+      actual: fixture.actualText,
+      expected: fixture.expectedText
+    }
+  };
+};
+var withVoiceCallReviewId = (id, artifact) => ({
+  ...artifact,
+  id
+});
+var toErrorMessage = (error) => {
+  if (typeof error === "string" && error.trim().length > 0) {
+    return error;
+  }
+  if (error instanceof Error && error.message.trim().length > 0) {
+    return error.message;
+  }
+  return "Unknown call error";
+};
+var createVoiceCallReviewRecorder = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const startedAt = now();
+  const errors = [];
+  const timeline = [];
+  const committedTurns = [];
+  const committedTurnIds = new Set;
+  const push = (source, event, fields = {}) => {
+    timeline.push({
+      atMs: Math.max(0, now() - startedAt),
+      event,
+      source,
+      ...fields
+    });
+  };
+  return {
+    finalize: () => {
+      const sortedTimeline = [...timeline].sort((left, right) => left.atMs - right.atMs);
+      const firstPartial = findTimelineEvent(sortedTimeline, "partial", "stt");
+      const commitEvent = findTimelineEvent(sortedTimeline, "commit", "turn");
+      const firstTtsAudio = findTimelineEvent(sortedTimeline, "tts-first-audio", "benchmark");
+      const firstOutboundMedia = findTimelineEvent(sortedTimeline, "media", "twilio");
+      const bargeInEvent = findTimelineEvent(sortedTimeline, "barge-in", "benchmark");
+      const clearEvent = findTimelineEvent(sortedTimeline, "clear", "twilio");
+      const markEvent = findTimelineEvent(sortedTimeline, "mark", "twilio");
+      const elapsedMs = sortedTimeline.at(-1)?.atMs ?? 0;
+      const lastSttText = [...sortedTimeline].reverse().find((entry) => entry.source === "stt" && (entry.event === "partial" || entry.event === "final") && typeof entry.text === "string" && entry.text.length > 0)?.text ?? undefined;
+      const latencyBreakdown = [
+        typeof firstPartial?.atMs === "number" ? {
+          label: "start to first partial",
+          valueMs: firstPartial.atMs
+        } : undefined,
+        typeof firstPartial?.atMs === "number" && typeof commitEvent?.atMs === "number" ? {
+          label: "first partial to commit",
+          valueMs: commitEvent.atMs - firstPartial.atMs
+        } : undefined,
+        typeof commitEvent?.atMs === "number" && typeof firstTtsAudio?.atMs === "number" ? {
+          label: "commit to first TTS audio",
+          valueMs: firstTtsAudio.atMs - commitEvent.atMs
+        } : undefined,
+        typeof commitEvent?.atMs === "number" && typeof firstOutboundMedia?.atMs === "number" ? {
+          label: "commit to first outbound media",
+          valueMs: firstOutboundMedia.atMs - commitEvent.atMs
+        } : undefined,
+        typeof bargeInEvent?.atMs === "number" && typeof clearEvent?.atMs === "number" ? {
+          label: "barge-in to clear",
+          valueMs: clearEvent.atMs - bargeInEvent.atMs
+        } : undefined
+      ].filter((value) => value !== undefined && value.valueMs >= 0);
+      return {
+        config: options.config,
+        errors,
+        fixtureId: options.fixtureId,
+        generatedAt: now(),
+        latencyBreakdown,
+        notes: [
+          firstPartial?.text ? `First partial: "${firstPartial.text}"` : undefined,
+          lastSttText ? `Last STT text: "${lastSttText}"` : undefined
+        ].filter((value) => typeof value === "string"),
+        path: options.path,
+        summary: {
+          clearLatencyMs: roundMetric(typeof clearEvent?.atMs === "number" && typeof bargeInEvent?.atMs === "number" ? clearEvent.atMs - bargeInEvent.atMs : undefined),
+          elapsedMs: roundMetric(elapsedMs),
+          firstOutboundMediaLatencyMs: roundMetric(firstOutboundMedia?.atMs),
+          firstTurnLatencyMs: roundMetric(commitEvent?.atMs),
+          markLatencyMs: roundMetric(markEvent?.atMs),
+          outboundMediaCount: sortedTimeline.filter((entry) => entry.source === "twilio" && entry.event === "media").length,
+          pass: errors.length === 0,
+          turnCount: committedTurns.length
+        },
+        title: options.title ?? "Voice Call Review",
+        timeline: sortedTimeline,
+        transcript: {
+          actual: committedTurns.join(" ").trim()
+        }
+      };
+    },
+    recordError: (error) => {
+      const message = toErrorMessage(error);
+      errors.push(message);
+      push("turn", "error", {
+        reason: message
+      });
+    },
+    recordTwilioInbound: (input) => {
+      push("twilio", input.event, {
+        bytes: input.bytes,
+        chunkDurationMs: input.chunkDurationMs,
+        name: input.name,
+        reason: input.reason,
+        text: input.text,
+        track: input.track
+      });
+    },
+    recordTwilioOutbound: (input) => {
+      push("twilio", input.event, {
+        bytes: input.bytes,
+        chunkDurationMs: input.chunkDurationMs,
+        name: input.name,
+        reason: input.reason,
+        text: input.text,
+        track: input.track
+      });
+    },
+    recordVoiceMessage: (message) => {
+      switch (message.type) {
+        case "partial":
+        case "final":
+          push("stt", message.type, {
+            confidence: message.transcript.confidence,
+            text: message.transcript.text
+          });
+          return;
+        case "assistant":
+          push("turn", "assistant", {
+            text: message.text
+          });
+          return;
+        case "audio":
+          push("benchmark", timeline.some((entry) => entry.event === "tts-first-audio") ? "tts-audio" : "tts-first-audio", {
+            bytes: Math.floor(message.chunkBase64.length * 3 / 4)
+          });
+          return;
+        case "turn":
+          if (committedTurnIds.has(message.turn.id)) {
+            return;
+          }
+          committedTurnIds.add(message.turn.id);
+          committedTurns.push(message.turn.text);
+          push("turn", "commit", {
+            confidence: message.turn.quality?.averageConfidence,
+            text: message.turn.text
+          });
+          return;
+        case "error":
+          errors.push(message.message);
+          push("turn", "error", {
+            reason: message.message
+          });
+          return;
+        case "complete":
+          push("turn", "complete", {
+            text: message.sessionId
+          });
+          return;
+        case "session":
+          push("turn", "session", {
+            reason: message.status,
+            text: message.sessionId
+          });
+          return;
+        case "pong":
+          push("benchmark", "pong");
+      }
+    }
+  };
+};
+var renderConfigSection = (config) => {
+  if (!config) {
+    return "";
+  }
+  return [
+    "## Config",
+    "",
+    "```json",
+    JSON.stringify(config, null, 2),
+    "```"
+  ].join(`
+`);
+};
+var renderTimeline = (timeline) => {
+  const focusedTimeline = timeline.filter((entry) => !isLowSignalTimelineEvent(entry));
+  if (focusedTimeline.length === 0) {
+    return `## Timeline
+
+_No timeline events captured._`;
+  }
+  const lines = compactTimeline(focusedTimeline);
+  return ["## Timeline", "", ...lines].join(`
+`);
+};
+var renderTransportSummary = (timeline) => {
+  const summaries = summarizeTimelineTraffic(timeline);
+  if (summaries.length === 0) {
+    return "";
+  }
+  return [
+    "## Transport Summary",
+    "",
+    ...summaries.map((summary) => {
+      const parts = [`- ${summary.label}: ${summary.count}`];
+      if (summary.bytes > 0) {
+        parts.push(`${summary.bytes} bytes`);
+      }
+      if ((summary.audioMs ?? 0) > 0) {
+        parts.push(`${roundMetric(summary.audioMs)}ms audio`);
+      }
+      return parts.join(", ");
+    })
+  ].join(`
+`);
+};
+var renderLatencyBreakdown = (breakdown) => {
+  if (breakdown.length === 0) {
+    return "";
+  }
+  return [
+    "## Latency Breakdown",
+    "",
+    ...breakdown.map((entry) => `- ${entry.label}: ${roundMetric(entry.valueMs)}ms`)
+  ].join(`
+`);
+};
+var renderVoiceCallReviewHTML = (artifact) => {
+  const notes = artifact.notes.map((note) => `<li>${escapeHtml(note)}</li>`).join("");
+  const latency = artifact.latencyBreakdown.map((entry) => `<li><strong>${escapeHtml(entry.label)}:</strong> ${roundMetric(entry.valueMs)}ms</li>`).join("");
+  const transport = summarizeTimelineTraffic(artifact.timeline).map((summary) => {
+    const parts = [`${summary.count}`, "events"];
+    if (summary.bytes > 0) {
+      parts.push(`${summary.bytes} bytes`);
+    }
+    if ((summary.audioMs ?? 0) > 0) {
+      parts.push(`${roundMetric(summary.audioMs)}ms audio`);
+    }
+    return `<li><strong>${escapeHtml(summary.label)}:</strong> ${escapeHtml(parts.join(", "))}</li>`;
+  }).join("");
+  const timeline = compactTimeline(artifact.timeline.filter((entry) => !isLowSignalTimelineEvent(entry))).map((line) => `<li>${escapeHtml(line.replace(/^- /u, ""))}</li>`).join("");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(artifact.title)}</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { font-family: ui-sans-serif, system-ui, sans-serif; margin: 0; padding: 24px; background: #0b0d10; color: #f4f4f5; }
+    main { max-width: 980px; margin: 0 auto; display: grid; gap: 16px; }
+    section { background: #13161b; border: 1px solid #232833; border-radius: 16px; padding: 18px; }
+    h1, h2 { margin: 0 0 12px; }
+    ul { margin: 0; padding-left: 20px; display: grid; gap: 8px; }
+    code, pre { font-family: ui-monospace, SFMono-Regular, monospace; }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; background: #0f1217; border-radius: 12px; padding: 14px; border: 1px solid #232833; }
+    .grid { display: grid; gap: 16px; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); }
+    .metric { display: grid; gap: 4px; }
+    .label { color: #a1a1aa; font-size: 0.82rem; text-transform: uppercase; letter-spacing: 0.08em; }
+    .value { font-size: 1.05rem; }
+  </style>
+</head>
+<body>
+  <main>
+    <section>
+      <h1>${escapeHtml(artifact.title)}</h1>
+      <div class="grid">
+        <div class="metric"><div class="label">Pass</div><div class="value">${artifact.summary.pass ? "yes" : "no"}</div></div>
+        <div class="metric"><div class="label">First Turn</div><div class="value">${artifact.summary.firstTurnLatencyMs ?? "n/a"}ms</div></div>
+        <div class="metric"><div class="label">First Outbound Media</div><div class="value">${artifact.summary.firstOutboundMediaLatencyMs ?? "n/a"}ms</div></div>
+        <div class="metric"><div class="label">Turn Count</div><div class="value">${artifact.summary.turnCount ?? "n/a"}</div></div>
+      </div>
+    </section>
+    <section>
+      <h2>Transcript</h2>
+      <ul>
+        <li><strong>Expected:</strong> ${escapeHtml(artifact.transcript.expected ?? "n/a")}</li>
+        <li><strong>Actual:</strong> ${escapeHtml(artifact.transcript.actual || "n/a")}</li>
+      </ul>
+    </section>
+    <section>
+      <h2>Notes</h2>
+      <ul>${notes || "<li>No notes.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Latency Breakdown</h2>
+      <ul>${latency || "<li>No latency data.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Transport Summary</h2>
+      <ul>${transport || "<li>No transport data.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Timeline</h2>
+      <ul>${timeline || "<li>No timeline events.</li>"}</ul>
+    </section>
+    <section>
+      <h2>Config</h2>
+      <pre>${escapeHtml(JSON.stringify(artifact.config ?? {}, null, 2))}</pre>
+    </section>
+  </main>
+</body>
+</html>`;
+};
+var renderVoiceCallReviewMarkdown = (artifact) => {
+  const summaryLines = [
+    `- pass: ${artifact.summary.pass ? "yes" : "no"}`,
+    formatMetric("first turn", artifact.summary.firstTurnLatencyMs),
+    formatMetric("first outbound media", artifact.summary.firstOutboundMediaLatencyMs),
+    formatMetric("mark", artifact.summary.markLatencyMs),
+    formatMetric("clear", artifact.summary.clearLatencyMs),
+    formatMetric("elapsed", artifact.summary.elapsedMs),
+    typeof artifact.summary.wordErrorRate === "number" ? `- word error rate: ${artifact.summary.wordErrorRate}` : undefined,
+    typeof artifact.summary.termRecall === "number" ? `- term recall: ${artifact.summary.termRecall}` : undefined,
+    typeof artifact.summary.turnCount === "number" ? `- turn count: ${artifact.summary.turnCount}` : undefined,
+    typeof artifact.summary.outboundMediaCount === "number" ? `- outbound media count: ${artifact.summary.outboundMediaCount}` : undefined
+  ].filter((value) => typeof value === "string");
+  const notes = artifact.notes.length ? ["## Notes", "", ...artifact.notes.map((note) => `- ${note}`)].join(`
+`) : "";
+  const errors = artifact.errors.length ? ["## Errors", "", ...artifact.errors.map((error) => `- ${error}`)].join(`
+`) : "";
+  const latency = renderLatencyBreakdown(artifact.latencyBreakdown);
+  const transportSummary = renderTransportSummary(artifact.timeline);
+  return [
+    `# ${artifact.title}`,
+    "",
+    artifact.path ? `Source: \`${artifact.path}\`` : undefined,
+    artifact.fixtureId ? `Fixture: \`${artifact.fixtureId}\`` : undefined,
+    "",
+    "## Summary",
+    "",
+    ...summaryLines,
+    "",
+    "## Transcript",
+    "",
+    `- expected: ${artifact.transcript.expected ?? "_n/a_"}`,
+    `- actual: ${artifact.transcript.actual}`,
+    "",
+    notes,
+    notes ? "" : undefined,
+    latency,
+    latency ? "" : undefined,
+    transportSummary,
+    transportSummary ? "" : undefined,
+    errors,
+    errors ? "" : undefined,
+    renderConfigSection(artifact.config),
+    renderConfigSection(artifact.config) ? "" : undefined,
+    renderTimeline(artifact.timeline)
+  ].filter((value) => typeof value === "string").join(`
+`);
+};
+
+// src/drizzle/runtimeStorage.ts
+var voiceAuditDeliveriesTable = voiceDocumentTable("voice_audit_deliveries");
+var voiceAuditTable = voiceDocumentTable("voice_audit");
+var voiceCampaignsTable = voiceDocumentTable("voice_campaigns");
+var voiceEventsTable = voiceDocumentTable("voice_events");
+var voiceExternalObjectsTable = voiceDocumentTable("voice_external_objects");
+var voiceReviewsTable = voiceDocumentTable("voice_reviews");
+var voiceSessionsTable = voiceDocumentTable("voice_sessions");
+var voiceTasksTable = voiceDocumentTable("voice_tasks");
+var voiceTelephonyWebhookIdempotencyTable = voiceDocumentTable("voice_telephony_webhook_idempotency");
+var voiceTraceDeliveriesTable = voiceDocumentTable("voice_trace_deliveries");
+var voiceTracesTable = voiceDocumentTable("voice_traces");
+var voiceRuntimeStorageDrizzleSchema = {
+  voiceAudit: voiceAuditTable,
+  voiceAuditDeliveries: voiceAuditDeliveriesTable,
+  voiceCampaigns: voiceCampaignsTable,
+  voiceEvents: voiceEventsTable,
+  voiceExternalObjects: voiceExternalObjectsTable,
+  voiceReviews: voiceReviewsTable,
+  voiceSessions: voiceSessionsTable,
+  voiceTasks: voiceTasksTable,
+  voiceTelephonyWebhookIdempotency: voiceTelephonyWebhookIdempotencyTable,
+  voiceTraceDeliveries: voiceTraceDeliveriesTable,
+  voiceTraces: voiceTracesTable
+};
+var createDrizzleSessionStore = (db) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (_id, value) => value,
+    getSortAt: (value) => value.lastActivityAt ?? value.createdAt,
+    table: voiceSessionsTable
+  });
+  const getOrCreate = async (id) => {
+    const existing = await store.get(id);
+    if (existing) {
+      return existing;
+    }
+    const session = createVoiceSessionRecord(id);
+    await store.set(id, session);
+    return session;
+  };
+  return {
+    get: store.get,
+    getOrCreate,
+    remove: store.remove,
+    set: store.set,
+    list: async () => (await store.list()).map((session) => toVoiceSessionSummary(session)).sort((first, second) => (second.lastActivityAt ?? second.createdAt) - (first.lastActivityAt ?? first.createdAt))
+  };
+};
+var createDrizzleReviewStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (id, value) => withVoiceCallReviewId(id, value),
+  getSortAt: (value) => value.generatedAt ?? 0,
+  table: voiceReviewsTable
+});
+var createDrizzleTaskStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (id, value) => withVoiceOpsTaskId(id, value),
+  getSortAt: (value) => value.createdAt,
+  table: voiceTasksTable
+});
+var createDrizzleEventStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (id, value) => withVoiceIntegrationEventId(id, value),
+  getSortAt: (value) => value.createdAt,
+  table: voiceEventsTable
+});
+var createDrizzleExternalObjectMapStore = (db) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (id, value) => ({
+      ...value,
+      id
+    }),
+    getSortAt: (value) => value.updatedAt,
+    table: voiceExternalObjectsTable
+  });
+  const find = async (input) => (await store.list()).find((mapping) => mapping.provider === input.provider && mapping.sourceId === input.sourceId && (input.sinkId === undefined || mapping.sinkId === input.sinkId) && (input.sourceType === undefined || mapping.sourceType === input.sourceType));
+  return {
+    ...store,
+    find
+  };
+};
+var createDrizzleTraceEventStore = (db) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (id, value) => ({ ...value, id }),
+    getSortAt: (value) => value.at,
+    table: voiceTracesTable
+  });
+  const append = async (event) => {
+    const stored = createVoiceTraceEvent(event);
+    await store.set(stored.id, stored);
+    return stored;
+  };
+  return {
+    append,
+    get: store.get,
+    remove: store.remove,
+    list: async (filter) => filterVoiceTraceEvents(await store.list(), filter)
+  };
+};
+var createDrizzleTraceSinkDeliveryStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (id, value) => ({
+    ...value,
+    id
+  }),
+  getSortAt: (value) => value.createdAt,
+  table: voiceTraceDeliveriesTable
+});
+var createDrizzleAuditEventStore = (db) => {
+  const store = createVoiceDrizzleRecordStore({
+    db,
+    decorate: (_id, value) => value,
+    getSortAt: (value) => value.at,
+    table: voiceAuditTable
+  });
+  const append = async (event) => {
+    const stored = createVoiceAuditEvent(event);
+    await store.set(stored.id, stored);
+    return stored;
+  };
+  return {
+    append,
+    get: store.get,
+    list: async (filter) => filterVoiceAuditEvents(await store.list(), filter)
+  };
+};
+var createDrizzleAuditSinkDeliveryStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (id, value) => ({
+    ...value,
+    id
+  }),
+  getSortAt: (value) => value.createdAt,
+  table: voiceAuditDeliveriesTable
+});
+var createDrizzleTelephonyWebhookIdempotencyStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (_id, value) => value,
+  getSortAt: (value) => value.updatedAt,
+  table: voiceTelephonyWebhookIdempotencyTable
+});
+var createDrizzleCampaignStore = (db) => createVoiceDrizzleRecordStore({
+  db,
+  decorate: (_id, value) => value,
+  getSortAt: (value) => value.campaign.createdAt,
+  table: voiceCampaignsTable
+});
+var createVoiceDrizzleAuditEventStore = (options) => createDrizzleAuditEventStore(options.db);
+var createVoiceDrizzleAuditSinkDeliveryStore = (options) => createDrizzleAuditSinkDeliveryStore(options.db);
+var createVoiceDrizzleCampaignStore = (options) => createDrizzleCampaignStore(options.db);
+var createVoiceDrizzleExternalObjectMapStore = (options) => createDrizzleExternalObjectMapStore(options.db);
+var createVoiceDrizzleIntegrationEventStore = (options) => createDrizzleEventStore(options.db);
+var createVoiceDrizzleReviewStore = (options) => createDrizzleReviewStore(options.db);
+var createVoiceDrizzleRuntimeStorage = (options) => ({
+  audit: createDrizzleAuditEventStore(options.db),
+  auditDeliveries: createDrizzleAuditSinkDeliveryStore(options.db),
+  campaigns: createDrizzleCampaignStore(options.db),
+  events: createDrizzleEventStore(options.db),
+  externalObjects: createDrizzleExternalObjectMapStore(options.db),
+  incidentBundles: createVoiceDrizzleIncidentBundleStore({
+    db: options.db
+  }),
+  memories: createVoiceDrizzleAssistantMemoryStore({ db: options.db }),
+  reviews: createDrizzleReviewStore(options.db),
+  session: createDrizzleSessionStore(options.db),
+  tasks: createDrizzleTaskStore(options.db),
+  traceDeliveries: createDrizzleTraceSinkDeliveryStore(options.db),
+  traces: createDrizzleTraceEventStore(options.db)
+});
+var createVoiceDrizzleSessionStore = (options) => createDrizzleSessionStore(options.db);
+var createVoiceDrizzleTaskStore = (options) => createDrizzleTaskStore(options.db);
+var createVoiceDrizzleTelephonyWebhookIdempotencyStore = (options) => createDrizzleTelephonyWebhookIdempotencyStore(options.db);
+var createVoiceDrizzleTraceEventStore = (options) => createDrizzleTraceEventStore(options.db);
+var createVoiceDrizzleTraceSinkDeliveryStore = (options) => createDrizzleTraceSinkDeliveryStore(options.db);
+
+// src/drizzle/index.ts
+var voiceDrizzleSchema = {
+  ...voiceRuntimeStorageDrizzleSchema,
+  voiceAssistantMemory: voiceAssistantMemoryTable,
+  voiceEvalBaseline: voiceEvalBaselineTable,
+  voiceHandoffDeliveries: voiceHandoffDeliveriesTable,
+  voiceIncidentBundles: voiceIncidentBundlesTable,
+  voiceObservabilityExportReceipts: voiceObservabilityExportDeliveryReceiptsTable,
+  voiceRealCallProfileEvidence: voiceRealCallProfileEvidenceTable,
+  voiceRealCallProfileRecoveryJobs: voiceRealCallProfileRecoveryJobsTable
+};
+export {
+  voiceTracesTable,
+  voiceTraceDeliveriesTable,
+  voiceTelephonyWebhookIdempotencyTable,
+  voiceTasksTable,
+  voiceSessionsTable,
+  voiceRuntimeStorageDrizzleSchema,
+  voiceReviewsTable,
+  voiceRealCallProfileRecoveryJobsTable,
+  voiceRealCallProfileEvidenceTable,
+  voiceObservabilityExportDeliveryReceiptsTable,
+  voiceIncidentBundlesTable,
+  voiceHandoffDeliveriesTable,
+  voiceExternalObjectsTable,
+  voiceEventsTable,
+  voiceEvalBaselineTable,
+  voiceDrizzleSchema,
+  voiceDocumentTable,
+  voiceCampaignsTable,
+  voiceAuditTable,
+  voiceAuditDeliveriesTable,
+  voiceAssistantMemoryTable,
+  createVoiceDrizzleTraceSinkDeliveryStore,
+  createVoiceDrizzleTraceEventStore,
+  createVoiceDrizzleTelephonyWebhookIdempotencyStore,
+  createVoiceDrizzleTaskStore,
+  createVoiceDrizzleSessionStore,
+  createVoiceDrizzleRuntimeStorage,
+  createVoiceDrizzleReviewStore,
+  createVoiceDrizzleRecordStore,
+  createVoiceDrizzleRealCallProfileRecoveryJobStore,
+  createVoiceDrizzleRealCallProfileEvidenceStore,
+  createVoiceDrizzleObservabilityExportDeliveryReceiptStore,
+  createVoiceDrizzleIntegrationEventStore,
+  createVoiceDrizzleIncidentBundleStore,
+  createVoiceDrizzleHandoffDeliveryStore,
+  createVoiceDrizzleExternalObjectMapStore,
+  createVoiceDrizzleEvalBaselineStore,
+  createVoiceDrizzleCampaignStore,
+  createVoiceDrizzleAuditSinkDeliveryStore,
+  createVoiceDrizzleAuditEventStore,
+  createVoiceDrizzleAssistantMemoryStore
+};