diff --git a/apps/brunch-agent/.env.example b/apps/brunch-agent/.env.example
new file mode 100644
index 00000000000..7a79371414e
--- /dev/null
+++ b/apps/brunch-agent/.env.example
@@ -0,0 +1,5 @@
+ELEVENLABS_API_KEY=sk_xxxx
+ELEVENLABS_SPEECH_ENGINE_ID=seng_xxxx
+ELEVENLABS_SPEECH_ENGINE_HOST=127.0.0.1
+ELEVENLABS_SPEECH_ENGINE_PORT=3001
+BRUNCH_CHAT_ORIGIN=http://127.0.0.1:4321
diff --git a/apps/brunch-agent/package.json b/apps/brunch-agent/package.json
index fc199cec26f..40590f9fdcd 100644
--- a/apps/brunch-agent/package.json
+++ b/apps/brunch-agent/package.json
@@ -12,9 +12,11 @@
     "lint:eslint": "oxlint --type-aware --report-unused-disable-directives-severity=error .",
     "lint:tsc": "tsgo --noEmit",
     "petrinaut:dev": "vite dev --config petrinaut-local.vite.config.ts",
-    "test:unit": "vitest run --config vitest.config.ts"
+    "test:unit": "vitest run --config vitest.config.ts",
+    "voice:dev": "node --env-file-if-exists=.env.local --experimental-strip-types src/elevenlabs-speech-engine-server.ts"
   },
   "dependencies": {
+    "@elevenlabs/elevenlabs-js": "2.64.0",
     "@flue/react": "2.0.3",
     "@flue/runtime": "2.0.3",
     "@flue/sdk": "2.0.3",
diff --git a/apps/brunch-agent/petrinaut-local.vite.config.ts b/apps/brunch-agent/petrinaut-local.vite.config.ts
index 249686c8498..d234b55d427 100644
--- a/apps/brunch-agent/petrinaut-local.vite.config.ts
+++ b/apps/brunch-agent/petrinaut-local.vite.config.ts
@@ -35,7 +35,7 @@ const withoutIncumbentChatHandler = (
     ) {
       return true;
     }
-    return plugin.name !== "petrinaut-api-dev";
+    return plugin.name !== "petrinaut-chat-api-dev";
   });
 
 export default defineConfig(async (environment) => {
diff --git a/apps/brunch-agent/src/app.ts b/apps/brunch-agent/src/app.ts
index 6ce50876433..7292c86e29f 100644
--- a/apps/brunch-agent/src/app.ts
+++ b/apps/brunch-agent/src/app.ts
@@ -15,7 +15,12 @@ import { Hono } from "hono";
 import { GherkinElicitor } from "./agents/gherkin-elicitor.ts";
 import { assetHandler } from "./assets.ts";
 import { petrinautChatHandler } from "./petrinaut-chat.ts";
-import { GHERKIN_AGENT_ROUTE, PETRINAUT_CHAT_ROUTE } from "./routes.ts";
+import {
+  GHERKIN_AGENT_ROUTE,
+  PETRINAUT_CHAT_ROUTE,
+  VOICE_EXPERIMENT_DIAGNOSTICS_ROUTE,
+} from "./routes.ts";
+import { voiceExperimentDiagnosticsHandler } from "./voice-experiment-diagnostics.ts";
 
 const app = new Hono();
 
@@ -30,6 +35,9 @@ app.route(`/agents/${GHERKIN_AGENT_ROUTE}`, createAgentRouter(GherkinElicitor));
 app.on(["POST", "OPTIONS"], PETRINAUT_CHAT_ROUTE, (c) =>
   petrinautChatHandler(c.req.raw),
 );
+app.get(VOICE_EXPERIMENT_DIAGNOSTICS_ROUTE, (c) =>
+  voiceExperimentDiagnosticsHandler(c.req.raw),
+);
 
 // The flue dev controller owns the whole request space — no fall-through to
 // vite's html serving — so the ui is app-served, in dev and in production
diff --git a/apps/brunch-agent/src/elevenlabs-speech-engine-server.ts b/apps/brunch-agent/src/elevenlabs-speech-engine-server.ts
new file mode 100644
index 00000000000..ceb9425266e
--- /dev/null
+++ b/apps/brunch-agent/src/elevenlabs-speech-engine-server.ts
@@ -0,0 +1,91 @@
+import { createServer } from "node:http";
+
+import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
+
+import { BrunchVoiceBridge } from "@hashintel/brunch-agent-transport-aisdk/voice-bridge";
+
+import {
+  applySpeechEngineInterviewConfig,
+  createElevenLabsSpeechEngineCallbacks,
+} from "./elevenlabs-speech-engine.ts";
+
+const apiKey = process.env.ELEVENLABS_API_KEY;
+const speechEngineId = process.env.ELEVENLABS_SPEECH_ENGINE_ID;
+if (!apiKey || !speechEngineId) {
+  throw new Error(
+    "ELEVENLABS_API_KEY and ELEVENLABS_SPEECH_ENGINE_ID are required.",
+  );
+}
+
+const port = Number(process.env.ELEVENLABS_SPEECH_ENGINE_PORT ?? "3001");
+if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+  throw new Error("ELEVENLABS_SPEECH_ENGINE_PORT must be a valid port.");
+}
+
+const host = process.env.ELEVENLABS_SPEECH_ENGINE_HOST ?? "127.0.0.1";
+const brunchChatOrigin =
+  process.env.BRUNCH_CHAT_ORIGIN ?? "http://127.0.0.1:4321";
+const chatEndpoint = new URL("/api/chat", brunchChatOrigin).toString();
+
+const bridge = new BrunchVoiceBridge({ chatEndpoint });
+const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+const elevenLabs = new ElevenLabsClient({ apiKey });
+
+await applySpeechEngineInterviewConfig({
+  speechEngine: elevenLabs.speechEngine,
+  speechEngineId,
+});
+
+console.log(
+  "Applied Speech Engine interview config (opening message, patient turn_v3)",
+);
+
+const httpServer = createServer((request, response) => {
+  if (request.method === "GET" && request.url === "/health") {
+    response.writeHead(200, {
+      "cache-control": "no-store",
+      "content-type": "application/json",
+    });
+    response.end(JSON.stringify({ status: "ok" }));
+    return;
+  }
+
+  response.writeHead(404, { "content-type": "application/json" });
+  response.end(JSON.stringify({ error: "Not found" }));
+});
+
+// Authentication remains enabled: the SDK verifies ElevenLabs' signed JWT on
+// every WebSocket upgrade before any transcript can reach Brunch.
+const attachment = elevenLabs.speechEngine.attach(
+  speechEngineId,
+  httpServer,
+  "/ws",
+  callbacks,
+);
+
+await new Promise<void>((resolve, reject) => {
+  httpServer.once("error", reject);
+  httpServer.listen(port, host, resolve);
+});
+
+console.log(
+  `ElevenLabs Speech Engine listening on http://${host}:${port}/ws; Brunch chat is ${chatEndpoint}`,
+);
+
+let shuttingDown = false;
+const shutdown = async () => {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  await attachment.close();
+  await new Promise<void>((resolve, reject) => {
+    httpServer.close((error) => (error ? reject(error) : resolve()));
+  });
+};
+
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.once(signal, () => {
+    void shutdown().finally(() => process.exit(0));
+  });
+}
diff --git a/apps/brunch-agent/src/elevenlabs-speech-engine.ts b/apps/brunch-agent/src/elevenlabs-speech-engine.ts
new file mode 100644
index 00000000000..2194751d338
--- /dev/null
+++ b/apps/brunch-agent/src/elevenlabs-speech-engine.ts
@@ -0,0 +1,206 @@
+import type { SpeechEngineCallbacks } from "@elevenlabs/elevenlabs-js";
+
+type TranscriptMessage = {
+  content: string;
+  role: "agent" | "user";
+};
+
+type VoiceBridge = {
+  release(conversationId: string): void;
+  respond(input: {
+    conversationId: string;
+    signal: AbortSignal;
+    transcript: string;
+  }): AsyncIterable<string>;
+};
+
+type CallbackDependencies = {
+  bridge: VoiceBridge;
+  log?: (reason: string, context?: Record<string, unknown>) => void;
+};
+
+type VoiceSession = {
+  conversationId?: string;
+  sendResponse(response: AsyncIterable<string>): Promise<void>;
+};
+
+type QueuedVoiceTurn = {
+  session: VoiceSession;
+  signal: AbortSignal;
+  transcript: string;
+};
+
+type VoiceTurnState = {
+  active: Promise<void> | null;
+  lastCompletedSignal: AbortSignal | null;
+  queued: QueuedVoiceTurn | null;
+};
+
+const MAX_TRANSCRIPT_CHARACTERS = 12_000;
+
+const normalizeTranscript = (transcript: string): string => {
+  let sanitized = "";
+  for (const character of transcript.normalize("NFKC")) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (
+      codePoint === 9 ||
+      codePoint === 10 ||
+      codePoint === 13 ||
+      codePoint >= 32
+    ) {
+      sanitized += character;
+    }
+  }
+
+  return sanitized
+    .replace(/\s+/gu, " ")
+    .trim()
+    .slice(0, MAX_TRANSCRIPT_CHARACTERS);
+};
+
+const latestUserTranscript = (transcript: TranscriptMessage[]): string => {
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    const message = transcript[index];
+    if (message?.role === "user") {
+      return normalizeTranscript(message.content);
+    }
+  }
+  return "";
+};
+
+const defaultLog = (reason: string, context: Record<string, unknown> = {}) => {
+  // Provider transcript, response text, and secrets must never be logged here.
+  console.error(`[ElevenLabs Speech Engine] ${reason}`, context);
+};
+
+export const speechEngineTurnConfig = {
+  turnEagerness: "patient",
+  turnModel: "turn_v3",
+  turnTimeout: 10,
+} as const;
+
+export const speechEngineOverrides = {
+  firstMessage: true,
+} as const;
+
+type SpeechEngineConfigClient = {
+  update(
+    speechEngineId: string,
+    request: {
+      overrides: typeof speechEngineOverrides;
+      turn: typeof speechEngineTurnConfig;
+    },
+  ): Promise<unknown>;
+};
+
+export const applySpeechEngineInterviewConfig = async ({
+  speechEngine,
+  speechEngineId,
+}: {
+  speechEngine: SpeechEngineConfigClient;
+  speechEngineId: string;
+}): Promise<void> => {
+  await speechEngine.update(speechEngineId, {
+    overrides: speechEngineOverrides,
+    turn: speechEngineTurnConfig,
+  });
+};
+
+export const createElevenLabsSpeechEngineCallbacks = ({
+  bridge,
+  log = defaultLog,
+}: CallbackDependencies): SpeechEngineCallbacks => {
+  const turnStateByConversationId = new Map<string, VoiceTurnState>();
+
+  const startTurn = (
+    conversationId: string,
+    state: VoiceTurnState,
+    turn: QueuedVoiceTurn,
+  ): void => {
+    const active = turn.session
+      .sendResponse(
+        bridge.respond({
+          conversationId,
+          signal: turn.signal,
+          transcript: turn.transcript,
+        }),
+      )
+      .then(() => {
+        if (!turn.signal.aborted) {
+          state.lastCompletedSignal = turn.signal;
+        }
+      })
+      .catch((error: unknown) => {
+        if (!turn.signal.aborted) {
+          log("Could not stream the Brunch voice response", {
+            errorName: error instanceof Error ? error.name : "unknown",
+          });
+        }
+      })
+      .finally(() => {
+        if (state.active !== active) {
+          return;
+        }
+        state.active = null;
+        const queued = state.queued;
+        state.queued = null;
+        if (
+          queued &&
+          !queued.signal.aborted &&
+          queued.signal !== state.lastCompletedSignal
+        ) {
+          startTurn(conversationId, state, queued);
+        }
+      });
+    state.active = active;
+  };
+
+  const release = (conversationId: string | undefined): void => {
+    if (!conversationId) {
+      return;
+    }
+    turnStateByConversationId.delete(conversationId);
+    bridge.release(conversationId);
+  };
+
+  return {
+    debug: process.env.NODE_ENV !== "production",
+    onTranscript(transcript, signal, session) {
+      const conversationId = session.conversationId;
+      if (!conversationId) {
+        log("Rejected transcript before session initialization");
+        return;
+      }
+      const userTurn = latestUserTranscript(transcript);
+      if (!userTurn) {
+        return;
+      }
+
+      const state = turnStateByConversationId.get(conversationId) ?? {
+        active: null,
+        lastCompletedSignal: null,
+        queued: null,
+      };
+      turnStateByConversationId.set(conversationId, state);
+      if (signal === state.lastCompletedSignal) {
+        return;
+      }
+
+      const turn = { session, signal, transcript: userTurn };
+      if (state.active) {
+        state.queued = turn;
+        return;
+      }
+      startTurn(conversationId, state, turn);
+    },
+    onClose(session) {
+      release(session.conversationId);
+    },
+    onDisconnect(session) {
+      release(session.conversationId);
+    },
+    onError(error) {
+      log("Speech Engine session failed", { errorName: error.name });
+    },
+  };
+};
diff --git a/apps/brunch-agent/src/local-dev-origins.ts b/apps/brunch-agent/src/local-dev-origins.ts
index 797fc52b346..9993c63b1b9 100644
--- a/apps/brunch-agent/src/local-dev-origins.ts
+++ b/apps/brunch-agent/src/local-dev-origins.ts
@@ -17,6 +17,8 @@ export const defaultChatOrigin = `http://${localChatListen.host}:${localChatList
 export const defaultPanelOrigins = [
   `http://${localPanelListen.host}:${localPanelListen.port}`,
   `http://localhost:${localPanelListen.port}`,
+  "http://127.0.0.1:5173",
+  "http://localhost:5173",
 ] as const;
 
 export const petrinautLocalServer = (chatOrigin: string) => ({
diff --git a/apps/brunch-agent/src/petrinaut-chat.ts b/apps/brunch-agent/src/petrinaut-chat.ts
index 9480653f56d..6c3c7c74ba8 100644
--- a/apps/brunch-agent/src/petrinaut-chat.ts
+++ b/apps/brunch-agent/src/petrinaut-chat.ts
@@ -19,6 +19,7 @@ import {
 import { GherkinElicitor } from "./agents/gherkin-elicitor.ts";
 import { createGherkinElicitationSession } from "./elicitation-session.ts";
 import { defaultPanelOrigins } from "./local-dev-origins.ts";
+import { voiceExperimentDiagnostics } from "./voice-experiment-diagnostics.ts";
 
 const inspect =
   process.env.BRUNCH_TRANSPORT_AISDK_INSPECT === "1"
@@ -34,11 +35,26 @@ const inspect =
 const targetDocumentIdFor = (conversationId: string): string =>
   `petrinaut-local:${conversationId}`;
 
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
 const streamElicitorTurn = async (
   conversationId: string,
   dispatch: { readonly message: string; readonly idempotencyKey: string },
   emit: (event: HarnessReplyEvent) => void,
 ): Promise<void> => {
+  const voiceTurnId = voiceExperimentDiagnostics.beginTurn(conversationId);
+  if (voiceTurnId) {
+    voiceExperimentDiagnostics.recordTranscript(conversationId, {
+      isPartial: false,
+      speaker: "expert",
+      transcript: dispatch.message,
+      turnId: voiceTurnId,
+    });
+  }
+  let assistantText = "";
   const agent = init(GherkinElicitor, { id: conversationId });
   const receipt = await agent.dispatch({
     ...dispatch,
@@ -46,7 +62,54 @@ const streamElicitorTurn = async (
   });
   const projector = createFlueReplyProjector({
     submissionId: receipt.submissionId,
-    emit,
+    emit: (event) => {
+      if (voiceTurnId && event.type === "part-delta" && event.kind === "text") {
+        assistantText += event.delta;
+        voiceExperimentDiagnostics.recordTranscript(conversationId, {
+          isPartial: true,
+          speaker: "assistant",
+          transcript: assistantText,
+          turnId: voiceTurnId,
+        });
+      }
+      if (
+        voiceTurnId &&
+        event.type === "part-end" &&
+        event.kind === "text" &&
+        assistantText
+      ) {
+        voiceExperimentDiagnostics.recordTranscript(conversationId, {
+          isPartial: false,
+          speaker: "assistant",
+          transcript: assistantText,
+          turnId: voiceTurnId,
+        });
+      }
+      if (event.type === "tool-input") {
+        voiceExperimentDiagnostics.recordToolCall(
+          conversationId,
+          voiceTurnId,
+          event,
+        );
+        const question = asRecord(event.input)?.question;
+        if (
+          voiceTurnId &&
+          event.toolName === "brunch_ask" &&
+          typeof question === "string"
+        ) {
+          voiceExperimentDiagnostics.recordTranscript(conversationId, {
+            isPartial: false,
+            speaker: "assistant",
+            transcript: question,
+            turnId: voiceTurnId,
+          });
+        }
+      }
+      if (event.type === "tool-output") {
+        voiceExperimentDiagnostics.recordToolOutput(conversationId, event);
+      }
+      emit(event);
+    },
   });
   await agent.read(receipt, { onEvent: (chunk) => projector.accept(chunk) });
 };
diff --git a/apps/brunch-agent/src/routes.ts b/apps/brunch-agent/src/routes.ts
index 739c6323023..cddd6374cae 100644
--- a/apps/brunch-agent/src/routes.ts
+++ b/apps/brunch-agent/src/routes.ts
@@ -3,3 +3,7 @@ export const GHERKIN_AGENT_ROUTE = "gherkin";
 
 /** Stock `DefaultChatTransport` endpoint used by Petrinaut's local panel. */
 export const PETRINAUT_CHAT_ROUTE = "/api/chat";
+
+/** Read-only metadata for comparing the two local voice experiments. */
+export const VOICE_EXPERIMENT_DIAGNOSTICS_ROUTE =
+  "/api/voice-experiment/elevenlabs-brunch-diagnostics";
diff --git a/apps/brunch-agent/src/voice-experiment-diagnostics.ts b/apps/brunch-agent/src/voice-experiment-diagnostics.ts
new file mode 100644
index 00000000000..e746472c171
--- /dev/null
+++ b/apps/brunch-agent/src/voice-experiment-diagnostics.ts
@@ -0,0 +1,372 @@
+import type { HarnessReplyEvent } from "@hashintel/brunch-agent";
+
+const VOICE_CONVERSATION_PREFIX = "voice:";
+const TRUSTED_EXPERIMENT = "elevenlabs-brunch";
+const MAX_SESSIONS = 100;
+const MAX_EVENTS_PER_SESSION = 50;
+const MAX_IDENTIFIER_CHARACTERS = 96;
+const MAX_SUMMARY_CHARACTERS = 240;
+const MAX_TRANSCRIPT_CHARACTERS = 4_000;
+const MAX_CAPTURE_VALUE_CHARACTERS = 500;
+const providerConversationIdPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+
+type VoiceCaptureDiagnostic = {
+  readonly captureId: string;
+  readonly input: Record<string, string | string[]>;
+  readonly toolName: string;
+};
+
+export type VoiceToolDiagnostic = {
+  readonly argumentSummary: string;
+  readonly callId: string;
+  readonly capture?: VoiceCaptureDiagnostic;
+  readonly sequence: number;
+  readonly timestampMs: number;
+  readonly toolName: string;
+  readonly turnId: number;
+};
+
+export type VoiceTranscriptDiagnostic = {
+  readonly sequence: number;
+  readonly speaker: "assistant" | "expert";
+  readonly timestampMs: number;
+  readonly transcript: string;
+  readonly turnId: number;
+  readonly type: "final-transcript" | "partial-transcript";
+};
+
+export type VoiceProjectionReadyDiagnostic = {
+  readonly callId: string;
+  readonly sequence: number;
+  readonly timestampMs: number;
+  readonly type: "projection-ready";
+};
+
+export type VoiceDiagnosticEvent =
+  | VoiceProjectionReadyDiagnostic
+  | VoiceToolDiagnostic
+  | VoiceTranscriptDiagnostic;
+
+type DiagnosticSession = {
+  events: VoiceDiagnosticEvent[];
+  nextSequence: number;
+  nextTurnId: number;
+  toolNameByCallId: Map<string, string>;
+};
+
+type VoiceExperimentDiagnosticsDependencies = {
+  now: () => number;
+};
+
+const defaultDependencies: VoiceExperimentDiagnosticsDependencies = {
+  now: () => Date.now(),
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
+const boundedText = (value: unknown, limit: number): string => {
+  if (typeof value !== "string") {
+    return "";
+  }
+
+  let sanitized = "";
+  for (const character of value.normalize("NFKC")) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint >= 32 && codePoint !== 127) {
+      sanitized += character;
+    }
+  }
+
+  return sanitized.replace(/\s+/gu, " ").trim().slice(0, limit);
+};
+
+const safeIdentifier = (value: string, fallback: string): string =>
+  boundedText(value, MAX_IDENTIFIER_CHARACTERS) || fallback;
+
+const summarizeToolInput = (toolName: string, input: unknown): string => {
+  if (toolName === "brunch_ask") {
+    const question = boundedText(
+      asRecord(input)?.question,
+      MAX_SUMMARY_CHARACTERS - "Question: ".length,
+    );
+    return question ? `Question: ${question}` : "Question unavailable";
+  }
+
+  if (toolName === "brunch_sweep") {
+    return "Settlement requested";
+  }
+
+  return "Arguments hidden";
+};
+
+const capturePropertiesByToolName = {
+  record_model_requirement: ["category", "description"],
+  record_process_decision: ["condition", "outcomes"],
+  record_process_flow: ["condition", "from", "to"],
+  record_process_state: ["category", "description", "name", "tokenDescription"],
+  record_process_step: ["description", "name", "owner", "timing", "trigger"],
+} as const;
+
+const createCaptureDiagnostic = ({
+  callId,
+  input,
+  toolName,
+}: {
+  callId: string;
+  input: unknown;
+  toolName: string;
+}): VoiceCaptureDiagnostic | null => {
+  if (!Object.hasOwn(capturePropertiesByToolName, toolName)) {
+    return null;
+  }
+  const inputRecord = asRecord(input);
+  if (!inputRecord) {
+    return null;
+  }
+  const properties =
+    capturePropertiesByToolName[
+      toolName as keyof typeof capturePropertiesByToolName
+    ];
+  const sanitizedInput: Record<string, string | string[]> = {};
+  for (const property of properties) {
+    const value = inputRecord[property];
+    if (typeof value === "string") {
+      const sanitized = boundedText(value, MAX_CAPTURE_VALUE_CHARACTERS);
+      if (sanitized) {
+        sanitizedInput[property] = sanitized;
+      }
+    } else if (Array.isArray(value)) {
+      const sanitized = value
+        .map((item) => boundedText(item, MAX_CAPTURE_VALUE_CHARACTERS))
+        .filter(Boolean)
+        .slice(0, 20);
+      if (sanitized.length > 0) {
+        sanitizedInput[property] = sanitized;
+      }
+    }
+  }
+  if (Object.keys(sanitizedInput).length === 0) {
+    return null;
+  }
+
+  return {
+    captureId: `capture-${callId}`,
+    input: sanitizedInput,
+    toolName,
+  };
+};
+
+export class VoiceExperimentDiagnostics {
+  readonly #dependencies: VoiceExperimentDiagnosticsDependencies;
+  readonly #sessions = new Map<string, DiagnosticSession>();
+
+  public constructor(
+    dependencies: Partial<VoiceExperimentDiagnosticsDependencies> = {},
+  ) {
+    this.#dependencies = { ...defaultDependencies, ...dependencies };
+  }
+
+  public beginTurn(conversationId: string): number {
+    if (!conversationId.startsWith(VOICE_CONVERSATION_PREFIX)) {
+      return 0;
+    }
+
+    const session = this.#sessionFor(conversationId);
+    session.nextTurnId += 1;
+    return session.nextTurnId;
+  }
+
+  public recordTranscript(
+    conversationId: string,
+    event: {
+      isPartial: boolean;
+      speaker: "assistant" | "expert";
+      transcript: string;
+      turnId: number;
+    },
+  ): void {
+    if (
+      !conversationId.startsWith(VOICE_CONVERSATION_PREFIX) ||
+      !Number.isSafeInteger(event.turnId) ||
+      event.turnId < 1
+    ) {
+      return;
+    }
+
+    const transcript = boundedText(event.transcript, MAX_TRANSCRIPT_CHARACTERS);
+    if (!transcript) {
+      return;
+    }
+
+    const session = this.#sessionFor(conversationId);
+    const type = event.isPartial ? "partial-transcript" : "final-transcript";
+    const last = session.events.at(-1);
+    if (last && "speaker" in last && last.speaker === event.speaker) {
+      if (last.transcript === transcript && last.type === type) {
+        return;
+      }
+
+      session.nextSequence += 1;
+      session.events[session.events.length - 1] = {
+        sequence: session.nextSequence,
+        speaker: event.speaker,
+        timestampMs: this.#dependencies.now(),
+        transcript,
+        turnId: event.turnId,
+        type,
+      };
+      return;
+    }
+
+    session.nextSequence += 1;
+    session.events.push({
+      sequence: session.nextSequence,
+      speaker: event.speaker,
+      timestampMs: this.#dependencies.now(),
+      transcript,
+      turnId: event.turnId,
+      type,
+    });
+    session.events = session.events.slice(-MAX_EVENTS_PER_SESSION);
+  }
+
+  public recordToolCall(
+    conversationId: string,
+    turnId: number,
+    event: Pick<
+      Extract<HarnessReplyEvent, { type: "tool-input" }>,
+      "input" | "toolCallId" | "toolName"
+    >,
+  ): void {
+    if (
+      !conversationId.startsWith(VOICE_CONVERSATION_PREFIX) ||
+      !Number.isSafeInteger(turnId) ||
+      turnId < 1
+    ) {
+      return;
+    }
+
+    const session = this.#sessionFor(conversationId);
+    session.nextSequence += 1;
+    const toolName = safeIdentifier(event.toolName, "unknown-tool");
+    const callId = safeIdentifier(event.toolCallId, "unknown-call");
+    const capture = createCaptureDiagnostic({
+      callId,
+      input: event.input,
+      toolName,
+    });
+    session.toolNameByCallId.set(callId, toolName);
+    session.events.push({
+      argumentSummary: summarizeToolInput(toolName, event.input),
+      callId,
+      ...(capture ? { capture } : {}),
+      sequence: session.nextSequence,
+      timestampMs: this.#dependencies.now(),
+      toolName,
+      turnId,
+    });
+    session.events = session.events.slice(-MAX_EVENTS_PER_SESSION);
+  }
+
+  public recordToolOutput(
+    conversationId: string,
+    event: Pick<
+      Extract<HarnessReplyEvent, { type: "tool-output" }>,
+      "output" | "toolCallId"
+    >,
+  ): void {
+    if (!conversationId.startsWith(VOICE_CONVERSATION_PREFIX)) {
+      return;
+    }
+    const session = this.#sessionFor(conversationId);
+    const callId = safeIdentifier(event.toolCallId, "unknown-call");
+    const toolName = session.toolNameByCallId.get(callId);
+    session.toolNameByCallId.delete(callId);
+    if (
+      toolName !== "brunch_sweep" ||
+      asRecord(event.output)?.status !== "applied"
+    ) {
+      return;
+    }
+
+    session.nextSequence += 1;
+    session.events.push({
+      callId,
+      sequence: session.nextSequence,
+      timestampMs: this.#dependencies.now(),
+      type: "projection-ready",
+    });
+    session.events = session.events.slice(-MAX_EVENTS_PER_SESSION);
+  }
+
+  public read(providerConversationId: string, afterSequence: number) {
+    const session = this.#sessions.get(
+      `${VOICE_CONVERSATION_PREFIX}${providerConversationId}`,
+    );
+    return (
+      session?.events.filter(({ sequence }) => sequence > afterSequence) ?? []
+    );
+  }
+
+  #sessionFor(conversationId: string): DiagnosticSession {
+    const existing = this.#sessions.get(conversationId);
+    if (existing) {
+      return existing;
+    }
+
+    if (this.#sessions.size >= MAX_SESSIONS) {
+      const oldest = this.#sessions.keys().next().value as string | undefined;
+      if (oldest) {
+        this.#sessions.delete(oldest);
+      }
+    }
+
+    const session: DiagnosticSession = {
+      events: [],
+      nextSequence: 0,
+      nextTurnId: 0,
+      toolNameByCallId: new Map(),
+    };
+    this.#sessions.set(conversationId, session);
+    return session;
+  }
+}
+
+const jsonResponse = (body: unknown, status = 200): Response =>
+  Response.json(body, {
+    status,
+    headers: { "cache-control": "no-store" },
+  });
+
+export const createVoiceExperimentDiagnosticsHandler =
+  (diagnostics: VoiceExperimentDiagnostics) =>
+  async (request: Request): Promise<Response> => {
+    if (request.method !== "GET") {
+      return jsonResponse({ error: "Method not allowed" }, 405);
+    }
+    if (request.headers.get("x-voice-experiment") !== TRUSTED_EXPERIMENT) {
+      return jsonResponse({ error: "Forbidden" }, 403);
+    }
+
+    const url = new URL(request.url);
+    const conversationId = url.searchParams.get("conversationId") ?? "";
+    const afterText = url.searchParams.get("after") ?? "0";
+    const after = Number(afterText);
+    if (
+      !providerConversationIdPattern.test(conversationId) ||
+      !/^\d+$/u.test(afterText) ||
+      !Number.isSafeInteger(after) ||
+      after < 0
+    ) {
+      return jsonResponse({ error: "Invalid diagnostic query" }, 400);
+    }
+
+    return jsonResponse({ events: diagnostics.read(conversationId, after) });
+  };
+
+export const voiceExperimentDiagnostics = new VoiceExperimentDiagnostics();
+export const voiceExperimentDiagnosticsHandler =
+  createVoiceExperimentDiagnosticsHandler(voiceExperimentDiagnostics);
diff --git a/apps/brunch-agent/test/brunch-voice-bridge.test.ts b/apps/brunch-agent/test/brunch-voice-bridge.test.ts
new file mode 100644
index 00000000000..1154e0f7e13
--- /dev/null
+++ b/apps/brunch-agent/test/brunch-voice-bridge.test.ts
@@ -0,0 +1,326 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { BrunchVoiceBridge } from "@hashintel/brunch-agent-transport-aisdk/voice-bridge";
+
+const encoder = new TextEncoder();
+
+const sseResponse = (...chunks: Record<string, unknown>[]) =>
+  new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`),
+          );
+        }
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      },
+    }),
+    {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "x-vercel-ai-ui-message-stream": "v1",
+      },
+    },
+  );
+
+const collect = async (stream: AsyncIterable<string>) => {
+  let text = "";
+  for await (const chunk of stream) {
+    text += chunk;
+  }
+  return text;
+};
+
+describe("BrunchVoiceBridge", () => {
+  test("sends the first finalized transcript through the existing chat route", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(
+        sseResponse(
+          { type: "start", messageId: "assistant-1" },
+          { type: "text-delta", id: "text-1", delta: "Tell me more." },
+          { type: "finish", finishReason: "stop" },
+        ),
+      );
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      createId: () => "generated-user-message",
+      fetch,
+    });
+    const signal = new AbortController().signal;
+
+    const reply = await collect(
+      bridge.respond({
+        conversationId: "conv_elevenlabs",
+        signal,
+        transcript: "The support lead triages the escalation.",
+      }),
+    );
+
+    expect(reply).toBe("Tell me more.");
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const [url, request] = fetch.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe("http://127.0.0.1:4321/api/chat");
+    expect(request.signal).toBe(signal);
+    expect(JSON.parse(request.body as string)).toEqual({
+      id: "voice:conv_elevenlabs",
+      trigger: "submit-message",
+      messages: [
+        {
+          id: "generated-user-message",
+          role: "user",
+          parts: [
+            {
+              type: "text",
+              text: "The support lead triages the escalation.",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("speaks brunch_ask and submits the next transcript as its human answer", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce(
+        sseResponse(
+          { type: "start", messageId: "assistant-ask" },
+          {
+            type: "tool-input-available",
+            toolCallId: "tool-call-1",
+            toolName: "brunch_ask",
+            input: { question: "Who owns the first response?" },
+          },
+          { type: "finish", finishReason: "tool-calls" },
+        ),
+      )
+      .mockResolvedValueOnce(
+        sseResponse(
+          { type: "start", messageId: "assistant-ask" },
+          {
+            type: "text-delta",
+            id: "text-2",
+            delta: "The support lead owns it. What happens next?",
+          },
+          { type: "finish", finishReason: "stop" },
+        ),
+      );
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      createId: () => "generated-user-message",
+      fetch,
+    });
+
+    const question = await collect(
+      bridge.respond({
+        conversationId: "conv_elevenlabs",
+        signal: new AbortController().signal,
+        transcript: "Help me model our escalation process.",
+      }),
+    );
+    const answerReply = await collect(
+      bridge.respond({
+        conversationId: "conv_elevenlabs",
+        signal: new AbortController().signal,
+        transcript: "The support lead.",
+      }),
+    );
+
+    expect(question).toBe("Who owns the first response?");
+    expect(answerReply).toBe("The support lead owns it. What happens next?");
+    const [, secondRequest] = fetch.mock.calls[1] as [string, RequestInit];
+    expect(JSON.parse(secondRequest.body as string)).toEqual({
+      id: "voice:conv_elevenlabs",
+      trigger: "submit-message",
+      messageId: "assistant-ask",
+      messages: [
+        {
+          id: "assistant-ask",
+          role: "assistant",
+          parts: [
+            {
+              type: "dynamic-tool",
+              toolName: "brunch_ask",
+              toolCallId: "tool-call-1",
+              state: "output-available",
+              input: { question: "Who owns the first response?" },
+              output: { answer: "The support lead." },
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("retains a pending ask when interruption happens before admission", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce(
+        sseResponse(
+          { type: "start", messageId: "assistant-ask" },
+          {
+            type: "tool-input-available",
+            toolCallId: "tool-call-1",
+            toolName: "brunch_ask",
+            input: { question: "Who owns the first response?" },
+          },
+        ),
+      )
+      .mockRejectedValueOnce(new DOMException("Interrupted", "AbortError"))
+      .mockResolvedValueOnce(
+        sseResponse(
+          { type: "start", messageId: "assistant-ask" },
+          { type: "text-delta", id: "text-2", delta: "Understood." },
+        ),
+      );
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      createId: () => "generated-user-message",
+      fetch,
+    });
+
+    await collect(
+      bridge.respond({
+        conversationId: "conv_elevenlabs",
+        signal: new AbortController().signal,
+        transcript: "Help me model our escalation process.",
+      }),
+    );
+    await expect(
+      collect(
+        bridge.respond({
+          conversationId: "conv_elevenlabs",
+          signal: AbortSignal.abort(),
+          transcript: "The support lead.",
+        }),
+      ),
+    ).rejects.toThrow("Interrupted");
+    await collect(
+      bridge.respond({
+        conversationId: "conv_elevenlabs",
+        signal: new AbortController().signal,
+        transcript: "The support lead.",
+      }),
+    );
+
+    for (const callIndex of [1, 2]) {
+      const [, request] = fetch.mock.calls[callIndex] as [string, RequestInit];
+      expect(JSON.parse(request.body as string)).toMatchObject({
+        id: "voice:conv_elevenlabs",
+        messageId: "assistant-ask",
+        messages: [
+          {
+            parts: [
+              {
+                toolCallId: "tool-call-1",
+                output: { answer: "The support lead." },
+              },
+            ],
+          },
+        ],
+      });
+    }
+  });
+
+  test("does not speak an ask question twice when text already ends with it", async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      sseResponse(
+        { type: "start", messageId: "assistant-ask" },
+        {
+          type: "text-delta",
+          id: "text-1",
+          delta: "Thanks. Who owns triage?",
+        },
+        {
+          type: "tool-input-available",
+          toolCallId: "tool-call-1",
+          toolName: "brunch_ask",
+          input: { question: "Who owns triage?" },
+        },
+      ),
+    );
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      fetch,
+    });
+
+    await expect(
+      collect(
+        bridge.respond({
+          conversationId: "conv_elevenlabs",
+          signal: new AbortController().signal,
+          transcript: "The support lead.",
+        }),
+      ),
+    ).resolves.toBe("Thanks. Who owns triage?");
+  });
+
+  test("forgets provider history and keeps sessions isolated", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(
+        sseResponse(
+          { type: "start", messageId: "assistant-1" },
+          { type: "text-delta", id: "text-1", delta: "Understood." },
+          { type: "finish", finishReason: "stop" },
+        ),
+      );
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      createId: () => "message-id",
+      fetch,
+    });
+
+    await collect(
+      bridge.respond({
+        conversationId: "conv_one",
+        signal: new AbortController().signal,
+        transcript: "Only this finalized turn.",
+      }),
+    );
+    await collect(
+      bridge.respond({
+        conversationId: "conv_two",
+        signal: new AbortController().signal,
+        transcript: "A different expert's turn.",
+      }),
+    );
+
+    const requestBodies = fetch.mock.calls.map(([, request]) =>
+      JSON.parse((request as RequestInit).body as string),
+    ) as { id: string; messages: unknown[] }[];
+    expect(requestBodies.map(({ id }) => id)).toEqual([
+      "voice:conv_one",
+      "voice:conv_two",
+    ]);
+    expect(JSON.stringify(requestBodies)).not.toContain("provider history");
+  });
+
+  test("surfaces a safe error without consuming an upstream body", async () => {
+    const text = vi.fn().mockResolvedValue("private upstream details");
+    const fetch = vi.fn().mockResolvedValue({
+      body: null,
+      ok: false,
+      status: 500,
+      text,
+    });
+    const bridge = new BrunchVoiceBridge({
+      chatEndpoint: "http://127.0.0.1:4321/api/chat",
+      fetch,
+    });
+
+    await expect(
+      collect(
+        bridge.respond({
+          conversationId: "conv_error",
+          signal: new AbortController().signal,
+          transcript: "A turn that fails.",
+        }),
+      ),
+    ).rejects.toThrow("Brunch could not answer the voice turn.");
+    expect(text).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/brunch-agent/test/elevenlabs-speech-engine.test.ts b/apps/brunch-agent/test/elevenlabs-speech-engine.test.ts
new file mode 100644
index 00000000000..a11acdb9f6b
--- /dev/null
+++ b/apps/brunch-agent/test/elevenlabs-speech-engine.test.ts
@@ -0,0 +1,223 @@
+import { describe, expect, test, vi } from "vitest";
+
+import {
+  applySpeechEngineInterviewConfig,
+  createElevenLabsSpeechEngineCallbacks,
+  speechEngineOverrides,
+  speechEngineTurnConfig,
+} from "../src/elevenlabs-speech-engine.ts";
+
+const collect = async (response: string | AsyncIterable<unknown>) => {
+  if (typeof response === "string") {
+    return response;
+  }
+  let text = "";
+  for await (const chunk of response) {
+    text += String(chunk);
+  }
+  return text;
+};
+
+const createSession = () => {
+  let responsePromise: Promise<string> | null = null;
+  const session = {
+    conversationId: "conv_speech_engine",
+    sendResponse: vi.fn(async (response: string | AsyncIterable<unknown>) => {
+      responsePromise = collect(response);
+      await responsePromise;
+    }),
+  };
+  return {
+    response: async () => {
+      await vi.waitFor(() => expect(responsePromise).not.toBeNull());
+      return responsePromise!;
+    },
+    session,
+  };
+};
+
+describe("ElevenLabs Speech Engine callbacks", () => {
+  test("forwards only the latest normalized user turn and the interruption signal", async () => {
+    const respond = vi.fn(async function* () {
+      yield "Brunch response";
+    });
+    const bridge = { release: vi.fn(), respond };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const { response, session } = createSession();
+    const signal = new AbortController().signal;
+
+    callbacks.onTranscript?.(
+      [
+        { role: "user", content: "Old provider history" },
+        { role: "agent", content: "Old provider response" },
+        {
+          role: "user",
+          content: "  The\u0000 support\n lead owns triage.  ",
+        },
+      ],
+      signal,
+      session as never,
+    );
+
+    expect(await response()).toBe("Brunch response");
+    expect(respond).toHaveBeenCalledWith({
+      conversationId: "conv_speech_engine",
+      signal,
+      transcript: "The support lead owns triage.",
+    });
+    expect(JSON.stringify(respond.mock.calls)).not.toContain(
+      "Old provider history",
+    );
+  });
+
+  test("does not invoke Brunch or speak for an empty transcript", async () => {
+    const bridge = { release: vi.fn(), respond: vi.fn() };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const { session } = createSession();
+
+    callbacks.onTranscript?.(
+      [{ role: "user", content: "\u0000   \n" }],
+      new AbortController().signal,
+      session as never,
+    );
+
+    expect(bridge.respond).not.toHaveBeenCalled();
+    expect(session.sendResponse).not.toHaveBeenCalled();
+  });
+
+  test("does not process the same completed provider turn twice", async () => {
+    const respond = vi.fn(async function* () {
+      yield "Brunch response";
+    });
+    const bridge = { release: vi.fn(), respond };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const { response, session } = createSession();
+    const transcript = [
+      { role: "user", content: "A finalized answer." },
+    ] as const;
+    const signal = new AbortController().signal;
+
+    callbacks.onTranscript?.([...transcript], signal, session as never);
+    await response();
+    callbacks.onTranscript?.([...transcript], signal, session as never);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(respond).toHaveBeenCalledTimes(1);
+    expect(session.sendResponse).toHaveBeenCalledTimes(1);
+  });
+
+  test("processes distinct provider turns with identical answers", async () => {
+    const respond = vi.fn(async function* () {
+      yield "Brunch response";
+    });
+    const bridge = { release: vi.fn(), respond };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const { session } = createSession();
+    const transcript = [{ role: "user", content: "Yes." }] as const;
+
+    callbacks.onTranscript?.(
+      [...transcript],
+      new AbortController().signal,
+      session as never,
+    );
+    await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(1));
+    callbacks.onTranscript?.(
+      [...transcript],
+      new AbortController().signal,
+      session as never,
+    );
+    await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(2));
+
+    expect(session.sendResponse).toHaveBeenCalledTimes(2);
+  });
+
+  test("queues the latest turn until the interrupted response settles", async () => {
+    let releaseFirst: () => void = () => undefined;
+    const firstTurnGate = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    let activeResponses = 0;
+    let maximumActiveResponses = 0;
+    const respond = vi.fn(async function* ({
+      signal,
+      transcript,
+    }: {
+      signal: AbortSignal;
+      transcript: string;
+    }) {
+      activeResponses += 1;
+      maximumActiveResponses = Math.max(
+        maximumActiveResponses,
+        activeResponses,
+      );
+      if (transcript === "First answer.") {
+        await firstTurnGate;
+      }
+      activeResponses -= 1;
+      if (signal.aborted) {
+        throw new DOMException("Interrupted", "AbortError");
+      }
+      yield `Reply to ${transcript}`;
+    });
+    const bridge = { release: vi.fn(), respond };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const { session } = createSession();
+    const firstController = new AbortController();
+
+    callbacks.onTranscript?.(
+      [{ role: "user", content: "First answer." }],
+      firstController.signal,
+      session as never,
+    );
+    firstController.abort();
+    callbacks.onTranscript?.(
+      [{ role: "user", content: "Corrected answer." }],
+      new AbortController().signal,
+      session as never,
+    );
+    expect(respond).toHaveBeenCalledTimes(1);
+
+    releaseFirst();
+    await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(2));
+    await vi.waitFor(() =>
+      expect(session.sendResponse).toHaveBeenCalledTimes(2),
+    );
+
+    expect(maximumActiveResponses).toBe(1);
+    expect(respond.mock.calls[1]?.[0]).toEqual(
+      expect.objectContaining({ transcript: "Corrected answer." }),
+    );
+  });
+
+  test("configures an opening question and patient turn-taking", async () => {
+    const update = vi.fn(async () => ({ engineId: "seng_test" }));
+
+    await applySpeechEngineInterviewConfig({
+      speechEngine: { update },
+      speechEngineId: "seng_test",
+    });
+
+    expect(update).toHaveBeenCalledWith("seng_test", {
+      overrides: speechEngineOverrides,
+      turn: speechEngineTurnConfig,
+    });
+    expect(speechEngineOverrides).toEqual({ firstMessage: true });
+    expect(speechEngineTurnConfig).toEqual({
+      turnEagerness: "patient",
+      turnModel: "turn_v3",
+      turnTimeout: 10,
+    });
+  });
+
+  test("releases bridge correlation on clean and unexpected disconnects", () => {
+    const bridge = { release: vi.fn(), respond: vi.fn() };
+    const callbacks = createElevenLabsSpeechEngineCallbacks({ bridge });
+    const session = { conversationId: "conv_speech_engine" };
+
+    callbacks.onClose?.(session as never);
+    callbacks.onDisconnect?.(session as never);
+
+    expect(bridge.release).toHaveBeenNthCalledWith(1, "conv_speech_engine");
+    expect(bridge.release).toHaveBeenNthCalledWith(2, "conv_speech_engine");
+  });
+});
diff --git a/apps/brunch-agent/test/local-dev-origins.test.ts b/apps/brunch-agent/test/local-dev-origins.test.ts
index 26eec099d35..307eed156fe 100644
--- a/apps/brunch-agent/test/local-dev-origins.test.ts
+++ b/apps/brunch-agent/test/local-dev-origins.test.ts
@@ -27,6 +27,8 @@ test("petrinaut:dev listens on the panel origin chat CORS already assumes", () =
   expect(defaultPanelOrigins).toEqual([
     "http://127.0.0.1:4915",
     "http://localhost:4915",
+    "http://127.0.0.1:5173",
+    "http://localhost:5173",
   ]);
   expect(localPanelListen).toEqual({
     host: "127.0.0.1",
diff --git a/apps/brunch-agent/test/voice-experiment-diagnostics.test.ts b/apps/brunch-agent/test/voice-experiment-diagnostics.test.ts
new file mode 100644
index 00000000000..f49c6837d80
--- /dev/null
+++ b/apps/brunch-agent/test/voice-experiment-diagnostics.test.ts
@@ -0,0 +1,352 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  createVoiceExperimentDiagnosticsHandler,
+  VoiceExperimentDiagnostics,
+} from "../src/voice-experiment-diagnostics.ts";
+
+const DIAGNOSTICS_URL =
+  "http://brunch.test/api/voice-experiment/elevenlabs-brunch-diagnostics";
+
+describe("voice experiment diagnostics", () => {
+  test("exposes only allowlisted, bounded tool metadata", async () => {
+    const diagnostics = new VoiceExperimentDiagnostics({
+      now: () => 1_234,
+    });
+    const turnId = diagnostics.beginTurn("voice:conv_safe");
+
+    diagnostics.recordToolCall("voice:conv_safe", turnId, {
+      input: {
+        question: `Who owns triage?\u0000${"x".repeat(400)}`,
+        secret: "must-not-leak",
+      },
+      toolCallId: "call_ask",
+      toolName: "brunch_ask",
+    });
+    diagnostics.recordToolCall("voice:conv_safe", turnId, {
+      input: { apiKey: "sk-private", transcript: "private interview" },
+      toolCallId: "call_unknown",
+      toolName: "unrecognized_tool",
+    });
+    diagnostics.recordToolCall("voice:conv_safe", turnId, {
+      input: {
+        description: "Assess severity",
+        name: "Triage",
+        owner: "Support lead",
+        secret: "must-not-leak",
+      },
+      toolCallId: "call_step",
+      toolName: "record_process_step",
+    });
+
+    const handler = createVoiceExperimentDiagnosticsHandler(diagnostics);
+    const response = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=conv_safe`, {
+        headers: { "x-voice-experiment": "elevenlabs-brunch" },
+      }),
+    );
+    const body = (await response.json()) as { events: unknown[] };
+    const serialized = JSON.stringify(body);
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("cache-control")).toBe("no-store");
+    expect(body.events).toEqual([
+      {
+        argumentSummary: expect.stringMatching(/^Question: Who owns triage\?/u),
+        callId: "call_ask",
+        sequence: 1,
+        timestampMs: 1_234,
+        toolName: "brunch_ask",
+        turnId: 1,
+      },
+      {
+        argumentSummary: "Arguments hidden",
+        callId: "call_unknown",
+        sequence: 2,
+        timestampMs: 1_234,
+        toolName: "unrecognized_tool",
+        turnId: 1,
+      },
+      {
+        argumentSummary: "Arguments hidden",
+        callId: "call_step",
+        capture: {
+          captureId: "capture-call_step",
+          input: {
+            description: "Assess severity",
+            name: "Triage",
+            owner: "Support lead",
+          },
+          toolName: "record_process_step",
+        },
+        sequence: 3,
+        timestampMs: 1_234,
+        toolName: "record_process_step",
+        turnId: 1,
+      },
+    ]);
+    expect(serialized).not.toContain("must-not-leak");
+    expect(serialized).not.toContain("sk-private");
+    expect(serialized).not.toContain("private interview");
+    expect(serialized).not.toContain("\\u0000");
+    expect(serialized.length).toBeLessThan(1_500);
+  });
+
+  test("exposes coalesced transcript events for the voice panel", async () => {
+    const diagnostics = new VoiceExperimentDiagnostics({ now: () => 3_000 });
+    const turnId = diagnostics.beginTurn("voice:conv_transcript");
+
+    diagnostics.recordTranscript("voice:conv_transcript", {
+      isPartial: false,
+      speaker: "expert",
+      transcript: "The support lead owns triage.",
+      turnId,
+    });
+    diagnostics.recordTranscript("voice:conv_transcript", {
+      isPartial: true,
+      speaker: "assistant",
+      transcript: "Who ",
+      turnId,
+    });
+    diagnostics.recordTranscript("voice:conv_transcript", {
+      isPartial: true,
+      speaker: "assistant",
+      transcript: "Who owns triage?",
+      turnId,
+    });
+
+    expect(diagnostics.read("conv_transcript", 2)).toEqual([
+      {
+        sequence: 3,
+        speaker: "assistant",
+        timestampMs: 3_000,
+        transcript: "Who owns triage?",
+        turnId: 1,
+        type: "partial-transcript",
+      },
+    ]);
+    expect(diagnostics.read("conv_transcript", 0)).toHaveLength(2);
+
+    diagnostics.recordTranscript("voice:conv_transcript", {
+      isPartial: false,
+      speaker: "assistant",
+      transcript: "Who owns triage?",
+      turnId,
+    });
+
+    const handler = createVoiceExperimentDiagnosticsHandler(diagnostics);
+    const response = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=conv_transcript`, {
+        headers: { "x-voice-experiment": "elevenlabs-brunch" },
+      }),
+    );
+    const body = (await response.json()) as { events: unknown[] };
+
+    expect(body.events).toEqual([
+      {
+        sequence: 1,
+        speaker: "expert",
+        timestampMs: 3_000,
+        transcript: "The support lead owns triage.",
+        turnId: 1,
+        type: "final-transcript",
+      },
+      {
+        sequence: 4,
+        speaker: "assistant",
+        timestampMs: 3_000,
+        transcript: "Who owns triage?",
+        turnId: 1,
+        type: "final-transcript",
+      },
+    ]);
+  });
+
+  test("emits projection readiness only after an applied sweep", () => {
+    const diagnostics = new VoiceExperimentDiagnostics({ now: () => 5_000 });
+    const turnId = diagnostics.beginTurn("voice:conv_projection");
+    diagnostics.recordToolCall("voice:conv_projection", turnId, {
+      input: {},
+      toolCallId: "sweep_applied",
+      toolName: "brunch_sweep",
+    });
+    diagnostics.recordToolOutput("voice:conv_projection", {
+      output: { status: "applied", appliedCaptureIds: ["capture-1"] },
+      toolCallId: "sweep_applied",
+    });
+    diagnostics.recordToolCall("voice:conv_projection", turnId, {
+      input: {},
+      toolCallId: "sweep_refused",
+      toolName: "brunch_sweep",
+    });
+    diagnostics.recordToolOutput("voice:conv_projection", {
+      output: { status: "refused" },
+      toolCallId: "sweep_refused",
+    });
+
+    expect(diagnostics.read("conv_projection", 0)).toEqual([
+      expect.objectContaining({
+        callId: "sweep_applied",
+        sequence: 1,
+        toolName: "brunch_sweep",
+      }),
+      {
+        callId: "sweep_applied",
+        sequence: 2,
+        timestampMs: 5_000,
+        type: "projection-ready",
+      },
+      expect.objectContaining({
+        callId: "sweep_refused",
+        sequence: 3,
+        toolName: "brunch_sweep",
+      }),
+    ]);
+  });
+
+  test("records the expert utterance and spoken brunch_ask question", async () => {
+    const diagnostics = new VoiceExperimentDiagnostics({ now: () => 4_000 });
+    const turnId = diagnostics.beginTurn("voice:conv_ask");
+    diagnostics.recordTranscript("voice:conv_ask", {
+      isPartial: false,
+      speaker: "expert",
+      transcript: "The support lead owns triage.",
+      turnId,
+    });
+    diagnostics.recordToolCall("voice:conv_ask", turnId, {
+      input: { question: "Who owns the next handoff?" },
+      toolCallId: "call_ask",
+      toolName: "brunch_ask",
+    });
+    diagnostics.recordTranscript("voice:conv_ask", {
+      isPartial: false,
+      speaker: "assistant",
+      transcript: "Who owns the next handoff?",
+      turnId,
+    });
+
+    expect(diagnostics.read("conv_ask", 0)).toEqual([
+      {
+        sequence: 1,
+        speaker: "expert",
+        timestampMs: 4_000,
+        transcript: "The support lead owns triage.",
+        turnId: 1,
+        type: "final-transcript",
+      },
+      {
+        argumentSummary: "Question: Who owns the next handoff?",
+        callId: "call_ask",
+        sequence: 2,
+        timestampMs: 4_000,
+        toolName: "brunch_ask",
+        turnId: 1,
+      },
+      {
+        sequence: 3,
+        speaker: "assistant",
+        timestampMs: 4_000,
+        transcript: "Who owns the next handoff?",
+        turnId: 1,
+        type: "final-transcript",
+      },
+    ]);
+  });
+
+  test("collapses aborted expert retries onto one transcript line", () => {
+    const diagnostics = new VoiceExperimentDiagnostics({ now: () => 5_000 });
+    diagnostics.recordTranscript("voice:conv_retry", {
+      isPartial: false,
+      speaker: "expert",
+      transcript: "Test elicitation.",
+      turnId: diagnostics.beginTurn("voice:conv_retry"),
+    });
+    diagnostics.recordTranscript("voice:conv_retry", {
+      isPartial: false,
+      speaker: "expert",
+      transcript: "Test, elicitation, one, two, three.",
+      turnId: diagnostics.beginTurn("voice:conv_retry"),
+    });
+    diagnostics.recordTranscript("voice:conv_retry", {
+      isPartial: false,
+      speaker: "expert",
+      transcript: "Test, elicitation, one, two, three.",
+      turnId: diagnostics.beginTurn("voice:conv_retry"),
+    });
+    diagnostics.recordTranscript("voice:conv_retry", {
+      isPartial: false,
+      speaker: "assistant",
+      transcript: "What process are we modelling?",
+      turnId: 3,
+    });
+
+    expect(diagnostics.read("conv_retry", 0)).toEqual([
+      {
+        sequence: 2,
+        speaker: "expert",
+        timestampMs: 5_000,
+        transcript: "Test, elicitation, one, two, three.",
+        turnId: 2,
+        type: "final-transcript",
+      },
+      {
+        sequence: 3,
+        speaker: "assistant",
+        timestampMs: 5_000,
+        transcript: "What process are we modelling?",
+        turnId: 3,
+        type: "final-transcript",
+      },
+    ]);
+  });
+
+  test("isolates sessions, supports cursors, and rejects untrusted queries", async () => {
+    const diagnostics = new VoiceExperimentDiagnostics({ now: () => 2_000 });
+    diagnostics.recordToolCall(
+      "voice:conv_one",
+      diagnostics.beginTurn("voice:conv_one"),
+      {
+        input: {},
+        toolCallId: "call_one",
+        toolName: "brunch_sweep",
+      },
+    );
+    diagnostics.recordToolCall(
+      "voice:conv_two",
+      diagnostics.beginTurn("voice:conv_two"),
+      {
+        input: {},
+        toolCallId: "call_two",
+        toolName: "brunch_sweep",
+      },
+    );
+
+    const handler = createVoiceExperimentDiagnosticsHandler(diagnostics);
+    const trusted = { "x-voice-experiment": "elevenlabs-brunch" };
+    const response = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=conv_one&after=0`, {
+        headers: trusted,
+      }),
+    );
+    const afterResponse = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=conv_one&after=1`, {
+        headers: trusted,
+      }),
+    );
+    const forbidden = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=conv_one`),
+    );
+    const invalid = await handler(
+      new Request(`${DIAGNOSTICS_URL}?conversationId=../conv_one`, {
+        headers: trusted,
+      }),
+    );
+
+    expect(await response.json()).toEqual({
+      events: [expect.objectContaining({ callId: "call_one", sequence: 1 })],
+    });
+    expect(await afterResponse.json()).toEqual({ events: [] });
+    expect(forbidden.status).toBe(403);
+    expect(invalid.status).toBe(400);
+  });
+});
diff --git a/apps/petrinaut-website/.env.example b/apps/petrinaut-website/.env.example
index dfb9d72a1b6..0496a6b5d63 100644
--- a/apps/petrinaut-website/.env.example
+++ b/apps/petrinaut-website/.env.example
@@ -1 +1,3 @@
 OPENAI_API_KEY=sk-xxxx
+ELEVENLABS_API_KEY=sk_xxxx
+ELEVENLABS_SPEECH_ENGINE_ID=seng_xxxx
diff --git a/apps/petrinaut-website/README.md b/apps/petrinaut-website/README.md
index d4fc4c4140f..da70d22792e 100644
--- a/apps/petrinaut-website/README.md
+++ b/apps/petrinaut-website/README.md
@@ -2,13 +2,14 @@
 
 A website for demoing Petrinaut (libs/@hashintel/petrinaut).
 
-A SPA plus a single API function that proxies AI requests to OpenAI.
+A SPA plus API functions for text chat and the OpenAI Realtime and ElevenLabs
+Speech Engine voice experiments.
 
 ## Quickstart
 
 ```sh
 cp .env.example .env.local
-# add your OPENAI_API_KEY to .env.local, if you want to use the chat feature
+# add the provider values needed by the experiment you are running
 
 turbo run dev
 ```
@@ -38,19 +39,28 @@ optimizer for isolated UI development.
 
 ## Environment variables
 
-| Name                          | Required         | Used by          | Notes                                                     |
-| ----------------------------- | ---------------- | ---------------- | --------------------------------------------------------- |
-| `OPENAI_API_KEY`              | for chat to work | `api/chat.ts`    | OpenAI key the function uses to call `streamText`.        |
-| `PETRINAUT_AI_MODEL`          | no               | `api/chat.ts`    | Overrides the default OpenAI model id.                    |
-| `PETRINAUT_OPT_ORIGIN`        | no               | `vite.config.ts` | Overrides the local optimizer proxy target.               |
-| `VITE_PETRINAUT_OPT_PROVIDER` | no               | website          | Set to `service` to enable the optimization route.        |
-| `SENTRY_DSN`                  | no               | `vite.config.ts` | Wired into the bundle via `__SENTRY_DSN__` at build time. |
+| Name                          | Required             | Used by                                                          | Notes                                                                               |
+| ----------------------------- | -------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| `OPENAI_API_KEY`              | for OpenAI features  | `api/chat.ts`, `api/voice-experiment/openai-realtime-session.ts` | Server-only OpenAI key used for chat and to mint ephemeral Realtime client secrets. |
+| `ELEVENLABS_API_KEY`          | for ElevenLabs voice | `api/voice-experiment/elevenlabs-conversation-token.ts`          | Server-only key used to mint short-lived WebRTC conversation tokens.                |
+| `ELEVENLABS_SPEECH_ENGINE_ID` | for ElevenLabs voice | `api/voice-experiment/elevenlabs-conversation-token.ts`          | Server-owned `seng_…` resource id; the browser cannot override it.                  |
+| `PETRINAUT_AI_MODEL`          | no                   | `api/chat.ts`                                                    | Overrides the default OpenAI model id.                                              |
+| `PETRINAUT_OPT_ORIGIN`        | no                   | `vite.config.ts`                                                 | Overrides the local optimizer proxy target.                                         |
+| `VITE_PETRINAUT_OPT_PROVIDER` | no                   | website                                                          | Set to `service` to enable the optimization route.                                  |
+| `SENTRY_DSN`                  | no                   | `vite.config.ts`                                                 | Wired into the bundle via `__SENTRY_DSN__` at build time.                           |
 
-Local values live in `.env.local`; Vite's `loadEnv` (see [`vite.config.ts`](vite.config.ts)) copies them into `process.env` for both the dev server and the chat function. In production, set these in the Vercel project settings.
+Local values live in `.env.local`; Vite's `loadEnv` (see [`vite.config.ts`](vite.config.ts)) copies them into `process.env` for both the dev server and the API functions. In production, set these in the Vercel project settings. Provider API keys must never be exposed through a `VITE_` variable or sent to the browser.
+
+## Voice interview experiments
+
+The local-storage demo can compare OpenAI Realtime and ElevenLabs while independently selecting the
+elicitor and mock projector. Detailed architecture, supported URL combinations, projection
+behavior, and local setup are documented in the
+[scoped voice experiment guide](src/main/app/local-storage-demo/voice-experiment/README.md).
 
 ## Testing the API against the built output
 
-A plain `yarn build && yarn vite preview` only serves the static `dist/` assets - `/api/chat` will 404 because the dev plugin is not loaded by `vite preview`. Use one of the options below to exercise the production code path locally.
+A plain `yarn build && yarn vite preview` only serves the static `dist/` assets - `/api/*` will 404 because the dev plugin is not loaded by `vite preview`. Use one of the options below to exercise the production code path locally.
 
 ### Option A: `vercel dev` (recommended)
 
@@ -107,4 +117,5 @@ Useful when you want to serve the literal `dist/` artifact you just built and av
 ## Known caveats
 
 - **In-memory rate limiting.** [`api/chat.ts`](api/chat.ts) keys rate-limit buckets by the client IP that Vercel's edge writes into `x-forwarded-for` (which Vercel actively prevents the caller from spoofing - see the [request headers docs](https://vercel.com/docs/edge-network/headers/request-headers)). The bucket map lives in module scope, so it resets on cold start and is not shared between concurrent function instances.
+- **The voice token endpoints use the same rate-limit shape.** Their tighter buckets protect ephemeral credential minting, but are still per warm function instance rather than a durable distributed limit.
 - **`vercel-build.sh` deletes the repo-root `.env`.** This is intentional (mise picks it up otherwise), but worth knowing if you run `vercel dev` locally and keep secrets there.
diff --git a/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.test.ts b/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.test.ts
new file mode 100644
index 00000000000..ce7fa06bd69
--- /dev/null
+++ b/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.test.ts
@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+import api from "./elevenlabs-conversation-token";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+const endpoint =
+  "https://petrinaut.local/api/voice-experiment/elevenlabs-conversation-token";
+
+const createRequest = (init: RequestInit = {}) =>
+  new Request(endpoint, {
+    method: "POST",
+    headers: {
+      origin: "https://petrinaut.local",
+      "x-voice-experiment": "elevenlabs-brunch",
+    },
+    ...init,
+  });
+
+describe("ElevenLabs conversation-token endpoint", () => {
+  const originalApiKey = process.env.ELEVENLABS_API_KEY;
+  const originalSpeechEngineId = process.env.ELEVENLABS_SPEECH_ENGINE_ID;
+  const originalVercelEnvironment = process.env.VERCEL_ENV;
+
+  beforeEach(() => {
+    process.env.ELEVENLABS_API_KEY =
+      "primary-elevenlabs-secret-that-must-stay-server-side"; // nosemgrep: hardcoded_secrets.node_api_key
+    process.env.ELEVENLABS_SPEECH_ENGINE_ID = "seng_server_owned";
+    delete process.env.VERCEL_ENV;
+  });
+
+  afterEach(() => {
+    process.env.ELEVENLABS_API_KEY = originalApiKey;
+    process.env.ELEVENLABS_SPEECH_ENGINE_ID = originalSpeechEngineId;
+    process.env.VERCEL_ENV = originalVercelEnvironment;
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  test("rejects unsupported methods without calling ElevenLabs", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(createRequest({ method: "GET" }));
+
+    expect(response.status).toBe(405);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("requires a same-origin ElevenLabs experiment request", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const crossOriginResponse = await api.fetch(
+      createRequest({
+        headers: {
+          origin: "https://attacker.example",
+          "x-voice-experiment": "elevenlabs-brunch",
+        },
+      }),
+    );
+    const unmarkedResponse = await api.fetch(
+      createRequest({
+        headers: { origin: "https://petrinaut.local" },
+      }),
+    );
+
+    expect(crossOriginResponse.status).toBe(403);
+    expect(unmarkedResponse.status).toBe(403);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("rejects browser-supplied speech-engine configuration", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(
+      createRequest({
+        body: JSON.stringify({ speechEngineId: "seng_browser_controlled" }),
+        headers: {
+          "content-type": "application/json",
+          origin: "https://petrinaut.local",
+          "x-voice-experiment": "elevenlabs-brunch",
+        },
+      }),
+    );
+
+    expect(response.status).toBe(400);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test.each(["ELEVENLABS_API_KEY", "ELEVENLABS_SPEECH_ENGINE_ID"])(
+    "fails safely when %s is missing",
+    async (variable) => {
+      delete process.env[variable];
+      const upstreamFetch = vi.fn();
+      vi.stubGlobal("fetch", upstreamFetch);
+
+      const response = await api.fetch(createRequest());
+
+      expect(response.status).toBe(500);
+      expect(await response.json()).toEqual({
+        error: "ElevenLabs voice is not configured",
+      });
+      expect(upstreamFetch).not.toHaveBeenCalled();
+    },
+  );
+
+  test("mints only a token for the server-configured speech engine", async () => {
+    const upstreamFetch = vi.fn().mockResolvedValue(
+      Response.json({
+        token: "short-lived-conversation-token",
+        conversation_id: "conv_123",
+        speech_engine: { id: "must-not-leak" },
+      }),
+    );
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(createRequest());
+
+    expect(response.status).toBe(200);
+    const responseBody: unknown = await response.json();
+    expect(responseBody).toEqual({
+      conversationId: "conv_123",
+      conversationToken: "short-lived-conversation-token",
+    });
+    expect(JSON.stringify(responseBody)).not.toContain(
+      process.env.ELEVENLABS_API_KEY as string,
+    );
+    expect(JSON.stringify(responseBody)).not.toContain("seng_server_owned");
+
+    expect(upstreamFetch).toHaveBeenCalledTimes(1);
+    const [url, request] = upstreamFetch.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe(
+      "https://api.elevenlabs.io/v1/convai/conversation/token?agent_id=seng_server_owned",
+    );
+    expect(request.method).toBe("GET");
+    expect(new Headers(request.headers).get("xi-api-key")).toBe(
+      process.env.ELEVENLABS_API_KEY,
+    );
+  });
+
+  test("does not expose upstream errors or the primary key", async () => {
+    const upstreamFetch = vi.fn().mockResolvedValue(
+      Response.json(
+        {
+          detail:
+            "Failure containing primary-elevenlabs-secret-that-must-stay-server-side",
+        },
+        { status: 401 },
+      ),
+    );
+    vi.stubGlobal("fetch", upstreamFetch);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    const response = await api.fetch(createRequest());
+    const body = await response.text();
+
+    expect(response.status).toBe(502);
+    expect(body).toBe(
+      JSON.stringify({ error: "Could not start ElevenLabs voice session" }),
+    );
+    expect(body).not.toContain("Failure containing");
+    expect(body).not.toContain(process.env.ELEVENLABS_API_KEY as string);
+  });
+});
diff --git a/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.ts b/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.ts
new file mode 100644
index 00000000000..bbd3dbd8f3f
--- /dev/null
+++ b/apps/petrinaut-website/api/voice-experiment/elevenlabs-conversation-token.ts
@@ -0,0 +1,185 @@
+import { z } from "zod";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+const ELEVENLABS_CONVERSATION_TOKEN_URL =
+  "https://api.elevenlabs.io/v1/convai/conversation/token";
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX_REQUESTS = 10;
+const RATE_LIMIT_MAX_TRACKED_CLIENTS = 10_000;
+const UPSTREAM_TIMEOUT_MS = 10_000;
+
+const upstreamResponseSchema = z.object({
+  conversation_id: z.string().min(1),
+  token: z.string().min(1),
+});
+
+const rateLimitBuckets = new Map<string, { count: number; resetAt: number }>();
+
+const jsonResponse = (body: unknown, init: ResponseInit = {}) => {
+  const headers = new Headers(init.headers);
+  headers.set("cache-control", "no-store");
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(body), { ...init, headers });
+};
+
+const logTokenFailure = (
+  reason: string,
+  context: Record<string, unknown> = {},
+) => {
+  // Never add request bodies, API keys, or upstream response bodies here.
+  // oxlint-disable-next-line no-console
+  console.error(`[ElevenLabs voice experiment] ${reason}`, context);
+};
+
+const resolveClientIp = (request: Request): string | null => {
+  const forwardedFor = request.headers.get("x-forwarded-for");
+  if (forwardedFor) {
+    const first = forwardedFor.split(",")[0]?.trim();
+    if (first) {
+      return first;
+    }
+  }
+  return request.headers.get("x-vercel-forwarded-for");
+};
+
+const checkRateLimit = (clientKey: string): boolean => {
+  const now = Date.now();
+  const current = rateLimitBuckets.get(clientKey);
+
+  if (!current || current.resetAt <= now) {
+    if (rateLimitBuckets.size >= RATE_LIMIT_MAX_TRACKED_CLIENTS) {
+      for (const [key, bucket] of rateLimitBuckets) {
+        if (bucket.resetAt <= now) {
+          rateLimitBuckets.delete(key);
+        }
+      }
+      if (rateLimitBuckets.size >= RATE_LIMIT_MAX_TRACKED_CLIENTS) {
+        return false;
+      }
+    }
+    rateLimitBuckets.set(clientKey, {
+      count: 1,
+      resetAt: now + RATE_LIMIT_WINDOW_MS,
+    });
+    return true;
+  }
+
+  if (current.count >= RATE_LIMIT_MAX_REQUESTS) {
+    return false;
+  }
+
+  current.count += 1;
+  return true;
+};
+
+const isTrustedBrowserRequest = (request: Request): boolean =>
+  request.headers.get("origin") === new URL(request.url).origin &&
+  request.headers.get("x-voice-experiment") === "elevenlabs-brunch";
+
+const fetch = async (request: Request): Promise<Response> => {
+  if (request.method === "OPTIONS") {
+    return new Response(null, { status: 204 });
+  }
+
+  if (request.method !== "POST") {
+    logTokenFailure("Rejected unsupported method", { method: request.method });
+    return jsonResponse({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  if (!isTrustedBrowserRequest(request)) {
+    logTokenFailure("Rejected untrusted browser request");
+    return jsonResponse({ error: "Forbidden" }, { status: 403 });
+  }
+
+  if ((await request.text()).trim() !== "") {
+    logTokenFailure("Rejected browser-supplied speech-engine configuration");
+    return jsonResponse(
+      { error: "Request body must be empty" },
+      { status: 400 },
+    );
+  }
+
+  const clientIp = resolveClientIp(request);
+  if (process.env.VERCEL_ENV === "production" && !clientIp) {
+    logTokenFailure("Rejected production request without a client IP");
+    return jsonResponse(
+      { error: "Could not determine client IP" },
+      { status: 400 },
+    );
+  }
+
+  if (!checkRateLimit(clientIp ?? "local-development")) {
+    logTokenFailure("Rejected rate-limited request");
+    return jsonResponse({ error: "Rate limit exceeded" }, { status: 429 });
+  }
+
+  const apiKey = process.env.ELEVENLABS_API_KEY;
+  const speechEngineId = process.env.ELEVENLABS_SPEECH_ENGINE_ID;
+  if (!apiKey || !speechEngineId) {
+    logTokenFailure("Missing ElevenLabs server configuration");
+    return jsonResponse(
+      { error: "ElevenLabs voice is not configured" },
+      { status: 500 },
+    );
+  }
+
+  const upstreamUrl = new URL(ELEVENLABS_CONVERSATION_TOKEN_URL);
+  upstreamUrl.searchParams.set("agent_id", speechEngineId);
+
+  let upstreamResponse: Response;
+  try {
+    upstreamResponse = await globalThis.fetch(upstreamUrl.toString(), {
+      method: "GET",
+      headers: { "xi-api-key": apiKey },
+      signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
+    });
+  } catch (error) {
+    logTokenFailure("Conversation-token request failed", {
+      errorName: error instanceof Error ? error.name : "unknown",
+    });
+    return jsonResponse(
+      { error: "Could not start ElevenLabs voice session" },
+      { status: 502 },
+    );
+  }
+
+  if (!upstreamResponse.ok) {
+    logTokenFailure("ElevenLabs rejected the conversation-token request", {
+      status: upstreamResponse.status,
+    });
+    return jsonResponse(
+      { error: "Could not start ElevenLabs voice session" },
+      { status: 502 },
+    );
+  }
+
+  let upstreamBody: unknown;
+  try {
+    upstreamBody = await upstreamResponse.json();
+  } catch {
+    logTokenFailure("ElevenLabs returned invalid JSON");
+    return jsonResponse(
+      { error: "Could not start ElevenLabs voice session" },
+      { status: 502 },
+    );
+  }
+
+  const parsed = upstreamResponseSchema.safeParse(upstreamBody);
+  if (!parsed.success) {
+    logTokenFailure("ElevenLabs returned an invalid conversation token");
+    return jsonResponse(
+      { error: "Could not start ElevenLabs voice session" },
+      { status: 502 },
+    );
+  }
+
+  return jsonResponse({
+    conversationId: parsed.data.conversation_id,
+    conversationToken: parsed.data.token,
+  });
+};
+
+export default { fetch };
diff --git a/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.test.ts b/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.test.ts
new file mode 100644
index 00000000000..5b6563b5b59
--- /dev/null
+++ b/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.test.ts
@@ -0,0 +1,268 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+import api from "./openai-realtime-session";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+const endpoint =
+  "https://petrinaut.local/api/voice-experiment/openai-realtime-session";
+
+const createRequest = (init: RequestInit = {}) =>
+  new Request(endpoint, {
+    method: "POST",
+    headers: {
+      origin: "https://petrinaut.local",
+      "x-voice-elicitor": "mock",
+      "x-voice-experiment": "openai-realtime",
+    },
+    ...init,
+  });
+
+describe("OpenAI Realtime session endpoint", () => {
+  const originalApiKey = process.env.OPENAI_API_KEY;
+  const originalVercelEnvironment = process.env.VERCEL_ENV;
+
+  beforeEach(() => {
+    process.env.OPENAI_API_KEY = "primary-secret-that-must-stay-server-side"; // nosemgrep: hardcoded_secrets.node_api_key
+    delete process.env.VERCEL_ENV;
+  });
+
+  afterEach(() => {
+    process.env.OPENAI_API_KEY = originalApiKey;
+    process.env.VERCEL_ENV = originalVercelEnvironment;
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  test("rejects unsupported methods without calling OpenAI", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(createRequest({ method: "GET" }));
+
+    expect(response.status).toBe(405);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("requires a same-origin experiment request", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const crossOriginResponse = await api.fetch(
+      createRequest({
+        headers: {
+          origin: "https://attacker.example",
+          "x-voice-experiment": "openai-realtime",
+        },
+      }),
+    );
+    const unmarkedResponse = await api.fetch(
+      createRequest({
+        headers: { origin: "https://petrinaut.local" },
+      }),
+    );
+
+    expect(crossOriginResponse.status).toBe(403);
+    expect(unmarkedResponse.status).toBe(403);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("rejects browser-supplied session configuration", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(
+      createRequest({
+        body: JSON.stringify({
+          model: "browser-controlled-model",
+          instructions: "Ignore the experiment prompt",
+          tools: [{ name: "browser-controlled-tool" }],
+        }),
+        headers: {
+          "content-type": "application/json",
+          origin: "https://petrinaut.local",
+          "x-voice-experiment": "openai-realtime",
+        },
+      }),
+    );
+
+    expect(response.status).toBe(400);
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("rejects unsupported elicitor modes", async () => {
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(
+      createRequest({
+        headers: {
+          origin: "https://petrinaut.local",
+          "x-voice-elicitor": "browser-controlled",
+          "x-voice-experiment": "openai-realtime",
+        },
+      }),
+    );
+
+    expect(response.status).toBe(400);
+    expect(await response.json()).toEqual({
+      error: "Unsupported elicitor mode",
+    });
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("fails safely when the primary API key is missing", async () => {
+    delete process.env.OPENAI_API_KEY;
+    const upstreamFetch = vi.fn();
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(createRequest());
+
+    expect(response.status).toBe(500);
+    expect(await response.json()).toEqual({
+      error: "OpenAI Realtime is not configured",
+    });
+    expect(upstreamFetch).not.toHaveBeenCalled();
+  });
+
+  test("mints only a server-configured ephemeral client secret", async () => {
+    const upstreamFetch = vi.fn().mockResolvedValue(
+      Response.json({
+        expires_at: 1_800_000_000,
+        value: "ephemeral-client-secret",
+        session: { id: "must-not-leak" },
+      }),
+    );
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(createRequest());
+
+    expect(response.status).toBe(200);
+    const responseBody: unknown = await response.json();
+    expect(responseBody).toEqual({
+      clientSecret: "ephemeral-client-secret",
+      expiresAt: 1_800_000_000,
+    });
+    expect(JSON.stringify(responseBody)).not.toContain(
+      process.env.OPENAI_API_KEY as string,
+    );
+
+    expect(upstreamFetch).toHaveBeenCalledTimes(1);
+    const [url, request] = upstreamFetch.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe("https://api.openai.com/v1/realtime/client_secrets");
+    expect(new Headers(request.headers).get("authorization")).toBe(
+      `Bearer ${process.env.OPENAI_API_KEY}`,
+    );
+    expect(
+      new Headers(request.headers).get("openai-safety-identifier"),
+    ).toMatch(/^[a-f0-9]{64}$/u);
+    const sessionRequest = JSON.parse(request.body as string) as {
+      session: {
+        instructions: string;
+        tools: { name: string }[];
+      };
+    };
+    expect(sessionRequest).toMatchObject({
+      session: {
+        audio: {
+          input: {
+            transcription: { model: "gpt-live-transcribe" },
+            turn_detection: {
+              create_response: false,
+              interrupt_response: true,
+              prefix_padding_ms: 300,
+              silence_duration_ms: 500,
+              threshold: 0.5,
+              type: "server_vad",
+            },
+          },
+          output: { voice: "marin" },
+        },
+        model: "gpt-realtime-2.1",
+        output_modalities: ["audio"],
+        tool_choice: "auto",
+        type: "realtime",
+      },
+    });
+    expect(sessionRequest.session.instructions).toContain(
+      "Stochastic Dynamic Coloured Petri Net",
+    );
+    expect(sessionRequest.session.instructions).toContain("wait_for_user");
+    expect(sessionRequest.session.instructions).toContain(
+      "before emitting spoken audio",
+    );
+    expect(sessionRequest.session.instructions).not.toContain(
+      "urgent customer support escalation",
+    );
+    expect(sessionRequest.session.tools.map(({ name }) => name)).toEqual([
+      "record_process_state",
+      "record_process_step",
+      "record_process_decision",
+      "record_process_flow",
+      "record_model_requirement",
+      "wait_for_user",
+    ]);
+  });
+
+  test("mints a fixed speech-renderer session for Brunch", async () => {
+    const upstreamFetch = vi.fn().mockResolvedValue(
+      Response.json({
+        expires_at: 1_800_000_000,
+        value: "ephemeral-client-secret",
+      }),
+    );
+    vi.stubGlobal("fetch", upstreamFetch);
+
+    const response = await api.fetch(
+      createRequest({
+        headers: {
+          origin: "https://petrinaut.local",
+          "x-voice-elicitor": "brunch",
+          "x-voice-experiment": "openai-realtime",
+        },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    const [, request] = upstreamFetch.mock.calls[0] as [string, RequestInit];
+    const sessionRequest = JSON.parse(request.body as string) as {
+      session: {
+        instructions: string;
+        tool_choice?: unknown;
+        tools?: unknown;
+      };
+    };
+    expect(sessionRequest.session.instructions).toContain("Brunch elicitor");
+    expect(sessionRequest.session.instructions).toContain("exactly as written");
+    expect(sessionRequest.session.tools).toBeUndefined();
+    expect(sessionRequest.session.tool_choice).toBeUndefined();
+  });
+
+  test("does not expose upstream errors or the primary key", async () => {
+    const upstreamFetch = vi.fn().mockResolvedValue(
+      Response.json(
+        {
+          error: {
+            message:
+              "Detailed upstream failure containing primary-secret-that-must-stay-server-side",
+          },
+        },
+        { status: 401 },
+      ),
+    );
+    vi.stubGlobal("fetch", upstreamFetch);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    const response = await api.fetch(createRequest());
+    const body = await response.text();
+
+    expect(response.status).toBe(502);
+    expect(body).toBe(
+      JSON.stringify({ error: "Could not start voice session" }),
+    );
+    expect(body).not.toContain("Detailed upstream failure");
+    expect(body).not.toContain(process.env.OPENAI_API_KEY as string);
+  });
+});
diff --git a/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.ts b/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.ts
new file mode 100644
index 00000000000..7ef8f40b5a3
--- /dev/null
+++ b/apps/petrinaut-website/api/voice-experiment/openai-realtime-session.ts
@@ -0,0 +1,445 @@
+import { z } from "zod";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+const OPENAI_CLIENT_SECRETS_URL =
+  "https://api.openai.com/v1/realtime/client_secrets"; // nosemgrep: hardcoded_secrets.node_secret
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX_REQUESTS = 10;
+const RATE_LIMIT_MAX_TRACKED_CLIENTS = 10_000;
+const UPSTREAM_TIMEOUT_MS = 10_000;
+
+const mockSessionConfig = {
+  session: {
+    type: "realtime",
+    model: "gpt-realtime-2.1",
+    output_modalities: ["audio"],
+    instructions: [
+      "# Role and Objective",
+      "You are a voice elicitation agent helping a domain expert describe a process well enough to draft a Stochastic Dynamic Coloured Petri Net in Petrinaut.",
+      "Do not assume a particular domain. Let the expert's first substantive statement establish the process being modeled.",
+      "# Conversation Flow",
+      "Work through these phases in order, while following the expert when they reveal important details early:",
+      "1. Scope: establish the process goal, the entity or token being modeled, and the start and end boundaries.",
+      "2. Structure: identify stable states, queues, and resources as candidate places; identify activities, events, and handoffs as candidate transitions; then establish their order.",
+      "3. Logic: identify branches and their conditions, loops and retries, concurrency, failure paths, and the flows that enable or consume each step.",
+      "4. Dynamics and evaluation: identify timing or rates, capacity constraints, useful metrics, and scenarios the model should support.",
+      "5. Confirmation: give a brief recap of the understood model and ask for one correction or missing detail at a time.",
+      "# Turn Discipline",
+      "Ask exactly one short, focused question in each spoken response.",
+      "Briefly acknowledge the answer, then ask only the highest-value missing fact.",
+      "Do not advance until the current question has been meaningfully answered.",
+      "If the expert gives a terse reply such as yes or no without the requested detail, clarify the same gap instead of repeating the question verbatim or moving on.",
+      "Do not speak again unless there is new, meaningful expert input or you are continuing immediately after recording an explicit fact with a tool.",
+      "Avoid compound questions and keep each spoken response to one or two concise sentences.",
+      "# Tools",
+      "All tools are dummy, experiment-only instrumentation. Never claim that their output was persisted to Brunch, Petrinaut, or any authoritative model.",
+      "Record only facts explicitly supplied or confirmed by the expert. Do not invent missing model elements.",
+      "Use record_process_state for a candidate place, record_process_step for a candidate transition, record_process_decision for branching logic, record_process_flow for a candidate arc, and record_model_requirement for timing, capacity, metrics, scenarios, or assumptions.",
+      "When facts need recording, call every required recording tool before emitting spoken audio for that turn.",
+      "Never begin an acknowledgment or question and then pause it to call a tool.",
+      "Do not narrate tool use. After the tool results return, speak exactly one short next question.",
+      "# Silence and Background Audio",
+      "If the input is silence, background noise, television or speaker audio, a side conversation, your own playback, or speech not addressed to you, call wait_for_user and do not respond conversationally afterward.",
+      "If speech addressed to you is unclear, ask one brief clarification question.",
+      "# Voice Style",
+      "Sound natural and attentive. Avoid filler preambles and keep questions ideally under twenty words.",
+    ].join("\n"),
+    max_output_tokens: 600,
+    audio: {
+      input: {
+        transcription: {
+          model: "gpt-live-transcribe",
+          delay: "low",
+          prompt:
+            "A domain-expert interview to elicit processes, states, transitions, flows, decisions, timing, constraints, metrics, and scenarios for Petri-net modeling.",
+        },
+        turn_detection: {
+          type: "server_vad",
+          create_response: false,
+          interrupt_response: true,
+          prefix_padding_ms: 300,
+          silence_duration_ms: 500,
+          threshold: 0.5,
+        },
+      },
+      output: {
+        voice: "marin",
+      },
+    },
+    tools: [
+      {
+        type: "function",
+        name: "record_process_state",
+        description:
+          "Record an explicitly stated stable state, queue, resource, source, or sink as a candidate Petri-net place. Experiment instrumentation only.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            name: {
+              type: "string",
+              description: "A short name for the candidate place.",
+            },
+            description: {
+              type: "string",
+              description: "What it represents in the expert's process.",
+            },
+            category: {
+              type: "string",
+              description: "The kind of process state being recorded.",
+              enum: ["state", "queue", "resource", "source", "sink"],
+            },
+            tokenDescription: {
+              type: "string",
+              description: "What a token at this place represents, if known.",
+            },
+          },
+          required: ["name", "description", "category"],
+        },
+      },
+      {
+        type: "function",
+        name: "record_process_step",
+        description:
+          "Record an explicitly stated activity, event, or handoff as a candidate Petri-net transition. Experiment instrumentation only.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            description: {
+              type: "string",
+              description: "What happens during the process step.",
+            },
+            name: {
+              type: "string",
+              description: "A short name for the process step.",
+            },
+            owner: {
+              type: "string",
+              description: "The role or team that owns the step, if known.",
+            },
+            trigger: {
+              type: "string",
+              description: "What enables or triggers the step, if known.",
+            },
+            timing: {
+              type: "string",
+              description: "The known timing behavior of the step.",
+              enum: ["immediate", "deterministic", "stochastic", "unknown"],
+            },
+          },
+          required: ["name", "description"],
+        },
+      },
+      {
+        type: "function",
+        name: "record_process_decision",
+        description:
+          "Record a branch or decision mentioned by the expert for experiment instrumentation only.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            condition: {
+              type: "string",
+              description: "The condition that determines the path taken.",
+            },
+            outcomes: {
+              type: "array",
+              description: "The possible paths after the decision.",
+              items: { type: "string" },
+            },
+          },
+          required: ["condition", "outcomes"],
+        },
+      },
+      {
+        type: "function",
+        name: "record_process_flow",
+        description:
+          "Record an explicitly stated flow between candidate places and transitions as a candidate Petri-net arc. Experiment instrumentation only.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            from: {
+              type: "string",
+              description: "The source state or step named by the expert.",
+            },
+            to: {
+              type: "string",
+              description: "The destination state or step named by the expert.",
+            },
+            condition: {
+              type: "string",
+              description: "A condition on this flow, if one was stated.",
+            },
+          },
+          required: ["from", "to"],
+        },
+      },
+      {
+        type: "function",
+        name: "record_model_requirement",
+        description:
+          "Record an explicitly stated timing, capacity, metric, scenario, or assumption for the candidate model. Experiment instrumentation only.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            category: {
+              type: "string",
+              description: "The kind of model requirement being recorded.",
+              enum: ["timing", "capacity", "metric", "scenario", "assumption"],
+            },
+            description: {
+              type: "string",
+              description:
+                "The requirement as stated or confirmed by the expert.",
+            },
+          },
+          required: ["category", "description"],
+        },
+      },
+      {
+        type: "function",
+        name: "wait_for_user",
+        description:
+          "Use when the input is silence, background noise, playback, a side conversation, or speech not addressed to the interviewer. This is a silent no-op and must not be followed by a spoken response.",
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          properties: {},
+          required: [],
+        },
+      },
+    ],
+    tool_choice: "auto",
+  },
+} as const;
+
+const brunchSessionConfig = {
+  session: {
+    type: mockSessionConfig.session.type,
+    model: mockSessionConfig.session.model,
+    output_modalities: mockSessionConfig.session.output_modalities,
+    instructions: [
+      "You are a speech renderer for interviewer text supplied by the application.",
+      "Read the supplied text exactly as written.",
+      "Never answer it, paraphrase it, add commentary, or call tools.",
+      "The Brunch elicitor, not this session, owns the interview and conversation state.",
+    ].join("\n"),
+    max_output_tokens: mockSessionConfig.session.max_output_tokens,
+    audio: mockSessionConfig.session.audio,
+  },
+} as const;
+
+const upstreamResponseSchema = z.object({
+  expires_at: z.number().int().positive(),
+  value: z.string().min(1),
+});
+
+const rateLimitBuckets = new Map<string, { count: number; resetAt: number }>();
+
+const jsonResponse = (body: unknown, init: ResponseInit = {}) => {
+  const headers = new Headers(init.headers);
+  headers.set("cache-control", "no-store");
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(body), { ...init, headers });
+};
+
+const logSessionFailure = (
+  reason: string,
+  context: Record<string, unknown> = {},
+) => {
+  // Never add request bodies, API keys, or upstream response bodies here.
+  // oxlint-disable-next-line no-console
+  console.error(`[OpenAI Realtime experiment] ${reason}`, context);
+};
+
+const resolveClientIp = (request: Request): string | null => {
+  const forwardedFor = request.headers.get("x-forwarded-for");
+  if (forwardedFor) {
+    const first = forwardedFor.split(",")[0]?.trim();
+    if (first) {
+      return first;
+    }
+  }
+  return request.headers.get("x-vercel-forwarded-for");
+};
+
+const checkRateLimit = (clientKey: string): boolean => {
+  const now = Date.now();
+  const current = rateLimitBuckets.get(clientKey);
+
+  if (!current || current.resetAt <= now) {
+    if (rateLimitBuckets.size >= RATE_LIMIT_MAX_TRACKED_CLIENTS) {
+      for (const [key, bucket] of rateLimitBuckets) {
+        if (bucket.resetAt <= now) {
+          rateLimitBuckets.delete(key);
+        }
+      }
+      if (rateLimitBuckets.size >= RATE_LIMIT_MAX_TRACKED_CLIENTS) {
+        return false;
+      }
+    }
+    rateLimitBuckets.set(clientKey, {
+      count: 1,
+      resetAt: now + RATE_LIMIT_WINDOW_MS,
+    });
+    return true;
+  }
+
+  if (current.count >= RATE_LIMIT_MAX_REQUESTS) {
+    return false;
+  }
+
+  current.count += 1;
+  return true;
+};
+
+const isTrustedBrowserRequest = (request: Request): boolean => {
+  const origin = request.headers.get("origin");
+  const experiment = request.headers.get("x-voice-experiment");
+
+  return (
+    origin === new URL(request.url).origin && experiment === "openai-realtime"
+  );
+};
+
+const createSafetyIdentifier = async (value: string): Promise<string> => {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(value),
+  );
+  return [...new Uint8Array(digest)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+};
+
+const fetch = async (request: Request): Promise<Response> => {
+  if (request.method === "OPTIONS") {
+    return new Response(null, { status: 204 });
+  }
+
+  if (request.method !== "POST") {
+    logSessionFailure("Rejected unsupported method", {
+      method: request.method,
+    });
+    return jsonResponse({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  if (!isTrustedBrowserRequest(request)) {
+    logSessionFailure("Rejected untrusted browser request");
+    return jsonResponse({ error: "Forbidden" }, { status: 403 });
+  }
+
+  if ((await request.text()).trim() !== "") {
+    logSessionFailure("Rejected browser-supplied session configuration");
+    return jsonResponse(
+      { error: "Request body must be empty" },
+      { status: 400 },
+    );
+  }
+
+  const elicitor = request.headers.get("x-voice-elicitor");
+  if (elicitor !== "mock" && elicitor !== "brunch") {
+    logSessionFailure("Rejected unsupported elicitor mode");
+    return jsonResponse(
+      { error: "Unsupported elicitor mode" },
+      { status: 400 },
+    );
+  }
+
+  const clientIp = resolveClientIp(request);
+  if (process.env.VERCEL_ENV === "production" && !clientIp) {
+    logSessionFailure("Rejected production request without a client IP");
+    return jsonResponse(
+      { error: "Could not determine client IP" },
+      { status: 400 },
+    );
+  }
+
+  const clientKey = clientIp ?? "local-development";
+  if (!checkRateLimit(clientKey)) {
+    logSessionFailure("Rejected rate-limited request");
+    return jsonResponse({ error: "Rate limit exceeded" }, { status: 429 });
+  }
+
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    logSessionFailure("Missing OpenAI API key");
+    return jsonResponse(
+      { error: "OpenAI Realtime is not configured" },
+      { status: 500 },
+    );
+  }
+
+  const safetyIdentifier = await createSafetyIdentifier(
+    `${apiKey}:${clientKey}`,
+  );
+
+  let upstreamResponse: Response;
+  try {
+    upstreamResponse = await globalThis.fetch(OPENAI_CLIENT_SECRETS_URL, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json",
+        "openai-safety-identifier": safetyIdentifier,
+      },
+      body: JSON.stringify(
+        elicitor === "brunch" ? brunchSessionConfig : mockSessionConfig,
+      ),
+      signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
+    });
+  } catch (error) {
+    logSessionFailure("Client-secret request failed", {
+      errorName: error instanceof Error ? error.name : "unknown",
+    });
+    return jsonResponse(
+      { error: "Could not start voice session" },
+      { status: 502 },
+    );
+  }
+
+  if (!upstreamResponse.ok) {
+    logSessionFailure("OpenAI rejected the client-secret request", {
+      status: upstreamResponse.status,
+    });
+    return jsonResponse(
+      { error: "Could not start voice session" },
+      { status: 502 },
+    );
+  }
+
+  let upstreamBody: unknown;
+  try {
+    upstreamBody = await upstreamResponse.json();
+  } catch {
+    logSessionFailure("OpenAI returned invalid JSON");
+    return jsonResponse(
+      { error: "Could not start voice session" },
+      { status: 502 },
+    );
+  }
+
+  const parsed = upstreamResponseSchema.safeParse(upstreamBody);
+  if (!parsed.success) {
+    logSessionFailure("OpenAI returned an invalid client secret");
+    return jsonResponse(
+      { error: "Could not start voice session" },
+      { status: 502 },
+    );
+  }
+
+  return jsonResponse({
+    clientSecret: parsed.data.value,
+    expiresAt: parsed.data.expires_at,
+  });
+};
+
+export default { fetch };
diff --git a/apps/petrinaut-website/package.json b/apps/petrinaut-website/package.json
index 46e48eeb96f..97c24f5a918 100644
--- a/apps/petrinaut-website/package.json
+++ b/apps/petrinaut-website/package.json
@@ -17,6 +17,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "3.0.63",
+    "@elevenlabs/client": "1.18.0",
     "@hashintel/brunch-agent-transport-aisdk": "workspace:*",
     "@hashintel/ds-components": "workspace:*",
     "@hashintel/ds-helpers": "workspace:*",
diff --git a/apps/petrinaut-website/src/app.css b/apps/petrinaut-website/src/app.css
index e27a23b7745..a7e956baff4 100644
--- a/apps/petrinaut-website/src/app.css
+++ b/apps/petrinaut-website/src/app.css
@@ -1 +1,66 @@
 @layer reset, base, tokens, recipes, utilities;
+
+@keyframes voice-recording-ring {
+  0% {
+    opacity: 0.5;
+    transform: scale(0.96);
+  }
+
+  75%,
+  100% {
+    opacity: 0;
+    transform: scale(1.42);
+  }
+}
+
+@keyframes voice-recording-glow {
+  0%,
+  100% {
+    box-shadow:
+      0 0 0 0 rgb(211 47 47 / 0.12),
+      0 10px 28px rgb(211 47 47 / 0.34),
+      inset 0 1px 0 rgb(255 255 255 / 0.2);
+  }
+
+  50% {
+    box-shadow:
+      0 0 0 12px rgb(211 47 47 / 0.1),
+      0 14px 32px rgb(211 47 47 / 0.4),
+      inset 0 1px 0 rgb(255 255 255 / 0.22);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  .voice-conversation-active {
+    animation: voice-recording-glow 1.35s ease-in-out infinite;
+  }
+
+  .voice-conversation-active::before,
+  .voice-conversation-active::after {
+    position: absolute;
+    inset: -2px;
+    z-index: 0;
+    border: 2px solid rgb(211 47 47 / 0.55);
+    border-radius: inherit;
+    content: "";
+    pointer-events: none;
+    animation: voice-recording-ring 1.8s ease-out infinite;
+    will-change: opacity, transform;
+  }
+
+  .voice-conversation-active::after {
+    animation-delay: 0.6s;
+  }
+
+  .voice-conversation-active > svg {
+    position: relative;
+    z-index: 1;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .voice-experiment-launcher,
+  .voice-experiment-panel {
+    transition: none !important;
+  }
+}
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.tsx
index 6f770fc9602..7305a86a373 100644
--- a/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.tsx
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.tsx
@@ -1,8 +1,9 @@
 import { produce } from "immer";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 
 import {
   createJsonDocHandle,
+  isSDCPNEqual,
   type MinimalNetMetadata,
   type PetrinautDocHandle,
   type PetrinautHandleCapabilities,
@@ -23,6 +24,16 @@ import {
   type SDCPNInLocalStorage,
   useLocalStorageSDCPNs,
 } from "./use-local-storage-sdcpns";
+import { VoiceExperiment } from "./voice-experiment";
+import { createElevenLabsAdapter } from "./voice-experiment/elevenlabs-adapter";
+import {
+  createMockInterviewDraft,
+  createMockInterviewProjection,
+  type FinalizeInterviewInput,
+  type InterviewDraftResult,
+} from "./voice-experiment/interview-draft";
+import { createOpenAIRealtimeAdapter } from "./voice-experiment/openai-realtime-adapter";
+import { getVoiceExperimentSelection } from "./voice-experiment/voice-experiment-selection";
 import { walkthroughSteps } from "./walkthrough/walkthrough-steps";
 
 const isEmptySDCPN = (sdcpn: SDCPN) =>
@@ -58,6 +69,7 @@ const createDefaultStoredSDCPN = (): SDCPNInLocalStorage => ({
 const createLocalStorageNetRecord = (params: {
   petriNetDefinition: SDCPN;
   title: string;
+  voiceInterview?: SDCPNInLocalStorage["voiceInterview"];
 }): SDCPNInLocalStorage => {
   const now = new Date();
 
@@ -66,6 +78,7 @@ const createLocalStorageNetRecord = (params: {
     title: params.title,
     sdcpn: params.petriNetDefinition,
     lastUpdated: now.toISOString(),
+    ...(params.voiceInterview ? { voiceInterview: params.voiceInterview } : {}),
   };
 };
 
@@ -118,6 +131,25 @@ const createActiveHandle = (net: SDCPNInLocalStorage): ActiveHandle => ({
  */
 export const LocalStorageDemoApp = () => {
   const sentryFeedbackAction = useSentryFeedbackAction();
+  const voiceExperiment = getVoiceExperimentSelection(window.location);
+  const [voiceConversationId] = useState(() => crypto.randomUUID());
+  const lastVoiceProjectionRevisionRef = useRef(0);
+  const voiceDraftEditedRef = useRef(false);
+  const voiceDraftNetIdRef = useRef<string | null>(null);
+  const voiceProvider = voiceExperiment?.provider;
+  const voiceElicitor = voiceExperiment?.elicitor;
+  const voiceExperimentAdapter = useMemo(() => {
+    if (voiceProvider === "openai" && voiceElicitor) {
+      return createOpenAIRealtimeAdapter({
+        conversationId: voiceConversationId,
+        elicitor: voiceElicitor,
+      });
+    }
+    if (voiceProvider === "elevenlabs" && voiceElicitor === "brunch") {
+      return createElevenLabsAdapter();
+    }
+    return undefined;
+  }, [voiceConversationId, voiceElicitor, voiceProvider]);
   const { aiMessagesByNetId, setAiMessagesByNetId } =
     useLocalStorageAiMessages();
   const { storedSDCPNs, setStoredSDCPNs } = useLocalStorageSDCPNs();
@@ -156,6 +188,12 @@ export const LocalStorageDemoApp = () => {
 
     return handle.subscribe((event) => {
       const lastUpdated = new Date().toISOString();
+      if (
+        netId === voiceDraftNetIdRef.current &&
+        !isSDCPNEqual(event.next, fallbackNet.sdcpn)
+      ) {
+        voiceDraftEditedRef.current = true;
+      }
 
       setStoredSDCPNs((prev) => {
         const stored = prev[netId] ?? fallbackNet;
@@ -185,6 +223,7 @@ export const LocalStorageDemoApp = () => {
   const createNewNet = (params: {
     petriNetDefinition: SDCPN;
     title: string;
+    voiceInterview?: SDCPNInLocalStorage["voiceInterview"];
   }) => {
     const newNet = createLocalStorageNetRecord(params);
     const previousNet =
@@ -207,8 +246,86 @@ export const LocalStorageDemoApp = () => {
     });
     setActiveHandle(createActiveHandle(newNet));
     setCurrentNetId(newNet.id);
+    return newNet.id;
+  };
+
+  const applyVoiceProjection = (result: InterviewDraftResult): boolean => {
+    if (result.revision <= lastVoiceProjectionRevisionRef.current) {
+      return false;
+    }
+    lastVoiceProjectionRevisionRef.current = result.revision;
+    const voiceInterview: NonNullable<SDCPNInLocalStorage["voiceInterview"]> = {
+      conversationId: result.conversationId,
+      revision: result.revision,
+      source: result.source,
+      transcript: result.transcript,
+      warnings: result.warnings,
+    };
+    const voiceDraftNetId = voiceDraftNetIdRef.current;
+    if (!voiceDraftNetId) {
+      voiceDraftNetIdRef.current = createNewNet({
+        petriNetDefinition: result.petriNetDefinition,
+        title: result.title,
+        voiceInterview,
+      });
+      return true;
+    }
+    if (voiceDraftEditedRef.current) {
+      setStoredSDCPNs((previous) => {
+        const existingDraft = previous[voiceDraftNetId];
+        return existingDraft
+          ? {
+              ...previous,
+              [voiceDraftNetId]: {
+                ...existingDraft,
+                lastUpdated: new Date().toISOString(),
+                voiceInterview: {
+                  ...voiceInterview,
+                  warnings: [
+                    ...voiceInterview.warnings,
+                    "A newer projection was not applied because the draft was manually edited.",
+                  ],
+                },
+              },
+            }
+          : previous;
+      });
+      return false;
+    }
+
+    const updatedNet: SDCPNInLocalStorage = {
+      id: voiceDraftNetId,
+      lastUpdated: new Date().toISOString(),
+      sdcpn: result.petriNetDefinition,
+      title: result.title,
+      voiceInterview,
+    };
+    setStoredSDCPNs((previous) => ({
+      ...previous,
+      [voiceDraftNetId]: updatedNet,
+    }));
+    if (currentNetId === voiceDraftNetId) {
+      setActiveHandle(createActiveHandle(updatedNet));
+    }
+    return true;
   };
 
+  const projectVoiceInterview =
+    voiceExperiment?.projector === "mock"
+      ? (input: FinalizeInterviewInput): boolean => {
+          const result = createMockInterviewProjection(input);
+          return result ? applyVoiceProjection(result) : false;
+        }
+      : undefined;
+
+  const finalizeVoiceInterview =
+    voiceExperiment?.projector === "mock"
+      ? (input: FinalizeInterviewInput) => {
+          const result = createMockInterviewDraft(input);
+          applyVoiceProjection(result);
+        }
+      : undefined;
+
   const loadPetriNet = (petriNetId: string) => {
     const netToLoad = storedSDCPNsForDisplay[petriNetId];
     if (!netToLoad) {
@@ -307,6 +424,15 @@ export const LocalStorageDemoApp = () => {
           title={currentNet.title}
           viewportActions={[sentryFeedbackAction]}
         />
+        {voiceExperiment ? (
+          <VoiceExperiment
+            adapter={voiceExperimentAdapter}
+            conversationId={voiceConversationId}
+            experiment={voiceExperiment}
+            onFinalize={finalizeVoiceInterview}
+            onProject={projectVoiceInterview}
+          />
+        ) : null}
       </WalkthroughProvider>
     </div>
   );
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/use-local-storage-sdcpns.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/use-local-storage-sdcpns.ts
index 796a72af1d6..c7b7ded095b 100644
--- a/apps/petrinaut-website/src/main/app/local-storage-demo/use-local-storage-sdcpns.ts
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/use-local-storage-sdcpns.ts
@@ -9,6 +9,17 @@ export type SDCPNInLocalStorage = {
   lastUpdated: string; // ISO timestamp
   sdcpn: SDCPN;
   title: string;
+  voiceInterview?: {
+    conversationId: string;
+    revision: number;
+    source: "brunch" | "mock";
+    transcript: {
+      speaker: "assistant" | "expert";
+      transcript: string;
+      turnId: number;
+    }[];
+    warnings: string[];
+  };
 };
 
 type LocalStorageSDCPNsStore = Record<string, SDCPNInLocalStorage>;
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment.tsx
new file mode 100644
index 00000000000..fc4080b7c98
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment.tsx
@@ -0,0 +1,1578 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  FiActivity,
+  FiCheck,
+  FiChevronDown,
+  FiCopy,
+  FiMaximize2,
+  FiMessageSquare,
+  FiMic,
+  FiMinimize2,
+  FiSquare,
+  FiTool,
+} from "react-icons/fi";
+
+import { css } from "@hashintel/ds-helpers/css";
+
+import {
+  getTranscriptEntries,
+  type TranscriptEntry,
+} from "./voice-experiment/transcript-entries";
+import {
+  getVoiceExperimentLabel,
+  type VoiceExperimentSelection,
+} from "./voice-experiment/voice-experiment-selection";
+
+import type { FinalizeInterviewInput } from "./voice-experiment/interview-draft";
+import type { VoiceExperimentAdapter } from "./voice-experiment/voice-experiment-adapter";
+import type { VoiceExperimentEvent } from "./voice-experiment/voice-experiment-events";
+
+const dockStyle = css({
+  position: "fixed",
+  zIndex: "popover",
+  bottom: "[76px]",
+  left: "0",
+  width: "full",
+  maxWidth: "[none]",
+  backgroundColor: "[transparent]",
+  pointerEvents: "none",
+});
+
+const fullscreenDockStyle = css({
+  zIndex: "[1600]",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: "4",
+  backgroundColor: "[rgb(15 23 42 / 0.62)]",
+  backdropFilter: "[blur(5px)]",
+  pointerEvents: "auto",
+});
+
+const panelStyle = css({
+  position: "relative",
+  display: "flex",
+  width: "full",
+  maxWidth: "[600px]",
+  maxHeight: "[calc(100vh - 108px)]",
+  marginX: "auto",
+  flexDirection: "column",
+  gap: "3.5",
+  padding: "[18px]",
+  overflow: "auto",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a30",
+  borderRadius: "2xl",
+  backgroundColor: "neutral.s05",
+  boxShadow:
+    "[0 24px 72px rgb(15 23 42 / 0.22), 0 2px 8px rgb(15 23 42 / 0.08)]",
+  pointerEvents: "auto",
+});
+
+const fullscreenPanelStyle = css({
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a35",
+  borderRadius: "2xl",
+  boxShadow: "[0 32px 96px rgb(15 23 42 / 0.42)]",
+});
+
+const launcherButtonStyle = css({
+  position: "absolute",
+  right: "[16px]",
+  bottom: "[-52px]",
+  display: "inline-flex",
+  width: "12",
+  height: "12",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: "0",
+  pointerEvents: "auto",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "blue.a100",
+  borderRadius: "full",
+  backgroundColor: "blue.s100",
+  color: "white",
+  cursor: "pointer",
+  isolation: "isolate",
+  boxShadow:
+    "[0 8px 22px rgb(42 128 200 / 0.28), inset 0 1px 0 rgb(255 255 255 / 0.25)]",
+  transition:
+    "[opacity 150ms ease, transform 200ms cubic-bezier(0.22, 1, 0.36, 1), background-color 150ms ease, box-shadow 150ms ease]",
+  _hover: {
+    transform: "translateY(-2px) scale(1.04)",
+    boxShadow:
+      "[0 11px 26px rgb(42 128 200 / 0.34), inset 0 1px 0 rgb(255 255 255 / 0.28)]",
+  },
+  _focusVisible: {
+    outline: "3px solid",
+    outlineColor: "blue.a40",
+    outlineOffset: "[3px]",
+  },
+});
+
+const hiddenLauncherButtonStyle = css({
+  visibility: "hidden",
+  opacity: "0",
+  pointerEvents: "none",
+  transform: "translateY(8px) scale(0.78)",
+  transition:
+    "[opacity 150ms ease, transform 200ms cubic-bezier(0.22, 1, 0.36, 1), background-color 150ms ease, box-shadow 150ms ease, visibility 0s linear 150ms]",
+});
+
+const activeLauncherButtonStyle = css({
+  borderColor: "red.s100",
+  backgroundColor: "red.s100",
+  boxShadow:
+    "[0 8px 24px rgb(211 47 47 / 0.34), inset 0 1px 0 rgb(255 255 255 / 0.22)]",
+  _hover: {
+    backgroundColor: "red.s110",
+    boxShadow:
+      "[0 11px 28px rgb(211 47 47 / 0.40), inset 0 1px 0 rgb(255 255 255 / 0.24)]",
+  },
+});
+
+const launcherStatusStyle = css({
+  position: "absolute",
+  top: "[-1px]",
+  right: "[-1px]",
+  width: "2.5",
+  height: "2.5",
+  borderWidth: "[2px]",
+  borderStyle: "solid",
+  borderColor: "neutral.s00",
+  borderRadius: "full",
+  backgroundColor: "neutral.s55",
+});
+
+const headerStyle = css({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  gap: "4",
+  paddingBottom: "3",
+  borderBottomWidth: "thin",
+  borderBottomStyle: "solid",
+  borderBottomColor: "neutral.a20",
+});
+
+const headerIdentityStyle = css({
+  display: "flex",
+  minWidth: "0",
+  alignItems: "center",
+});
+
+const headerActionsStyle = css({
+  display: "flex",
+  alignItems: "center",
+  gap: "3",
+});
+
+const minimizeButtonStyle = css({
+  display: "inline-flex",
+  width: "8",
+  height: "8",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: "0",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "lg",
+  backgroundColor: "white",
+  color: "neutral.s75",
+  cursor: "pointer",
+  transition:
+    "[background-color 140ms ease, color 140ms ease, transform 140ms ease]",
+  _hover: {
+    backgroundColor: "neutral.a10",
+    color: "neutral.s100",
+    transform: "translateY(1px)",
+  },
+  _focusVisible: {
+    outline: "2px solid",
+    outlineColor: "blue.a35",
+    outlineOffset: "[2px]",
+  },
+});
+
+const titleCopyStyle = css({
+  display: "flex",
+  minWidth: "0",
+  alignItems: "center",
+  gap: "2",
+  flexWrap: "wrap",
+});
+
+const headingStyle = css({
+  color: "neutral.s115",
+  fontSize: "lg",
+  fontWeight: "semibold",
+  lineHeight: "tight",
+});
+
+const experimentBadgeStyle = css({
+  paddingX: "2",
+  paddingY: "0.5",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a30",
+  borderRadius: "full",
+  backgroundColor: "white",
+  color: "neutral.s80",
+  fontSize: "xs",
+  fontWeight: "medium",
+});
+
+const sectionLabelStyle = css({
+  color: "neutral.s90",
+  fontSize: "xs",
+  fontWeight: "semibold",
+  letterSpacing: "wide",
+  textTransform: "uppercase",
+});
+
+const transcriptStyle = css({
+  display: "flex",
+  minHeight: "28",
+  maxHeight: "64",
+  flexDirection: "column",
+  gap: "2.5",
+  padding: "3",
+  overflowY: "auto",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a25",
+  borderRadius: "xl",
+  backgroundColor: "white",
+  color: "neutral.s80",
+  boxShadow: "[inset 0 1px 0 rgb(255 255 255 / 0.85)]",
+  fontSize: "sm",
+  lineHeight: "relaxed",
+  scrollBehavior: "smooth",
+  _focusVisible: {
+    outline: "2px solid",
+    outlineColor: "blue.a30",
+    outlineOffset: "[2px]",
+  },
+});
+
+const transcriptSectionStyle = css({
+  display: "flex",
+  minHeight: "0",
+  flexDirection: "column",
+  gap: "2",
+});
+
+const transcriptHeaderStyle = css({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  paddingX: "1",
+});
+
+const sectionHeaderMetaStyle = css({
+  display: "flex",
+  alignItems: "center",
+  gap: "1.5",
+});
+
+const sectionActionsStyle = css({
+  display: "inline-flex",
+  alignItems: "center",
+  gap: "1",
+});
+
+const sectionActionButtonStyle = css({
+  display: "inline-flex",
+  width: "7",
+  height: "7",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: "0",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "md",
+  backgroundColor: "white",
+  color: "neutral.s65",
+  cursor: "pointer",
+  transition:
+    "[background-color 120ms ease, border-color 120ms ease, color 120ms ease, transform 120ms ease]",
+  _hover: {
+    borderColor: "blue.a35",
+    backgroundColor: "blue.a10",
+    color: "blue.a95",
+    transform: "translateY(-1px)",
+  },
+  _focusVisible: {
+    outline: "2px solid",
+    outlineColor: "blue.a35",
+    outlineOffset: "[2px]",
+  },
+});
+
+const copiedSectionActionButtonStyle = css({
+  borderColor: "green.a35",
+  backgroundColor: "green.a10",
+  color: "green.a95",
+});
+
+const fullscreenSectionStyle = css({
+  flex: "1",
+  minHeight: "0",
+});
+
+const fullscreenContentStyle = css({
+  flex: "1",
+  maxHeight: "[none]",
+});
+
+const sectionHeadingStyle = css({
+  display: "inline-flex",
+  alignItems: "center",
+  gap: "1.5",
+  color: "neutral.s80",
+});
+
+const transcriptCountStyle = css({
+  paddingX: "2",
+  paddingY: "0.5",
+  borderRadius: "full",
+  backgroundColor: "neutral.a15",
+  color: "neutral.s70",
+  fontSize: "xs",
+});
+
+const transcriptEntryStyle = css({
+  display: "flex",
+  width: "[88%]",
+  flexDirection: "column",
+  gap: "0.5",
+});
+
+const expertTranscriptEntryStyle = css({
+  marginLeft: "auto",
+  alignItems: "flex-end",
+});
+
+const transcriptSpeakerStyle = css({
+  color: "neutral.s65",
+  fontSize: "xs",
+  fontWeight: "medium",
+});
+
+const transcriptBubbleStyle = css({
+  paddingX: "3",
+  paddingY: "2",
+  borderRadius: "xl",
+  backgroundColor: "neutral.a15",
+  color: "neutral.s95",
+});
+
+const expertTranscriptBubbleStyle = css({
+  backgroundColor: "blue.a20",
+});
+
+const partialTranscriptStyle = css({
+  opacity: "0.7",
+});
+
+const transcriptPlaceholderStyle = css({
+  margin: "auto",
+  display: "flex",
+  alignItems: "center",
+  gap: "2",
+  color: "neutral.s65",
+  textAlign: "center",
+});
+
+const statusIndicatorStyle = css({
+  width: "2.5",
+  height: "2.5",
+  flexShrink: "0",
+  borderRadius: "full",
+  backgroundColor: "neutral.a50",
+});
+
+const connectedStatusIndicatorStyle = css({
+  backgroundColor: "green.a85",
+  boxShadow: "[0 0 0 4px {colors.green.a10}]",
+});
+
+const pendingStatusIndicatorStyle = css({
+  backgroundColor: "yellow.a85",
+  boxShadow: "[0 0 0 4px {colors.yellow.a10}]",
+});
+
+const errorStatusIndicatorStyle = css({
+  backgroundColor: "red.a85",
+  boxShadow: "[0 0 0 4px {colors.red.a10}]",
+});
+
+const conversationControlStyle = css({
+  display: "flex",
+  width: "full",
+  minHeight: "24",
+  alignItems: "center",
+  flexDirection: "column",
+  gap: "2",
+  justifyContent: "center",
+  paddingY: "1",
+});
+
+const conversationControlLabelStyle = css({
+  color: "neutral.s80",
+  fontSize: "xs",
+  fontWeight: "semibold",
+});
+
+const microphoneButtonStyle = css({
+  position: "relative",
+  display: "inline-flex",
+  width: "[68px]",
+  height: "[68px]",
+  flexShrink: "0",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: "0",
+  borderWidth: "[2px]",
+  borderStyle: "solid",
+  borderColor: "blue.a100",
+  borderRadius: "full",
+  backgroundColor: "blue.a100",
+  color: "white",
+  cursor: "pointer",
+  isolation: "isolate",
+  boxShadow:
+    "[0 10px 26px rgb(42 128 200 / 0.30), inset 0 1px 0 rgb(255 255 255 / 0.22)]",
+  transition:
+    "[transform 160ms ease, background-color 160ms ease, border-color 160ms ease, box-shadow 160ms ease, opacity 160ms ease]",
+  _hover: {
+    backgroundColor: "blue.a110",
+    transform: "translateY(-2px) scale(1.03)",
+    boxShadow:
+      "[0 14px 30px rgb(42 128 200 / 0.34), inset 0 1px 0 rgb(255 255 255 / 0.24)]",
+  },
+  _focusVisible: {
+    outline: "3px solid",
+    outlineColor: "blue.a40",
+    outlineOffset: "[4px]",
+  },
+  _disabled: {
+    cursor: "not-allowed",
+    opacity: "0.52",
+    transform: "none",
+  },
+});
+
+const activeMicrophoneButtonStyle = css({
+  borderColor: "red.s100",
+  backgroundColor: "red.s100",
+  boxShadow:
+    "[0 10px 28px rgb(211 47 47 / 0.34), inset 0 1px 0 rgb(255 255 255 / 0.20)]",
+  _hover: {
+    backgroundColor: "red.s110",
+    boxShadow:
+      "[0 14px 32px rgb(211 47 47 / 0.38), inset 0 1px 0 rgb(255 255 255 / 0.22)]",
+  },
+});
+
+const eventLogStyle = css({
+  display: "flex",
+  minHeight: "20",
+  maxHeight: "36",
+  flexDirection: "column",
+  gap: "1.5",
+  padding: "2",
+  overflowY: "auto",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "xl",
+  backgroundColor: "neutral.a10",
+});
+
+const logsSectionStyle = css({
+  display: "flex",
+  minHeight: "0",
+  flexDirection: "column",
+  gap: "2",
+  borderTopWidth: "thin",
+  borderTopStyle: "solid",
+  borderTopColor: "neutral.a20",
+  paddingTop: "2",
+});
+
+const logsHeaderStyle = css({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  paddingX: "1",
+});
+
+const eventRowStyle = css({
+  display: "grid",
+  gridTemplateColumns: "[auto minmax(0, 1fr) auto]",
+  alignItems: "start",
+  gap: "2",
+  padding: "2",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a15",
+  borderRadius: "lg",
+  backgroundColor: "white",
+});
+
+const eventSequenceStyle = css({
+  display: "inline-flex",
+  minWidth: "7",
+  height: "6",
+  alignItems: "center",
+  justifyContent: "center",
+  borderRadius: "md",
+  backgroundColor: "neutral.a15",
+  color: "neutral.s60",
+  fontFamily: "mono",
+  fontSize: "[11px]",
+  fontWeight: "semibold",
+});
+
+const eventBodyStyle = css({
+  display: "flex",
+  minWidth: "0",
+  flexDirection: "column",
+  gap: "0.5",
+});
+
+const eventTypeStyle = css({
+  color: "blue.a85",
+  fontFamily: "mono",
+  fontSize: "xs",
+  fontWeight: "semibold",
+  overflowWrap: "anywhere",
+});
+
+const eventSummaryStyle = css({
+  color: "neutral.s75",
+  fontSize: "xs",
+  lineHeight: "relaxed",
+  overflowWrap: "anywhere",
+});
+
+const eventTimeStyle = css({
+  color: "neutral.s50",
+  fontFamily: "mono",
+  fontSize: "[11px]",
+  whiteSpace: "nowrap",
+});
+
+const emptyLogStyle = css({
+  padding: "3",
+  color: "neutral.s50",
+  fontSize: "sm",
+  textAlign: "center",
+});
+
+const toolDiagnosticsSectionStyle = css({
+  display: "flex",
+  minHeight: "0",
+  flexDirection: "column",
+  gap: "2",
+});
+
+const toolDiagnosticsHeaderStyle = css({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  paddingX: "1",
+});
+
+const toolDiagnosticsLogStyle = css({
+  display: "flex",
+  maxHeight: "36",
+  flexDirection: "column",
+  gap: "2",
+  padding: "2",
+  overflowY: "auto",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a15",
+  borderRadius: "xl",
+  backgroundColor: "neutral.a10",
+});
+
+const toolDiagnosticEmptyStyle = css({
+  display: "flex",
+  minHeight: "14",
+  alignItems: "center",
+  justifyContent: "center",
+  gap: "2",
+  color: "neutral.s65",
+  fontSize: "sm",
+});
+
+const toolDiagnosticCardStyle = css({
+  display: "grid",
+  gridTemplateColumns: "[minmax(0, 1fr) auto]",
+  gap: "1.5",
+  paddingX: "2.5",
+  paddingY: "2",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "lg",
+  backgroundColor: "white",
+});
+
+const toolDiagnosticNameStyle = css({
+  minWidth: "0",
+  overflow: "hidden",
+  color: "blue.a85",
+  fontFamily: "mono",
+  fontSize: "xs",
+  fontWeight: "semibold",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap",
+});
+
+const toolDiagnosticTurnStyle = css({
+  color: "neutral.s50",
+  fontFamily: "mono",
+  fontSize: "xs",
+  whiteSpace: "nowrap",
+});
+
+const toolDiagnosticSummaryStyle = css({
+  gridColumn: "[1 / -1]",
+  color: "neutral.s75",
+  fontSize: "sm",
+  lineHeight: "relaxed",
+  overflowWrap: "anywhere",
+});
+
+const toolDiagnosticCallStyle = css({
+  gridColumn: "[1 / -1]",
+  color: "neutral.s45",
+  fontFamily: "mono",
+  fontSize: "xs",
+  overflowWrap: "anywhere",
+});
+
+type SessionState =
+  | "ready"
+  | "connecting"
+  | "connected"
+  | "responding"
+  | "ending"
+  | "ended"
+  | "start-error"
+  | "error";
+
+type LoggedEvent = {
+  event: VoiceExperimentEvent;
+  sequence: number;
+};
+
+type DetailSection = "logs" | "tools" | "transcript";
+
+const PROJECTION_DEBOUNCE_MS = 300;
+
+const createInterviewInput = (
+  events: readonly LoggedEvent[],
+  conversationId: string,
+  readiness: FinalizeInterviewInput["readiness"],
+  revision: number,
+): FinalizeInterviewInput => ({
+  captures: events.flatMap(({ event }) =>
+    event.type === "tool-called" && event.capture ? [event.capture] : [],
+  ),
+  conversationId,
+  readiness,
+  revision,
+  transcript: getTranscriptEntries(events)
+    .filter((entry) => !entry.isPartial)
+    .map(({ speaker, transcript, turnId }) => ({
+      speaker,
+      transcript,
+      turnId,
+    })),
+});
+
+const getEventSummary = (event: VoiceExperimentEvent) => {
+  if (event.type === "partial-transcript") {
+    return `${event.speaker} · ${event.transcript}`;
+  }
+  if (event.type === "final-transcript") {
+    return `${event.speaker} · ${event.transcript}`;
+  }
+  if (event.type === "tool-called") {
+    return `${event.toolName} · turn ${event.turnId} · call ${event.callId}`;
+  }
+  if (event.type === "projection-updated") {
+    return `Draft updated to revision ${event.revision}`;
+  }
+  if (event.type === "projection-error") {
+    return `Revision ${event.revision} · ${event.message}`;
+  }
+  if (event.type === "projection-ready") {
+    return `Applied sweep ${event.callId}`;
+  }
+  if (event.type === "error") {
+    return event.message;
+  }
+  if (event.type === "recording-started") {
+    return `Expert microphone opened for turn ${event.turnId}`;
+  }
+  if (event.type === "response-started") {
+    return `Interviewer response started for turn ${event.turnId}`;
+  }
+  if (event.type === "response-completed") {
+    return event.responseText
+      ? `Interviewer response completed · ${event.responseText}`
+      : `Interviewer response completed for turn ${event.turnId}`;
+  }
+  return event.conversationId
+    ? `Provider connected · ${event.conversationId}`
+    : "Provider connected";
+};
+
+const formatTranscriptOutput = (
+  transcriptEntries: readonly TranscriptEntry[],
+): string =>
+  transcriptEntries
+    .map(
+      (entry) =>
+        `${entry.speaker === "expert" ? "Expert" : "Interviewer"}${
+          entry.isPartial ? " (partial)" : ""
+        }: ${entry.transcript}`,
+    )
+    .join("\n\n");
+
+const formatToolOutput = (events: readonly LoggedEvent[]): string =>
+  events
+    .flatMap(({ event }) =>
+      event.type === "tool-called"
+        ? [
+            [
+              `[Turn ${event.turnId}] ${event.toolName}`,
+              event.argumentSummary,
+              `Call ${event.callId}`,
+              ...(event.capture
+                ? [`Capture ${JSON.stringify(event.capture.input)}`]
+                : []),
+            ].join("\n"),
+          ]
+        : [],
+    )
+    .join("\n\n");
+
+const formatLogOutput = (events: readonly LoggedEvent[]): string =>
+  events
+    .map(
+      ({ event, sequence }) =>
+        `${new Date(event.timestampMs).toISOString()}  #${String(
+          sequence,
+        ).padStart(2, "0")}  ${event.type}  ${getEventSummary(event)}`,
+    )
+    .join("\n");
+
+const writeTextToClipboard = async (text: string): Promise<void> => {
+  await navigator.clipboard.writeText(text);
+};
+
+const createErrorEvent = (error: unknown): VoiceExperimentEvent => ({
+  message: error instanceof Error ? error.message : "Voice experiment failed.",
+  timestampMs: Date.now(),
+  type: "error",
+});
+
+const DetailSectionActions = ({
+  copied,
+  isFullscreen,
+  label,
+  onCopy,
+  onToggleFullscreen,
+}: {
+  copied: boolean;
+  isFullscreen: boolean;
+  label: string;
+  onCopy: () => void;
+  onToggleFullscreen: () => void;
+}) => (
+  <div className={sectionActionsStyle}>
+    <button
+      aria-label={copied ? `${label} copied` : `Copy ${label}`}
+      className={[
+        sectionActionButtonStyle,
+        copied ? copiedSectionActionButtonStyle : "",
+      ]
+        .filter(Boolean)
+        .join(" ")}
+      onClick={onCopy}
+      title={copied ? "Copied" : `Copy ${label}`}
+      type="button"
+    >
+      {copied ? (
+        <FiCheck aria-hidden="true" size={14} />
+      ) : (
+        <FiCopy aria-hidden="true" size={14} />
+      )}
+    </button>
+    <button
+      aria-label={`${isFullscreen ? "Exit fullscreen" : "Show fullscreen"} ${label}`}
+      aria-pressed={isFullscreen}
+      className={sectionActionButtonStyle}
+      onClick={onToggleFullscreen}
+      title={`${isFullscreen ? "Exit fullscreen" : "Show fullscreen"} ${label}`}
+      type="button"
+    >
+      {isFullscreen ? (
+        <FiMinimize2 aria-hidden="true" size={14} />
+      ) : (
+        <FiMaximize2 aria-hidden="true" size={14} />
+      )}
+    </button>
+  </div>
+);
+
+export const VoiceExperiment = ({
+  adapter,
+  conversationId,
+  experiment,
+  onFinalize,
+  onProject,
+}: {
+  adapter?: VoiceExperimentAdapter;
+  conversationId: string;
+  experiment: VoiceExperimentSelection;
+  onFinalize?: (input: FinalizeInterviewInput) => Promise<void> | void;
+  onProject?: (input: FinalizeInterviewInput) => boolean | Promise<boolean>;
+}) => {
+  const [copiedSection, setCopiedSection] = useState<DetailSection | null>(
+    null,
+  );
+  const [events, setEvents] = useState<LoggedEvent[]>([]);
+  const [fullscreenSection, setFullscreenSection] =
+    useState<DetailSection | null>(null);
+  const [isExpanded, setIsExpanded] = useState(false);
+  const [projectionRequestRevision, setProjectionRequestRevision] = useState(0);
+  const [sessionState, setSessionState] = useState<SessionState>("ready");
+  const [isConversationActive, setIsConversationActive] = useState(false);
+  const hasToggledPanelRef = useRef(false);
+  const copiedResetTimeoutRef = useRef<number | null>(null);
+  const launcherButtonRef = useRef<HTMLButtonElement>(null);
+  const minimizeButtonRef = useRef<HTMLButtonElement>(null);
+  const sequenceRef = useRef(0);
+  const finalizationConversationIdRef = useRef(conversationId);
+  const finalizationEventsRef = useRef<LoggedEvent[]>([]);
+  const onProjectRef = useRef(onProject);
+  const projectionReadinessRef =
+    useRef<FinalizeInterviewInput["readiness"]>("captures");
+  const projectionRevisionRef = useRef(0);
+  const transcriptRef = useRef<HTMLDivElement>(null);
+  const shouldAutoScrollTranscriptRef = useRef(true);
+
+  const appendEvent = useCallback(
+    (event: VoiceExperimentEvent) => {
+      const loggedEvent = { event, sequence: ++sequenceRef.current };
+      if (
+        event.type === "partial-transcript" ||
+        event.type === "final-transcript" ||
+        event.type === "tool-called"
+      ) {
+        finalizationEventsRef.current.push(loggedEvent);
+      }
+      if (
+        (event.type === "tool-called" && event.capture) ||
+        event.type === "projection-ready"
+      ) {
+        projectionReadinessRef.current =
+          event.type === "projection-ready" ? "elicitor" : "captures";
+        projectionRevisionRef.current += 1;
+        setProjectionRequestRevision(projectionRevisionRef.current);
+      }
+      setEvents((previous) => [...previous.slice(-49), loggedEvent]);
+
+      if (event.type === "connected") {
+        finalizationConversationIdRef.current =
+          event.conversationId ?? conversationId;
+        setSessionState("connected");
+      } else if (event.type === "recording-started") {
+        setIsConversationActive(true);
+      } else if (event.type === "response-started") {
+        setSessionState("responding");
+      } else if (event.type === "response-completed") {
+        setSessionState("connected");
+      } else if (event.type === "error") {
+        setSessionState("error");
+      }
+    },
+    [conversationId],
+  );
+
+  useEffect(() => adapter?.subscribe(appendEvent), [adapter, appendEvent]);
+
+  useEffect(() => {
+    onProjectRef.current = onProject;
+  }, [onProject]);
+
+  useEffect(
+    () => () => {
+      if (copiedResetTimeoutRef.current !== null) {
+        window.clearTimeout(copiedResetTimeoutRef.current);
+      }
+    },
+    [],
+  );
+
+  useEffect(() => {
+    if (!fullscreenSection) {
+      return;
+    }
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === "Escape") {
+        setFullscreenSection(null);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+
+    return () => {
+      document.body.style.overflow = previousOverflow;
+      window.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [fullscreenSection]);
+
+  useEffect(() => {
+    if (projectionRequestRevision < 1) {
+      return;
+    }
+    const timeout = window.setTimeout(() => {
+      const project = onProjectRef.current;
+      if (!project) {
+        return;
+      }
+      const input = createInterviewInput(
+        finalizationEventsRef.current,
+        finalizationConversationIdRef.current,
+        projectionReadinessRef.current,
+        projectionRequestRevision,
+      );
+      void Promise.resolve(project(input))
+        .then((updated) => {
+          if (updated) {
+            appendEvent({
+              revision: projectionRequestRevision,
+              timestampMs: Date.now(),
+              type: "projection-updated",
+            });
+          }
+        })
+        .catch((error: unknown) => {
+          appendEvent({
+            message:
+              error instanceof Error
+                ? error.message
+                : "Live projection failed.",
+            revision: projectionRequestRevision,
+            timestampMs: Date.now(),
+            type: "projection-error",
+          });
+        });
+    }, PROJECTION_DEBOUNCE_MS);
+
+    return () => window.clearTimeout(timeout);
+  }, [appendEvent, projectionRequestRevision]);
+
+  useEffect(() => {
+    if (!hasToggledPanelRef.current) {
+      return;
+    }
+
+    if (isExpanded) {
+      minimizeButtonRef.current?.focus();
+    } else {
+      launcherButtonRef.current?.focus();
+    }
+  }, [isExpanded]);
+
+  useEffect(() => {
+    const dispose = () => {
+      void adapter?.dispose();
+    };
+
+    window.addEventListener("pagehide", dispose);
+    return () => {
+      window.removeEventListener("pagehide", dispose);
+      dispose();
+    };
+  }, [adapter]);
+
+  const startConversation = async () => {
+    if (
+      !adapter ||
+      (sessionState !== "ready" && sessionState !== "start-error")
+    ) {
+      return;
+    }
+
+    setSessionState("connecting");
+    try {
+      await adapter.connect();
+      await adapter.startTurn();
+      setIsConversationActive(true);
+      setSessionState("connected");
+    } catch (error) {
+      setIsConversationActive(false);
+      await adapter.dispose().catch(() => undefined);
+      appendEvent(createErrorEvent(error));
+      setSessionState("start-error");
+    }
+  };
+
+  const stopConversation = async () => {
+    if (!adapter || sessionState === "ready" || sessionState === "ended") {
+      return;
+    }
+
+    setIsConversationActive(false);
+    setSessionState("ending");
+    try {
+      await adapter.dispose();
+      if (onFinalize) {
+        await onFinalize(
+          createInterviewInput(
+            finalizationEventsRef.current,
+            finalizationConversationIdRef.current,
+            "finalize",
+            projectionRevisionRef.current + 1,
+          ),
+        );
+      }
+      setSessionState("ended");
+    } catch (error) {
+      appendEvent(createErrorEvent(error));
+    }
+  };
+
+  const openVoiceInterview = () => {
+    hasToggledPanelRef.current = true;
+    setIsExpanded(true);
+
+    if (sessionState === "ready") {
+      void startConversation();
+    }
+  };
+
+  const minimizeVoiceInterview = () => {
+    hasToggledPanelRef.current = true;
+    setFullscreenSection(null);
+    setIsExpanded(false);
+  };
+
+  useEffect(() => {
+    const transcript = transcriptRef.current;
+    if (transcript && shouldAutoScrollTranscriptRef.current) {
+      transcript.scrollTo({ top: transcript.scrollHeight });
+    }
+  }, [events]);
+
+  const handleTranscriptScroll = () => {
+    const transcript = transcriptRef.current;
+    if (transcript) {
+      const distanceFromBottom =
+        transcript.scrollHeight -
+        transcript.scrollTop -
+        transcript.clientHeight;
+      shouldAutoScrollTranscriptRef.current = distanceFromBottom < 24;
+    }
+  };
+
+  const transcriptEntries = getTranscriptEntries(events);
+  const toolDiagnostics = events.filter(
+    (
+      entry,
+    ): entry is LoggedEvent & {
+      event: Extract<VoiceExperimentEvent, { type: "tool-called" }>;
+    } => entry.event.type === "tool-called",
+  );
+  const copySectionOutput = async (section: DetailSection) => {
+    const output =
+      section === "transcript"
+        ? formatTranscriptOutput(transcriptEntries)
+        : section === "tools"
+          ? formatToolOutput(events)
+          : formatLogOutput(events);
+    try {
+      await writeTextToClipboard(output || `No ${section} output.`);
+    } catch {
+      return;
+    }
+    setCopiedSection(section);
+    if (copiedResetTimeoutRef.current !== null) {
+      window.clearTimeout(copiedResetTimeoutRef.current);
+    }
+    copiedResetTimeoutRef.current = window.setTimeout(() => {
+      setCopiedSection(null);
+      copiedResetTimeoutRef.current = null;
+    }, 1_500);
+  };
+  const toggleFullscreenSection = (section: DetailSection) => {
+    setFullscreenSection((current) => (current === section ? null : section));
+  };
+  const showTranscript =
+    fullscreenSection === null || fullscreenSection === "transcript";
+  const showTools = fullscreenSection === null || fullscreenSection === "tools";
+  const showLogs = fullscreenSection === null || fullscreenSection === "logs";
+  const isConnected =
+    sessionState === "connected" || sessionState === "responding";
+  const isPending = sessionState === "connecting" || sessionState === "ending";
+  const canToggleConversation =
+    Boolean(adapter) &&
+    !isPending &&
+    (sessionState === "ready" ||
+      sessionState === "start-error" ||
+      isConversationActive);
+  const latestEvent = events.at(-1)?.event;
+  const statusLabel = !adapter
+    ? "Unavailable"
+    : sessionState === "ready"
+      ? "Ready"
+      : sessionState === "start-error"
+        ? "Ready to retry"
+        : sessionState === "connecting"
+          ? "Connecting"
+          : sessionState === "connected" || sessionState === "responding"
+            ? "Conversation active"
+            : sessionState === "ending"
+              ? "Stopping"
+              : sessionState === "ended"
+                ? "Conversation ended"
+                : latestEvent?.type === "error"
+                  ? latestEvent.message
+                  : "Connection error";
+  const controlLabel = isConversationActive
+    ? onFinalize
+      ? "Finish and create net"
+      : "Stop conversation"
+    : sessionState === "connecting"
+      ? "Starting…"
+      : sessionState === "ending"
+        ? onFinalize
+          ? "Creating draft…"
+          : "Stopping…"
+        : sessionState === "ended"
+          ? "Conversation ended"
+          : sessionState === "start-error"
+            ? "Retry conversation"
+            : sessionState === "error"
+              ? "Unavailable"
+              : "Start conversation";
+
+  return (
+    <div
+      className={[
+        dockStyle,
+        fullscreenSection ? fullscreenDockStyle : "",
+        "petrinaut-root",
+      ]
+        .filter(Boolean)
+        .join(" ")}
+      data-ai-cta-dismiss-exempt=""
+      style={
+        fullscreenSection
+          ? {
+              inset: 0,
+              height: "100dvh",
+              maxWidth: "none",
+              transform: "none",
+              width: "100vw",
+            }
+          : undefined
+      }
+    >
+      <button
+        ref={launcherButtonRef}
+        aria-controls="voice-experiment-panel"
+        aria-expanded={isExpanded}
+        aria-hidden={isExpanded}
+        aria-label={
+          isConversationActive
+            ? "Open active voice interview"
+            : "Open voice interview"
+        }
+        className={[
+          launcherButtonStyle,
+          "voice-experiment-launcher",
+          isExpanded ? hiddenLauncherButtonStyle : "",
+          isConversationActive ? activeLauncherButtonStyle : "",
+          isConversationActive ? "voice-conversation-active" : "",
+        ]
+          .filter(Boolean)
+          .join(" ")}
+        onClick={openVoiceInterview}
+        tabIndex={isExpanded ? -1 : 0}
+        title={
+          isConversationActive
+            ? "Open active voice interview"
+            : "Open voice interview"
+        }
+        type="button"
+      >
+        <FiMic aria-hidden="true" size={19} />
+        <span
+          aria-hidden="true"
+          className={[
+            launcherStatusStyle,
+            sessionState === "error"
+              ? errorStatusIndicatorStyle
+              : isPending
+                ? pendingStatusIndicatorStyle
+                : isConnected
+                  ? connectedStatusIndicatorStyle
+                  : "",
+          ]
+            .filter(Boolean)
+            .join(" ")}
+        />
+      </button>
+
+      {isExpanded && (
+        <aside
+          aria-label="Voice experiment"
+          className={[
+            panelStyle,
+            fullscreenSection ? fullscreenPanelStyle : "",
+            "voice-experiment-panel",
+          ]
+            .filter(Boolean)
+            .join(" ")}
+          id="voice-experiment-panel"
+          role={fullscreenSection ? "dialog" : undefined}
+          style={
+            fullscreenSection
+              ? {
+                  height: "min(56rem, calc(100dvh - 48px))",
+                  maxHeight: "none",
+                  maxWidth: "none",
+                  width: "min(72rem, 100%)",
+                }
+              : undefined
+          }
+        >
+          <header className={headerStyle}>
+            <div className={headerIdentityStyle}>
+              <div className={titleCopyStyle}>
+                <strong className={headingStyle}>Voice interview</strong>
+                <span className={experimentBadgeStyle}>
+                  {getVoiceExperimentLabel(experiment)}
+                </span>
+              </div>
+            </div>
+            <div className={headerActionsStyle}>
+              <span
+                aria-label={statusLabel}
+                className={[
+                  statusIndicatorStyle,
+                  sessionState === "error"
+                    ? errorStatusIndicatorStyle
+                    : isPending
+                      ? pendingStatusIndicatorStyle
+                      : isConnected
+                        ? connectedStatusIndicatorStyle
+                        : "",
+                ]
+                  .filter(Boolean)
+                  .join(" ")}
+                role="status"
+                title={statusLabel}
+              />
+              <button
+                ref={minimizeButtonRef}
+                aria-label="Minimize voice interview"
+                className={minimizeButtonStyle}
+                onClick={minimizeVoiceInterview}
+                title="Minimize voice interview"
+                type="button"
+              >
+                <FiChevronDown aria-hidden="true" size={17} />
+              </button>
+            </div>
+          </header>
+
+          {fullscreenSection === null && (
+            <div className={conversationControlStyle}>
+              <button
+                aria-label={controlLabel}
+                aria-pressed={isConversationActive}
+                className={[
+                  microphoneButtonStyle,
+                  isConversationActive ? activeMicrophoneButtonStyle : "",
+                  isConversationActive ? "voice-conversation-active" : "",
+                ]
+                  .filter(Boolean)
+                  .join(" ")}
+                disabled={!canToggleConversation}
+                onClick={() =>
+                  void (isConversationActive
+                    ? stopConversation()
+                    : startConversation())
+                }
+                title={controlLabel}
+                type="button"
+              >
+                {isConversationActive ? (
+                  <FiSquare aria-hidden="true" fill="currentColor" size={22} />
+                ) : (
+                  <FiMic aria-hidden="true" size={26} />
+                )}
+              </button>
+              <span className={conversationControlLabelStyle}>
+                {controlLabel}
+              </span>
+            </div>
+          )}
+
+          {showTranscript && (
+            <section
+              className={[
+                transcriptSectionStyle,
+                fullscreenSection === "transcript"
+                  ? fullscreenSectionStyle
+                  : "",
+              ]
+                .filter(Boolean)
+                .join(" ")}
+            >
+              <div className={transcriptHeaderStyle}>
+                <span className={sectionHeadingStyle}>
+                  <FiMessageSquare aria-hidden="true" size={14} />
+                  <span className={sectionLabelStyle}>Transcript</span>
+                </span>
+                <div className={sectionHeaderMetaStyle}>
+                  <span className={transcriptCountStyle}>
+                    {transcriptEntries.length}{" "}
+                    {transcriptEntries.length === 1 ? "message" : "messages"}
+                  </span>
+                  <DetailSectionActions
+                    copied={copiedSection === "transcript"}
+                    isFullscreen={fullscreenSection === "transcript"}
+                    label="transcript"
+                    onCopy={() => void copySectionOutput("transcript")}
+                    onToggleFullscreen={() =>
+                      toggleFullscreenSection("transcript")
+                    }
+                  />
+                </div>
+              </div>
+              <div
+                aria-label="Conversation transcript"
+                aria-live="polite"
+                className={[
+                  transcriptStyle,
+                  fullscreenSection === "transcript"
+                    ? fullscreenContentStyle
+                    : "",
+                ]
+                  .filter(Boolean)
+                  .join(" ")}
+                onScroll={handleTranscriptScroll}
+                ref={transcriptRef}
+                role="log"
+                // A bounded transcript must be keyboard-focusable to scroll.
+                // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+                tabIndex={0}
+              >
+                {transcriptEntries.length === 0 ? (
+                  <p className={transcriptPlaceholderStyle}>
+                    <FiMessageSquare aria-hidden="true" size={16} />
+                    Conversation appears here
+                  </p>
+                ) : (
+                  transcriptEntries.map((entry) => (
+                    <div
+                      className={[
+                        transcriptEntryStyle,
+                        entry.speaker === "expert"
+                          ? expertTranscriptEntryStyle
+                          : "",
+                      ]
+                        .filter(Boolean)
+                        .join(" ")}
+                      key={entry.id}
+                    >
+                      <span className={transcriptSpeakerStyle}>
+                        {entry.speaker === "expert" ? "Expert" : "Interviewer"}
+                      </span>
+                      <p
+                        className={[
+                          transcriptBubbleStyle,
+                          entry.speaker === "expert"
+                            ? expertTranscriptBubbleStyle
+                            : "",
+                          entry.isPartial ? partialTranscriptStyle : "",
+                        ]
+                          .filter(Boolean)
+                          .join(" ")}
+                      >
+                        {entry.transcript}
+                      </p>
+                    </div>
+                  ))
+                )}
+              </div>
+            </section>
+          )}
+
+          {showTools && (
+            <section
+              aria-labelledby="voice-tool-diagnostics-heading"
+              className={[
+                toolDiagnosticsSectionStyle,
+                fullscreenSection === "tools" ? fullscreenSectionStyle : "",
+              ]
+                .filter(Boolean)
+                .join(" ")}
+            >
+              <div className={toolDiagnosticsHeaderStyle}>
+                <span className={sectionHeadingStyle}>
+                  <FiTool aria-hidden="true" size={14} />
+                  <span
+                    className={sectionLabelStyle}
+                    id="voice-tool-diagnostics-heading"
+                  >
+                    Tool calls
+                  </span>
+                </span>
+                <div className={sectionHeaderMetaStyle}>
+                  <span className={transcriptCountStyle}>
+                    {toolDiagnostics.length}
+                  </span>
+                  <DetailSectionActions
+                    copied={copiedSection === "tools"}
+                    isFullscreen={fullscreenSection === "tools"}
+                    label="tool calls"
+                    onCopy={() => void copySectionOutput("tools")}
+                    onToggleFullscreen={() => toggleFullscreenSection("tools")}
+                  />
+                </div>
+              </div>
+              <div
+                aria-label="Tool call diagnostics"
+                aria-live="polite"
+                className={[
+                  toolDiagnosticsLogStyle,
+                  fullscreenSection === "tools" ? fullscreenContentStyle : "",
+                ]
+                  .filter(Boolean)
+                  .join(" ")}
+                role="log"
+              >
+                {toolDiagnostics.length === 0 ? (
+                  <p className={toolDiagnosticEmptyStyle}>
+                    <FiTool aria-hidden="true" size={14} />
+                    Tool calls appear here
+                  </p>
+                ) : (
+                  toolDiagnostics.map(({ event, sequence }) => (
+                    <article className={toolDiagnosticCardStyle} key={sequence}>
+                      <strong className={toolDiagnosticNameStyle}>
+                        {event.toolName}
+                      </strong>
+                      <span className={toolDiagnosticTurnStyle}>
+                        Turn {event.turnId}
+                      </span>
+                      <p className={toolDiagnosticSummaryStyle}>
+                        {event.argumentSummary}
+                      </p>
+                      <span className={toolDiagnosticCallStyle}>
+                        Call {event.callId}
+                      </span>
+                    </article>
+                  ))
+                )}
+              </div>
+            </section>
+          )}
+
+          {showLogs && (
+            <section
+              aria-labelledby="voice-event-log-heading"
+              className={[
+                logsSectionStyle,
+                fullscreenSection === "logs" ? fullscreenSectionStyle : "",
+              ]
+                .filter(Boolean)
+                .join(" ")}
+            >
+              <div className={logsHeaderStyle}>
+                <span className={sectionHeadingStyle}>
+                  <FiActivity aria-hidden="true" size={14} />
+                  <span
+                    className={sectionLabelStyle}
+                    id="voice-event-log-heading"
+                  >
+                    Logs
+                  </span>
+                </span>
+                <div className={sectionHeaderMetaStyle}>
+                  <span className={transcriptCountStyle}>
+                    {events.length} {events.length === 1 ? "event" : "events"}
+                  </span>
+                  <DetailSectionActions
+                    copied={copiedSection === "logs"}
+                    isFullscreen={fullscreenSection === "logs"}
+                    label="logs"
+                    onCopy={() => void copySectionOutput("logs")}
+                    onToggleFullscreen={() => toggleFullscreenSection("logs")}
+                  />
+                </div>
+              </div>
+              <div
+                aria-label="Voice event log"
+                aria-live="polite"
+                className={[
+                  eventLogStyle,
+                  fullscreenSection === "logs" ? fullscreenContentStyle : "",
+                ]
+                  .filter(Boolean)
+                  .join(" ")}
+                role="log"
+              >
+                {events.length === 0 ? (
+                  <span className={emptyLogStyle}>
+                    No events · conversation {conversationId.slice(0, 8)}
+                  </span>
+                ) : (
+                  events.map(({ event, sequence }) => (
+                    <article className={eventRowStyle} key={sequence}>
+                      <span className={eventSequenceStyle}>
+                        {String(sequence).padStart(2, "0")}
+                      </span>
+                      <div className={eventBodyStyle}>
+                        <strong className={eventTypeStyle}>{event.type}</strong>
+                        <span className={eventSummaryStyle}>
+                          {getEventSummary(event)}
+                        </span>
+                      </div>
+                      <time
+                        className={eventTimeStyle}
+                        dateTime={new Date(event.timestampMs).toISOString()}
+                      >
+                        {new Date(event.timestampMs).toLocaleTimeString()}
+                      </time>
+                    </article>
+                  ))
+                )}
+              </div>
+            </section>
+          )}
+        </aside>
+      )}
+    </div>
+  );
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/README.md b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/README.md
new file mode 100644
index 00000000000..85c5c060ba7
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/README.md
@@ -0,0 +1,82 @@
+# Voice interview experiment
+
+The local-storage demo can compare voice providers independently from the elicitor and projector:
+
+- **Provider** handles speech input, turn detection, and speech output.
+- **Elicitor** conducts the interview and records evidence.
+- **Projector** converts settled evidence into a Petrinaut net.
+
+## Experiment modes
+
+- `voiceProvider=openai&elicitor=mock` uses OpenAI Realtime with experiment-only capture tools.
+- `voiceProvider=openai&elicitor=brunch` uses OpenAI for speech with Brunch as the authoritative
+  elicitor.
+- `voiceProvider=elevenlabs&elicitor=brunch` uses ElevenLabs Speech Engine with Brunch callbacks.
+- Adding `projector=mock` enables incremental and final mock-net projection.
+
+ElevenLabs with the mock elicitor is unsupported because a Speech Engine conversation is bound to
+its server-side callback. The legacy `voiceExperiment=openai-realtime` and
+`voiceExperiment=elevenlabs-brunch` links remain available.
+
+## Conversation behavior
+
+Both providers use the same opening question and enforce alternating interview turns. The
+microphone closes after a finalized expert answer and reopens only after interviewer playback ends.
+
+### OpenAI Realtime
+
+The session endpoint returns a short-lived client secret and selects a fixed server-owned
+configuration. Server VAD detects the end of expert speech but does not create responses
+automatically. The browser admits the next response only after receiving a non-empty finalized
+transcript.
+
+With `elicitor=brunch`, finalized expert transcripts go through Brunch's `/api/chat` transport.
+Brunch owns interview state and `brunch_ask`; OpenAI only transcribes and renders Brunch text as
+speech. The Brunch source text remains the authoritative displayed transcript.
+
+### ElevenLabs Speech Engine
+
+ElevenLabs owns browser WebRTC, recognition, endpointing, synthesis, playback, and interruption
+detection. Its server callback forwards finalized expert speech to Brunch. The panel polls
+server-side diagnostics for Brunch-owned transcripts and tool events because Speech Engine does not
+push the equivalent stream directly to the browser.
+
+## Mock projection
+
+Add `projector=mock` to test the handoff from interview evidence to a visible net. Structured
+capture calls are accumulated through a provider-neutral contract and debounced for 300 ms. Once
+they form a coherent state-step-flow graph, the app creates one draft net and updates it by
+revision.
+
+An applied `brunch_sweep` emits the same readiness signal and projects the best available mock
+draft. Refused sweeps do not trigger projection. **Finish and create net** forces a final projection
+and uses a clearly labelled placeholder when structured evidence is unavailable.
+
+Stale responses are discarded. Manual edits freeze automatic net replacement, and navigating away
+from the draft prevents later projections from changing the active net. The saved local-storage
+record includes the transcript, conversation id, projection revision, source, and warnings.
+
+Examples:
+
+- `/?voiceProvider=openai&elicitor=mock&projector=mock`
+- `/?voiceProvider=openai&elicitor=brunch&projector=mock`
+- `/?voiceProvider=elevenlabs&elicitor=brunch&projector=mock`
+
+## Local development
+
+OpenAI modes require `OPENAI_API_KEY` in the website's `.env.local`. Brunch mode also requires the
+Brunch server on `127.0.0.1:4321`; the Vite proxy maps
+`/api/voice-experiment/brunch-chat` to its `/api/chat` endpoint.
+
+For ElevenLabs:
+
+1. Set the same `ELEVENLABS_API_KEY` and `ELEVENLABS_SPEECH_ENGINE_ID` in
+   `apps/petrinaut-website/.env.local` and `apps/brunch-agent/.env.local`.
+2. Start Brunch on `127.0.0.1:4321`.
+3. Run `yarn workspace @apps/brunch-agent voice:dev`.
+4. Expose port `3001` through a public HTTPS tunnel and configure the Speech Engine WebSocket as
+   `wss://<public-host>/ws`.
+5. Open the desired experiment URL through the real-panel launcher.
+
+Provider API keys remain server-side. The browser receives only short-lived OpenAI or ElevenLabs
+credentials.
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.test.ts
new file mode 100644
index 00000000000..c4099694131
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.test.ts
@@ -0,0 +1,501 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { createElevenLabsAdapter } from "./elevenlabs-adapter";
+
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+
+type SessionCallbacks = {
+  onConnect?: (event: { conversationId: string }) => void;
+  onDisconnect?: (details: { reason: string }) => void;
+  onError?: (message: string) => void;
+  onInterruption?: () => void;
+  onMessage?: (event: {
+    event_id?: number;
+    message: string;
+    role: "agent" | "user";
+  }) => void;
+  onModeChange?: (event: { mode: "listening" | "speaking" }) => void;
+  onConversationCreated?: (conversation: FakeConversation) => void;
+};
+
+class FakeConversation {
+  public endSession = vi.fn(async () => undefined);
+  public setMicMuted = vi.fn();
+}
+
+const createHarness = ({ autoConnect = true } = {}) => {
+  const conversation = new FakeConversation();
+  let callbacks: SessionCallbacks | null = null;
+  let diagnosticPoll: (() => void) | null = null;
+  let diagnosticResponse: unknown = { events: [] };
+  const startSession = vi.fn(async (options: SessionCallbacks) => {
+    callbacks = options;
+    options.onConversationCreated?.(conversation);
+    if (autoConnect) {
+      options.onConnect?.({ conversationId: "conv_123" });
+    }
+    return conversation;
+  });
+  const permissionTrack = { stop: vi.fn() };
+  const getUserMedia = vi.fn(async () => ({
+    getTracks: () => [permissionTrack],
+  }));
+  const fetch = vi.fn(async (input: RequestInfo | URL) =>
+    (input instanceof Request
+      ? input.url
+      : input instanceof URL
+        ? input.href
+        : input
+    ).includes("elevenlabs-brunch-diagnostics")
+      ? Response.json(diagnosticResponse)
+      : Response.json({
+          conversationId: "conv_123",
+          conversationToken: "short-lived-token",
+        }),
+  );
+  const clearInterval = vi.fn();
+  const setInterval = vi.fn((callback: () => void) => {
+    diagnosticPoll = callback;
+    return 17 as unknown as ReturnType<typeof globalThis.setInterval>;
+  });
+  let now = 1_000;
+  const adapter = createElevenLabsAdapter({
+    clearInterval,
+    fetch: fetch as typeof globalThis.fetch,
+    getUserMedia: getUserMedia as unknown as (
+      constraints: MediaStreamConstraints,
+    ) => Promise<MediaStream>,
+    now: () => ++now,
+    setInterval,
+    startSession,
+  });
+  const events: VoiceExperimentEvent[] = [];
+  adapter.subscribe((event) => events.push(event));
+
+  return {
+    adapter,
+    callbacks: () => callbacks,
+    clearInterval,
+    conversation,
+    events,
+    fetch,
+    getUserMedia,
+    permissionTrack,
+    pollDiagnostics: async (response: unknown) => {
+      diagnosticResponse = response;
+      diagnosticPoll?.();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    },
+    setInterval,
+    startSession,
+  };
+};
+
+describe("ElevenLabsAdapter", () => {
+  test("can connect after an unused adapter is disposed by a Strict Mode cleanup", async () => {
+    const harness = createHarness();
+
+    await harness.adapter.dispose();
+    await harness.adapter.connect();
+
+    await expect(harness.adapter.startTurn()).resolves.toBeUndefined();
+    expect(harness.conversation.endSession).not.toHaveBeenCalled();
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+    ]);
+  });
+
+  test("can reconnect after disposing a completed connection", async () => {
+    const harness = createHarness();
+
+    await harness.adapter.connect();
+    await harness.adapter.dispose();
+    await harness.adapter.connect();
+
+    await expect(harness.adapter.startTurn()).resolves.toBeUndefined();
+    expect(harness.startSession).toHaveBeenCalledTimes(2);
+    expect(harness.conversation.endSession).toHaveBeenCalledTimes(1);
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [true],
+      [false],
+    ]);
+  });
+
+  test("does not resolve connect until ElevenLabs reports the session connected", async () => {
+    const harness = createHarness({ autoConnect: false });
+    let connectionResolved = false;
+
+    const connection = harness.adapter.connect().then(() => {
+      connectionResolved = true;
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(harness.startSession).toHaveBeenCalledTimes(1);
+    expect(connectionResolved).toBe(false);
+
+    harness.callbacks()?.onConnect?.({ conversationId: "conv_123" });
+    await connection;
+
+    expect(connectionResolved).toBe(true);
+    await expect(harness.adapter.startTurn()).resolves.toBeUndefined();
+  });
+
+  test("starts an authenticated WebRTC session with the microphone gated", async () => {
+    const harness = createHarness();
+
+    await harness.adapter.connect();
+
+    expect(harness.fetch).toHaveBeenCalledWith(
+      "/api/voice-experiment/elevenlabs-conversation-token",
+      expect.objectContaining({
+        headers: { "x-voice-experiment": "elevenlabs-brunch" },
+        method: "POST",
+      }),
+    );
+    expect(harness.getUserMedia).toHaveBeenCalledWith({ audio: true });
+    expect(harness.permissionTrack.stop).toHaveBeenCalledTimes(1);
+    expect(harness.startSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        connectionType: "webrtc",
+        conversationToken: "short-lived-token",
+        overrides: {
+          agent: {
+            firstMessage: "Hi—what process would you like us to model today?",
+          },
+        },
+      }),
+    );
+    expect(harness.conversation.setMicMuted).toHaveBeenCalledWith(true);
+    expect(
+      harness.fetch.mock.calls
+        .map(([input]) =>
+          input instanceof Request
+            ? input.url
+            : input instanceof URL
+              ? input.href
+              : input,
+        )
+        .join(" "),
+    ).not.toContain("/api/chat");
+    expect(harness.events).toContainEqual({
+      conversationId: "conv_123",
+      timestampMs: 1_001,
+      type: "connected",
+    });
+  });
+
+  test("leaves the microphone open after the conversation starts", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.adapter.startTurn();
+    await harness.adapter.finishTurn();
+    await harness.adapter.startTurn();
+
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+    ]);
+    expect(harness.events.at(-1)).toEqual({
+      timestampMs: 1_002,
+      turnId: 1,
+      type: "recording-started",
+    });
+  });
+
+  test("does not open the mic over an opening question already playing", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    harness.callbacks()?.onModeChange?.({ mode: "speaking" });
+    await harness.adapter.startTurn();
+
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([[true]]);
+
+    harness.callbacks()?.onModeChange?.({ mode: "listening" });
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+    ]);
+  });
+
+  test("keeps the microphone muted while Brunch prepares a response", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.callbacks()?.onModeChange?.({ mode: "speaking" });
+    harness.callbacks()?.onInterruption?.();
+    harness.callbacks()?.onMessage?.({
+      event_id: 10,
+      message: "The support lead owns triage.",
+      role: "user",
+    });
+    harness.callbacks()?.onModeChange?.({ mode: "listening" });
+
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+      [true],
+    ]);
+
+    harness.callbacks()?.onModeChange?.({ mode: "speaking" });
+    harness.callbacks()?.onModeChange?.({ mode: "listening" });
+
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+      [true],
+      [false],
+    ]);
+  });
+
+  test("shows only the client opening question before Brunch diagnostics", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.callbacks()?.onModeChange?.({ mode: "speaking" });
+    harness.callbacks()?.onMessage?.({
+      event_id: 10,
+      message: "Hi—what process would you like us to model today?",
+      role: "agent",
+    });
+    harness.callbacks()?.onModeChange?.({ mode: "listening" });
+    harness.callbacks()?.onMessage?.({
+      event_id: 11,
+      message: "Test elicitation.",
+      role: "user",
+    });
+    harness.callbacks()?.onMessage?.({
+      event_id: 12,
+      message: "This Brunch response arrives through diagnostics.",
+      role: "agent",
+    });
+
+    expect(harness.events).toEqual([
+      {
+        conversationId: "conv_123",
+        timestampMs: 1_001,
+        type: "connected",
+      },
+      { timestampMs: 1_002, turnId: 1, type: "recording-started" },
+      { timestampMs: 1_003, turnId: 1, type: "response-started" },
+      {
+        speaker: "assistant",
+        timestampMs: 1_004,
+        transcript: "Hi—what process would you like us to model today?",
+        turnId: 1,
+        type: "final-transcript",
+      },
+      {
+        responseText: "Hi—what process would you like us to model today?",
+        timestampMs: 1_005,
+        turnId: 1,
+        type: "response-completed",
+      },
+    ]);
+    expect(harness.conversation.setMicMuted.mock.calls).toEqual([
+      [true],
+      [false],
+      [true],
+      [false],
+      [true],
+    ]);
+  });
+
+  test("polls normalized Brunch tool diagnostics for the provider conversation", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.pollDiagnostics({
+      events: [
+        {
+          argumentSummary: "Question: Who owns triage?",
+          callId: "call_ask",
+          privateInput: "must-not-appear",
+          sequence: 1,
+          timestampMs: 2_000,
+          toolName: "brunch_ask",
+          turnId: 1,
+        },
+        {
+          argumentSummary: "Arguments hidden",
+          callId: "call_step",
+          capture: {
+            captureId: "capture-call_step",
+            input: {
+              description: "Assess severity",
+              name: "Triage",
+              owner: "Support lead",
+              secret: "must-not-appear",
+            },
+            toolName: "record_process_step",
+          },
+          sequence: 2,
+          timestampMs: 2_001,
+          toolName: "record_process_step",
+          turnId: 1,
+        },
+        {
+          callId: "sweep-1",
+          sequence: 3,
+          timestampMs: 2_002,
+          type: "projection-ready",
+        },
+      ],
+    });
+
+    expect(harness.fetch).toHaveBeenCalledWith(
+      "/api/voice-experiment/elevenlabs-brunch-diagnostics?conversationId=conv_123&after=0",
+      { headers: { "x-voice-experiment": "elevenlabs-brunch" } },
+    );
+    expect(harness.events).toContainEqual({
+      argumentSummary: "Question: Who owns triage?",
+      callId: "call_ask",
+      timestampMs: 2_000,
+      toolName: "brunch_ask",
+      turnId: 1,
+      type: "tool-called",
+    });
+    expect(harness.events).toContainEqual({
+      callId: "sweep-1",
+      timestampMs: 2_002,
+      type: "projection-ready",
+    });
+    expect(harness.events).toContainEqual({
+      argumentSummary: "Arguments hidden",
+      callId: "call_step",
+      capture: {
+        captureId: "capture-call_step",
+        input: {
+          description: "Assess severity",
+          name: "Triage",
+          owner: "Support lead",
+        },
+        toolName: "record_process_step",
+      },
+      timestampMs: 2_001,
+      toolName: "record_process_step",
+      turnId: 1,
+      type: "tool-called",
+    });
+    expect(JSON.stringify(harness.events)).not.toContain("must-not-appear");
+
+    await harness.adapter.dispose();
+    expect(harness.clearInterval).toHaveBeenCalledWith(17);
+  });
+
+  test("surfaces Speech Engine transcripts from diagnostics", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.pollDiagnostics({
+      events: [
+        {
+          sequence: 1,
+          speaker: "expert",
+          timestampMs: 2_000,
+          transcript: "The support lead triages it.",
+          turnId: 1,
+          type: "final-transcript",
+        },
+        {
+          sequence: 2,
+          speaker: "assistant",
+          timestampMs: 2_100,
+          transcript: "Who owns the next handoff?",
+          turnId: 1,
+          type: "final-transcript",
+        },
+      ],
+    });
+
+    expect(harness.events).toContainEqual({
+      speaker: "expert",
+      timestampMs: 2_000,
+      transcript: "The support lead triages it.",
+      turnId: 1,
+      type: "final-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      speaker: "assistant",
+      timestampMs: 2_100,
+      transcript: "Who owns the next handoff?",
+      turnId: 1,
+      type: "final-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      responseText: "Who owns the next handoff?",
+      timestampMs: 2_100,
+      turnId: 1,
+      type: "response-completed",
+    });
+  });
+
+  test("polls growing partial transcripts after the latest cursor", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.pollDiagnostics({
+      events: [
+        {
+          sequence: 1,
+          speaker: "assistant",
+          timestampMs: 2_000,
+          transcript: "Who",
+          turnId: 1,
+          type: "partial-transcript",
+        },
+      ],
+    });
+    await harness.pollDiagnostics({
+      events: [
+        {
+          sequence: 2,
+          speaker: "assistant",
+          timestampMs: 2_100,
+          transcript: "Who owns triage?",
+          turnId: 1,
+          type: "partial-transcript",
+        },
+      ],
+    });
+
+    expect(harness.fetch).toHaveBeenLastCalledWith(
+      "/api/voice-experiment/elevenlabs-brunch-diagnostics?conversationId=conv_123&after=1",
+      { headers: { "x-voice-experiment": "elevenlabs-brunch" } },
+    );
+    expect(
+      harness.events.filter((event) => event.type === "partial-transcript"),
+    ).toEqual([
+      {
+        speaker: "assistant",
+        timestampMs: 2_000,
+        transcript: "Who",
+        turnId: 1,
+        type: "partial-transcript",
+      },
+      {
+        speaker: "assistant",
+        timestampMs: 2_100,
+        transcript: "Who owns triage?",
+        turnId: 1,
+        type: "partial-transcript",
+      },
+    ]);
+  });
+
+  test("releases ElevenLabs microphone, playback, and connection once", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.adapter.dispose();
+    await harness.adapter.dispose();
+
+    expect(harness.conversation.endSession).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.ts
new file mode 100644
index 00000000000..2250c457ab7
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/elevenlabs-adapter.ts
@@ -0,0 +1,612 @@
+import { createInterviewCapture } from "./interview-draft";
+import { interviewOpeningQuestion } from "./interview-opening";
+
+import type { VoiceExperimentAdapter } from "./voice-experiment-adapter";
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+
+const TOKEN_ENDPOINT = "/api/voice-experiment/elevenlabs-conversation-token";
+const DIAGNOSTICS_ENDPOINT =
+  "/api/voice-experiment/elevenlabs-brunch-diagnostics";
+const DIAGNOSTICS_POLL_INTERVAL_MS = 500;
+
+type ConversationControl = {
+  endSession(): Promise<void>;
+  setMicMuted(isMuted: boolean): void;
+};
+
+type SessionOptions = {
+  connectionType: "webrtc";
+  conversationToken: string;
+  overrides: {
+    agent: {
+      firstMessage: string;
+    };
+  };
+  onConnect(event: { conversationId: string }): void;
+  onConversationCreated(conversation: ConversationControl): void;
+  onDisconnect(details: { reason: string }): void;
+  onError(message: string): void;
+  onInterruption(): void;
+  onMessage(event: {
+    event_id?: number;
+    message: string;
+    role: "agent" | "user";
+  }): void;
+  onModeChange(event: { mode: "listening" | "speaking" }): void;
+};
+
+type ElevenLabsAdapterDependencies = {
+  clearInterval: (handle: ReturnType<typeof globalThis.setInterval>) => void;
+  fetch: typeof globalThis.fetch;
+  getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+  now: () => number;
+  setInterval: (
+    callback: () => void,
+    intervalMs: number,
+  ) => ReturnType<typeof globalThis.setInterval>;
+  startSession: (options: SessionOptions) => Promise<ConversationControl>;
+};
+
+const defaultDependencies: ElevenLabsAdapterDependencies = {
+  clearInterval: (handle) => globalThis.clearInterval(handle),
+  fetch: (...args) => globalThis.fetch(...args),
+  getUserMedia: (constraints) =>
+    navigator.mediaDevices.getUserMedia(constraints),
+  now: () => Date.now(),
+  setInterval: (callback, intervalMs) =>
+    globalThis.setInterval(callback, intervalMs),
+  startSession: async (options) => {
+    const { Conversation } = await import("@elevenlabs/client");
+    return Conversation.startSession(options);
+  },
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
+const getString = (
+  value: Record<string, unknown> | null,
+  key: string,
+): string | null => {
+  const candidate = value?.[key];
+  return typeof candidate === "string" ? candidate : null;
+};
+
+const boundedDiagnosticText = (value: unknown, limit: number): string => {
+  if (typeof value !== "string") {
+    return "";
+  }
+  let sanitized = "";
+  for (const character of value.normalize("NFKC")) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint >= 32 && codePoint !== 127) {
+      sanitized += character;
+    }
+  }
+  return sanitized.replace(/\s+/gu, " ").trim().slice(0, limit);
+};
+
+const parseTranscriptDiagnostic = (
+  value: unknown,
+):
+  | ({ sequence: number } & Extract<
+      VoiceExperimentEvent,
+      { type: "final-transcript" | "partial-transcript" }
+    >)
+  | null => {
+  const record = asRecord(value);
+  const sequence = record?.sequence;
+  const timestampMs = record?.timestampMs;
+  const turnId = record?.turnId;
+  const type = getString(record, "type");
+  const speaker = getString(record, "speaker");
+  const transcript = boundedDiagnosticText(record?.transcript, 4_000);
+  if (
+    !Number.isSafeInteger(sequence) ||
+    Number(sequence) < 1 ||
+    typeof timestampMs !== "number" ||
+    !Number.isFinite(timestampMs) ||
+    !Number.isSafeInteger(turnId) ||
+    Number(turnId) < 1 ||
+    (type !== "final-transcript" && type !== "partial-transcript") ||
+    (speaker !== "assistant" && speaker !== "expert") ||
+    !transcript
+  ) {
+    return null;
+  }
+
+  return {
+    sequence: Number(sequence),
+    speaker,
+    timestampMs,
+    transcript,
+    turnId: Number(turnId),
+    type,
+  };
+};
+
+const parseToolDiagnostic = (
+  value: unknown,
+):
+  | ({ sequence: number } & Extract<
+      VoiceExperimentEvent,
+      { type: "tool-called" }
+    >)
+  | null => {
+  const record = asRecord(value);
+  const sequence = record?.sequence;
+  const timestampMs = record?.timestampMs;
+  const turnId = record?.turnId;
+  const toolName = boundedDiagnosticText(record?.toolName, 96);
+  const callId = boundedDiagnosticText(record?.callId, 96);
+  const argumentSummary = boundedDiagnosticText(record?.argumentSummary, 240);
+  if (
+    !Number.isSafeInteger(sequence) ||
+    Number(sequence) < 1 ||
+    typeof timestampMs !== "number" ||
+    !Number.isFinite(timestampMs) ||
+    !Number.isSafeInteger(turnId) ||
+    Number(turnId) < 1 ||
+    !toolName ||
+    !callId ||
+    !argumentSummary
+  ) {
+    return null;
+  }
+  const captureRecord = asRecord(record?.capture);
+  const capture =
+    getString(captureRecord, "toolName") === toolName
+      ? createInterviewCapture({
+          captureId:
+            getString(captureRecord, "captureId") ?? `capture-${callId}`,
+          input: captureRecord?.input,
+          toolName,
+        })
+      : null;
+
+  return {
+    argumentSummary,
+    callId,
+    ...(capture ? { capture } : {}),
+    sequence: Number(sequence),
+    timestampMs,
+    toolName,
+    turnId: Number(turnId),
+    type: "tool-called",
+  };
+};
+
+const parseProjectionReadyDiagnostic = (
+  value: unknown,
+):
+  | ({ sequence: number } & Extract<
+      VoiceExperimentEvent,
+      { type: "projection-ready" }
+    >)
+  | null => {
+  const record = asRecord(value);
+  const sequence = record?.sequence;
+  const timestampMs = record?.timestampMs;
+  const callId = boundedDiagnosticText(record?.callId, 96);
+  if (
+    getString(record, "type") !== "projection-ready" ||
+    !Number.isSafeInteger(sequence) ||
+    Number(sequence) < 1 ||
+    typeof timestampMs !== "number" ||
+    !Number.isFinite(timestampMs) ||
+    !callId
+  ) {
+    return null;
+  }
+
+  return {
+    callId,
+    sequence: Number(sequence),
+    timestampMs,
+    type: "projection-ready",
+  };
+};
+
+const parseDiagnosticEvent = (
+  value: unknown,
+):
+  | ({ sequence: number } & Extract<
+      VoiceExperimentEvent,
+      | { type: "final-transcript" | "partial-transcript" }
+      | { type: "projection-ready" }
+      | { type: "tool-called" }
+    >)
+  | null =>
+  parseTranscriptDiagnostic(value) ??
+  parseToolDiagnostic(value) ??
+  parseProjectionReadyDiagnostic(value);
+
+class ElevenLabsAdapter implements VoiceExperimentAdapter {
+  readonly #dependencies: ElevenLabsAdapterDependencies;
+  readonly #listeners = new Set<(event: VoiceExperimentEvent) => void>();
+
+  #awaitingBrunchResponse = false;
+  #connectPromise: Promise<void> | null = null;
+  #connected = false;
+  #conversation: ConversationControl | null = null;
+  #diagnosticConversationId: string | null = null;
+  #diagnosticCursor = 0;
+  #diagnosticPollHandle: ReturnType<typeof globalThis.setInterval> | null =
+    null;
+  #diagnosticPollInFlight = false;
+  #disposed = false;
+  #hasEmittedOpeningQuestion = false;
+  #isListening = false;
+  #isMicrophoneMuted = true;
+  #providerMode: "listening" | "speaking" = "listening";
+  #responseInProgress = false;
+  #turnId = 0;
+
+  public constructor(dependencies: ElevenLabsAdapterDependencies) {
+    this.#dependencies = dependencies;
+  }
+
+  public subscribe(listener: (event: VoiceExperimentEvent) => void) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+
+  public async connect(): Promise<void> {
+    if (this.#disposed) {
+      this.#awaitingBrunchResponse = false;
+      this.#disposed = false;
+      this.#hasEmittedOpeningQuestion = false;
+      this.#isListening = false;
+      this.#isMicrophoneMuted = true;
+      this.#providerMode = "listening";
+      this.#responseInProgress = false;
+      this.#turnId = 0;
+    }
+    if (this.#connected) {
+      return;
+    }
+    if (this.#connectPromise) {
+      return this.#connectPromise;
+    }
+
+    this.#connectPromise = this.#establishConnection().finally(() => {
+      this.#connectPromise = null;
+    });
+    return this.#connectPromise;
+  }
+
+  public async startTurn(): Promise<void> {
+    this.#requireConversation();
+    if (this.#isListening) {
+      return;
+    }
+
+    this.#isListening = true;
+    this.#turnId += 1;
+    this.#responseInProgress = this.#providerMode === "speaking";
+    this.#setMicrophoneMuted(this.#providerMode === "speaking");
+    this.#emit({
+      timestampMs: this.#dependencies.now(),
+      turnId: this.#turnId,
+      type: "recording-started",
+    });
+  }
+
+  public async finishTurn(): Promise<void> {
+    // Start/stop owns the session; Speech Engine owns each spoken turn.
+    this.#requireConversation();
+  }
+
+  public async dispose(): Promise<void> {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
+    this.#awaitingBrunchResponse = false;
+    this.#connected = false;
+    this.#isListening = false;
+    this.#stopDiagnosticsPolling();
+    const conversation = this.#conversation;
+    this.#conversation = null;
+    if (conversation) {
+      await conversation.endSession();
+    }
+  }
+
+  async #establishConnection(): Promise<void> {
+    const tokenResponse = await this.#dependencies.fetch(TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: { "x-voice-experiment": "elevenlabs-brunch" },
+    });
+    if (!tokenResponse.ok) {
+      throw new Error("The ElevenLabs voice session could not be started.");
+    }
+
+    const tokenBody = asRecord(await tokenResponse.json());
+    const conversationToken = getString(tokenBody, "conversationToken");
+    if (!conversationToken) {
+      throw new Error(
+        "The ElevenLabs voice session returned an invalid token.",
+      );
+    }
+
+    const permissionStream = await this.#dependencies.getUserMedia({
+      audio: true,
+    });
+    for (const track of permissionStream.getTracks()) {
+      track.stop();
+    }
+
+    let providerConnected = false;
+    let readinessSettled = false;
+    let resolveReady: () => void = () => undefined;
+    let rejectReady: (error: Error) => void = () => undefined;
+    const ready = new Promise<void>((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    const markReadyIfConnected = () => {
+      if (
+        readinessSettled ||
+        !providerConnected ||
+        !this.#conversation ||
+        this.#disposed
+      ) {
+        return;
+      }
+      readinessSettled = true;
+      this.#connected = true;
+      this.#emit({
+        ...(this.#diagnosticConversationId
+          ? { conversationId: this.#diagnosticConversationId }
+          : {}),
+        timestampMs: this.#dependencies.now(),
+        type: "connected",
+      });
+      resolveReady();
+    };
+    const failBeforeConnected = (message: string) => {
+      if (!readinessSettled) {
+        readinessSettled = true;
+        rejectReady(new Error(message));
+      }
+    };
+    const setConversation = (createdConversation: ConversationControl) => {
+      if (this.#conversation !== createdConversation) {
+        this.#conversation = createdConversation;
+        createdConversation.setMicMuted(true);
+        this.#isMicrophoneMuted = true;
+      }
+      markReadyIfConnected();
+    };
+
+    const conversation = await this.#dependencies.startSession({
+      connectionType: "webrtc",
+      conversationToken,
+      overrides: {
+        agent: {
+          firstMessage: interviewOpeningQuestion,
+        },
+      },
+      onConnect: ({ conversationId }) => {
+        if (this.#disposed) {
+          return;
+        }
+        providerConnected = true;
+        this.#startDiagnosticsPolling(conversationId);
+        markReadyIfConnected();
+      },
+      onConversationCreated: (createdConversation) => {
+        setConversation(createdConversation);
+      },
+      onDisconnect: ({ reason }) => {
+        this.#connected = false;
+        this.#stopDiagnosticsPolling();
+        failBeforeConnected(
+          "The ElevenLabs voice connection closed before it was ready.",
+        );
+        if (!this.#disposed && reason === "error") {
+          this.#emitError("The ElevenLabs voice connection was lost.");
+        }
+      },
+      onError: () => {
+        if (!this.#disposed) {
+          failBeforeConnected("The ElevenLabs voice connection failed.");
+          this.#emitError("The ElevenLabs voice connection failed.");
+        }
+      },
+      onInterruption: () => {
+        this.#responseInProgress = false;
+      },
+      onMessage: ({ message, role }) => {
+        if (role === "user" && message.trim() && !this.#disposed) {
+          // A finalized expert answer closes the listening window before the
+          // silent Brunch latency period, preventing a second admitted turn.
+          this.#awaitingBrunchResponse = true;
+          this.#setMicrophoneMuted(true);
+          return;
+        }
+        if (
+          this.#disposed ||
+          role !== "agent" ||
+          this.#hasEmittedOpeningQuestion ||
+          !message.trim()
+        ) {
+          return;
+        }
+
+        this.#setMicrophoneMuted(true);
+        this.#hasEmittedOpeningQuestion = true;
+        const turnId = Math.max(this.#turnId, 1);
+        this.#emitResponseStarted(turnId);
+        this.#emit({
+          speaker: "assistant",
+          timestampMs: this.#dependencies.now(),
+          transcript: message,
+          turnId,
+          type: "final-transcript",
+        });
+        this.#emit({
+          responseText: message,
+          timestampMs: this.#dependencies.now(),
+          turnId,
+          type: "response-completed",
+        });
+        this.#responseInProgress = false;
+      },
+      onModeChange: ({ mode }) => {
+        this.#providerMode = mode;
+        if (mode === "speaking" && !this.#disposed) {
+          this.#awaitingBrunchResponse = false;
+          this.#setMicrophoneMuted(true);
+          this.#emitResponseStarted(Math.max(this.#turnId, 1));
+        } else if (
+          mode === "listening" &&
+          this.#isListening &&
+          !this.#awaitingBrunchResponse
+        ) {
+          this.#setMicrophoneMuted(false);
+        }
+      },
+    });
+
+    setConversation(conversation);
+    if (this.#disposed) {
+      await conversation.endSession();
+      this.#conversation = null;
+      readinessSettled = true;
+      resolveReady();
+      return;
+    }
+
+    await ready;
+  }
+
+  #emitResponseStarted(turnId: number): void {
+    if (this.#responseInProgress) {
+      return;
+    }
+    this.#responseInProgress = true;
+    this.#emit({
+      timestampMs: this.#dependencies.now(),
+      turnId,
+      type: "response-started",
+    });
+  }
+
+  #startDiagnosticsPolling(conversationId: string): void {
+    this.#stopDiagnosticsPolling();
+    this.#diagnosticConversationId = conversationId;
+    this.#diagnosticCursor = 0;
+    this.#diagnosticPollHandle = this.#dependencies.setInterval(() => {
+      void this.#pollDiagnostics();
+    }, DIAGNOSTICS_POLL_INTERVAL_MS);
+  }
+
+  #stopDiagnosticsPolling(): void {
+    if (this.#diagnosticPollHandle !== null) {
+      this.#dependencies.clearInterval(this.#diagnosticPollHandle);
+    }
+    this.#diagnosticPollHandle = null;
+    this.#diagnosticConversationId = null;
+    this.#diagnosticPollInFlight = false;
+  }
+
+  async #pollDiagnostics(): Promise<void> {
+    const conversationId = this.#diagnosticConversationId;
+    if (!conversationId || this.#diagnosticPollInFlight || this.#disposed) {
+      return;
+    }
+
+    this.#diagnosticPollInFlight = true;
+    try {
+      const query = new URLSearchParams({
+        conversationId,
+        after: String(this.#diagnosticCursor),
+      });
+      const response = await this.#dependencies.fetch(
+        `${DIAGNOSTICS_ENDPOINT}?${query}`,
+        { headers: { "x-voice-experiment": "elevenlabs-brunch" } },
+      );
+      if (!response.ok || this.#diagnosticConversationId !== conversationId) {
+        return;
+      }
+
+      const body = asRecord(await response.json());
+      if (!Array.isArray(body?.events)) {
+        return;
+      }
+      for (const value of body.events) {
+        const diagnostic = parseDiagnosticEvent(value);
+        if (!diagnostic || diagnostic.sequence <= this.#diagnosticCursor) {
+          continue;
+        }
+        this.#diagnosticCursor = diagnostic.sequence;
+        const { sequence: _sequence, ...event } = diagnostic;
+        if (
+          event.type === "partial-transcript" ||
+          event.type === "final-transcript"
+        ) {
+          if (event.speaker === "assistant") {
+            this.#emitResponseStarted(event.turnId);
+          }
+          this.#emit(event);
+          if (
+            event.type === "final-transcript" &&
+            event.speaker === "assistant"
+          ) {
+            this.#emit({
+              responseText: event.transcript,
+              timestampMs: event.timestampMs,
+              turnId: event.turnId,
+              type: "response-completed",
+            });
+            this.#responseInProgress = false;
+          }
+          continue;
+        }
+        this.#emit(event);
+      }
+    } catch {
+      // Diagnostics are non-authoritative and must never disrupt voice turns.
+    } finally {
+      this.#diagnosticPollInFlight = false;
+    }
+  }
+
+  #requireConversation(): ConversationControl {
+    if (!this.#connected || !this.#conversation || this.#disposed) {
+      throw new Error("The ElevenLabs voice session is not connected.");
+    }
+    return this.#conversation;
+  }
+
+  #setMicrophoneMuted(isMuted: boolean): void {
+    if (!this.#conversation || this.#isMicrophoneMuted === isMuted) {
+      return;
+    }
+    this.#conversation.setMicMuted(isMuted);
+    this.#isMicrophoneMuted = isMuted;
+  }
+
+  #emit(event: VoiceExperimentEvent): void {
+    for (const listener of this.#listeners) {
+      listener(event);
+    }
+  }
+
+  #emitError(message: string): void {
+    this.#emit({
+      message,
+      timestampMs: this.#dependencies.now(),
+      type: "error",
+    });
+  }
+}
+
+export const createElevenLabsAdapter = (
+  dependencies: Partial<ElevenLabsAdapterDependencies> = {},
+): VoiceExperimentAdapter =>
+  new ElevenLabsAdapter({ ...defaultDependencies, ...dependencies });
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.test.ts
new file mode 100644
index 00000000000..ca49dbc6b86
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.test.ts
@@ -0,0 +1,213 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  createInterviewCapture,
+  createMockInterviewDraft,
+  createMockInterviewProjection,
+  type FinalizeInterviewInput,
+} from "./interview-draft";
+
+describe("createMockInterviewDraft", () => {
+  test("creates a visible placeholder net when the elicitor has no structured captures", () => {
+    const result = createMockInterviewDraft({
+      captures: [],
+      conversationId: "conversation-1",
+      readiness: "finalize",
+      revision: 1,
+      transcript: [
+        {
+          speaker: "assistant",
+          transcript: "What process would you like to model?",
+          turnId: 1,
+        },
+        {
+          speaker: "expert",
+          transcript: "Battery charging.",
+          turnId: 1,
+        },
+      ],
+    });
+
+    expect(result).toMatchObject({
+      conversationId: "conversation-1",
+      source: "mock",
+      revision: 1,
+      title: "Battery charging — mock draft",
+    });
+    expect(result.petriNetDefinition.places).toHaveLength(2);
+    expect(result.petriNetDefinition.transitions).toHaveLength(1);
+    expect(result.petriNetDefinition.transitions[0]).toMatchObject({
+      inputArcs: [
+        {
+          placeId: "place__mock-interview-input",
+          type: "standard",
+          weight: 1,
+        },
+      ],
+      outputArcs: [{ placeId: "place__mock-draft-ready", weight: 1 }],
+    });
+    expect(result.petriNetDefinition.scenarios?.[0]?.initialState).toEqual({
+      type: "per_place",
+      content: {
+        "place__mock-draft-ready": "0",
+        "place__mock-interview-input": "1",
+      },
+    });
+    expect(result.warnings[0]).toContain("placeholder net");
+  });
+
+  test("projects state, step, and flow calls through the future draft contract", () => {
+    const result = createMockInterviewDraft({
+      captures: [
+        {
+          captureId: "capture-state-1",
+          toolName: "record_process_state",
+          input: {
+            name: "Battery empty",
+            description: "The battery starts empty.",
+            category: "state",
+          },
+        },
+        {
+          captureId: "capture-step-1",
+          toolName: "record_process_step",
+          input: {
+            name: "Charge battery",
+            description: "The charger fills the battery.",
+          },
+        },
+        {
+          captureId: "capture-state-2",
+          toolName: "record_process_state",
+          input: {
+            name: "Battery charged",
+            description: "The battery is ready.",
+            category: "state",
+          },
+        },
+        {
+          captureId: "capture-flow-1",
+          toolName: "record_process_flow",
+          input: { from: "Battery empty", to: "Charge battery" },
+        },
+        {
+          captureId: "capture-flow-2",
+          toolName: "record_process_flow",
+          input: { from: "Charge battery", to: "Battery charged" },
+        },
+      ],
+      conversationId: "conversation-2",
+      readiness: "finalize",
+      revision: 5,
+      transcript: [
+        {
+          speaker: "expert",
+          transcript: "Battery charging.",
+          turnId: 1,
+        },
+      ],
+    });
+
+    expect(result.petriNetDefinition.places.map(({ name }) => name)).toEqual([
+      "BatteryEmpty",
+      "BatteryCharged",
+    ]);
+    expect(result.petriNetDefinition.transitions).toEqual([
+      expect.objectContaining({
+        name: "ChargeBattery",
+        inputArcs: [{ placeId: "place__mock-1", type: "standard", weight: 1 }],
+        outputArcs: [{ placeId: "place__mock-2", weight: 1 }],
+      }),
+    ]);
+    expect(result.captures).toHaveLength(5);
+    expect(result.revision).toBe(5);
+    expect(result.warnings[0]).toContain("mock projector");
+  });
+
+  test("waits for coherent captures before producing a live projection", () => {
+    const input: FinalizeInterviewInput = {
+      captures: [
+        {
+          captureId: "capture-state",
+          toolName: "record_process_state",
+          input: {
+            name: "Battery empty",
+            description: "The battery starts empty.",
+            category: "state",
+          },
+        },
+      ],
+      conversationId: "conversation-live",
+      readiness: "captures",
+      revision: 1,
+      transcript: [
+        {
+          speaker: "expert",
+          transcript: "Battery charging.",
+          turnId: 1,
+        },
+      ],
+    };
+
+    expect(createMockInterviewProjection(input)).toBeNull();
+    expect(
+      createMockInterviewProjection({
+        ...input,
+        captures: [
+          ...input.captures,
+          {
+            captureId: "capture-step",
+            toolName: "record_process_step",
+            input: {
+              name: "Charge battery",
+              description: "The charger fills the battery.",
+            },
+          },
+          {
+            captureId: "capture-flow",
+            toolName: "record_process_flow",
+            input: { from: "Battery empty", to: "Charge battery" },
+          },
+        ],
+        revision: 3,
+      }),
+    ).toMatchObject({
+      revision: 3,
+      source: "mock",
+      title: "Battery charging — mock draft",
+    });
+    expect(
+      createMockInterviewProjection({
+        ...input,
+        readiness: "elicitor",
+        revision: 2,
+      }),
+    ).toMatchObject({
+      revision: 2,
+      title: "Battery charging — mock draft",
+    });
+  });
+
+  test("sanitizes provider capture payloads through one contract", () => {
+    expect(
+      createInterviewCapture({
+        captureId: "capture-1",
+        input: {
+          description: " Assess severity ",
+          name: "Triage",
+          owner: "Support",
+          secret: "must-not-leak",
+        },
+        toolName: "record_process_step",
+      }),
+    ).toEqual({
+      captureId: "capture-1",
+      input: {
+        description: "Assess severity",
+        name: "Triage",
+        owner: "Support",
+      },
+      toolName: "record_process_step",
+    });
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.ts
new file mode 100644
index 00000000000..64e3c7905f3
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-draft.ts
@@ -0,0 +1,401 @@
+import type { SDCPN } from "@hashintel/petrinaut-core";
+
+export type InterviewTranscriptLine = {
+  speaker: "assistant" | "expert";
+  transcript: string;
+  turnId: number;
+};
+
+export type InterviewCaptureToolName =
+  | "record_model_requirement"
+  | "record_process_decision"
+  | "record_process_flow"
+  | "record_process_state"
+  | "record_process_step";
+
+export type InterviewCapture = {
+  captureId: string;
+  input: Record<string, unknown>;
+  toolName: InterviewCaptureToolName;
+};
+
+export type FinalizeInterviewInput = {
+  captures: InterviewCapture[];
+  conversationId: string;
+  readiness: "captures" | "elicitor" | "finalize";
+  revision: number;
+  transcript: InterviewTranscriptLine[];
+};
+
+export type InterviewDraftResult = {
+  captures: InterviewCapture[];
+  conversationId: string;
+  petriNetDefinition: SDCPN;
+  revision: number;
+  source: "brunch" | "mock";
+  title: string;
+  transcript: InterviewTranscriptLine[];
+  warnings: string[];
+};
+
+export type FinalizeInterview = (
+  input: FinalizeInterviewInput,
+) => InterviewDraftResult | Promise<InterviewDraftResult>;
+
+const stringProperty = (
+  input: Record<string, unknown>,
+  property: string,
+): string | null => {
+  const value = input[property];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+};
+
+const allowedCaptureProperties = {
+  record_model_requirement: ["category", "description"],
+  record_process_decision: ["condition", "outcomes"],
+  record_process_flow: ["condition", "from", "to"],
+  record_process_state: ["category", "description", "name", "tokenDescription"],
+  record_process_step: ["description", "name", "owner", "timing", "trigger"],
+} satisfies Record<InterviewCaptureToolName, string[]>;
+
+const isInterviewCaptureToolName = (
+  toolName: string,
+): toolName is InterviewCaptureToolName =>
+  Object.hasOwn(allowedCaptureProperties, toolName);
+
+const safeCaptureValue = (value: unknown): string | string[] | null => {
+  if (typeof value === "string") {
+    const sanitized = value
+      .normalize("NFKC")
+      .replace(/\s+/gu, " ")
+      .trim()
+      .slice(0, 500);
+    return sanitized || null;
+  }
+  if (Array.isArray(value)) {
+    const sanitized = value
+      .filter((item): item is string => typeof item === "string")
+      .map((item) =>
+        item.normalize("NFKC").replace(/\s+/gu, " ").trim().slice(0, 500),
+      )
+      .filter(Boolean)
+      .slice(0, 20);
+    return sanitized.length > 0 ? sanitized : null;
+  }
+  return null;
+};
+
+export const createInterviewCapture = ({
+  captureId,
+  input,
+  toolName,
+}: {
+  captureId: string;
+  input: unknown;
+  toolName: string;
+}): InterviewCapture | null => {
+  if (
+    !isInterviewCaptureToolName(toolName) ||
+    typeof input !== "object" ||
+    input === null
+  ) {
+    return null;
+  }
+  const inputRecord = input as Record<string, unknown>;
+  const sanitizedInput = Object.fromEntries(
+    allowedCaptureProperties[toolName].flatMap((property) => {
+      const value = safeCaptureValue(inputRecord[property]);
+      return value === null ? [] : [[property, value]];
+    }),
+  );
+  if (Object.keys(sanitizedInput).length === 0) {
+    return null;
+  }
+  const sanitizedCaptureId = captureId.normalize("NFKC").trim().slice(0, 128);
+  if (!sanitizedCaptureId) {
+    return null;
+  }
+
+  return {
+    captureId: sanitizedCaptureId,
+    input: sanitizedInput,
+    toolName,
+  };
+};
+
+const identifierFrom = (value: string, fallback: string): string => {
+  const words = value.normalize("NFKC").match(/[\p{L}\p{N}]+/gu) ?? [];
+  const identifier = words
+    .map((word) => `${word[0]?.toLocaleUpperCase() ?? ""}${word.slice(1)}`)
+    .join("")
+    .replace(/^\d/u, "N$&");
+  return identifier || fallback;
+};
+
+const titleFrom = (transcript: readonly InterviewTranscriptLine[]): string => {
+  const expertTopic = transcript.find(
+    (line) => line.speaker === "expert" && line.transcript.trim(),
+  )?.transcript;
+  const topic = expertTopic
+    ?.normalize("NFKC")
+    .replace(/\s+/gu, " ")
+    .replace(/[.!?]+$/u, "")
+    .trim()
+    .slice(0, 60);
+  return `${topic || "Voice interview"} — mock draft`;
+};
+
+const emptyNetFields: Pick<
+  SDCPN,
+  "differentialEquations" | "parameters" | "types"
+> = {
+  differentialEquations: [],
+  parameters: [],
+  types: [],
+};
+
+const createFallbackDraft = (
+  topic: string,
+): { petriNetDefinition: SDCPN; warnings: string[] } => {
+  const topicIdentifier = identifierFrom(topic, "Interview");
+  const inputPlaceId = "place__mock-interview-input";
+  const outputPlaceId = "place__mock-draft-ready";
+
+  return {
+    petriNetDefinition: {
+      ...emptyNetFields,
+      places: [
+        {
+          id: inputPlaceId,
+          name: `${topicIdentifier}Input`,
+          colorId: null,
+          differentialEquationId: null,
+          dynamicsEnabled: false,
+          showAsInitialState: true,
+          x: 0,
+          y: 0,
+        },
+        {
+          id: outputPlaceId,
+          name: `${topicIdentifier}Draft`,
+          colorId: null,
+          differentialEquationId: null,
+          dynamicsEnabled: false,
+          x: 600,
+          y: 0,
+        },
+      ],
+      transitions: [
+        {
+          id: "transition__mock-create-draft",
+          name: `Draft${topicIdentifier}`,
+          inputArcs: [{ placeId: inputPlaceId, type: "standard", weight: 1 }],
+          outputArcs: [{ placeId: outputPlaceId, weight: 1 }],
+          lambdaCode: "export default Lambda(() => true)",
+          lambdaType: "predicate",
+          transitionKernelCode: "export default TransitionKernel(() => ({}));",
+          x: 300,
+          y: 0,
+        },
+      ],
+      scenarios: [
+        {
+          id: "scenario__mock-interview",
+          name: "Mock interview result",
+          description:
+            "A deterministic placeholder proving the voice interview can hand a draft to Petrinaut.",
+          initialState: {
+            type: "per_place",
+            content: {
+              [inputPlaceId]: "1",
+              [outputPlaceId]: "0",
+            },
+          },
+          parameterOverrides: {},
+          scenarioParameters: [],
+        },
+      ],
+    },
+    warnings: [
+      "The mock projector did not receive a complete state-step-flow graph, so it created a clearly labelled placeholder net.",
+    ],
+  };
+};
+
+const createCapturedDraft = (
+  captures: readonly InterviewCapture[],
+): { petriNetDefinition: SDCPN; warnings: string[] } | null => {
+  const stateCaptures = captures.filter(
+    (capture) => capture.toolName === "record_process_state",
+  );
+  const stepCaptures = captures.filter(
+    (capture) => capture.toolName === "record_process_step",
+  );
+  const flowCaptures = captures.filter(
+    (capture) => capture.toolName === "record_process_flow",
+  );
+
+  const stateNames = [
+    ...new Set(
+      stateCaptures
+        .map((capture) => stringProperty(capture.input, "name"))
+        .filter((name): name is string => name !== null),
+    ),
+  ];
+  const stepNames = [
+    ...new Set(
+      stepCaptures
+        .map((capture) => stringProperty(capture.input, "name"))
+        .filter((name): name is string => name !== null),
+    ),
+  ];
+  if (stateNames.length === 0 || stepNames.length === 0) {
+    return null;
+  }
+
+  const placeIdByName = new Map(
+    stateNames.map((name, index) => [
+      name.toLocaleLowerCase(),
+      `place__mock-${index + 1}`,
+    ]),
+  );
+  const transitionIdByName = new Map(
+    stepNames.map((name, index) => [
+      name.toLocaleLowerCase(),
+      `transition__mock-${index + 1}`,
+    ]),
+  );
+  const transitions: SDCPN["transitions"] = stepNames.map((name, index) => ({
+    id: `transition__mock-${index + 1}`,
+    name: identifierFrom(name, `Step${index + 1}`),
+    inputArcs: [],
+    outputArcs: [],
+    lambdaCode: "export default Lambda(() => true)",
+    lambdaType: "predicate",
+    transitionKernelCode: "export default TransitionKernel(() => ({}));",
+    x: 300 + index * 450,
+    y: 0,
+  }));
+
+  let resolvedFlowCount = 0;
+  for (const capture of flowCaptures) {
+    const from = stringProperty(capture.input, "from")?.toLocaleLowerCase();
+    const to = stringProperty(capture.input, "to")?.toLocaleLowerCase();
+    if (!from || !to) {
+      continue;
+    }
+    const fromPlaceId = placeIdByName.get(from);
+    const toTransitionId = transitionIdByName.get(to);
+    if (fromPlaceId && toTransitionId) {
+      transitions
+        .find((transition) => transition.id === toTransitionId)
+        ?.inputArcs.push({
+          placeId: fromPlaceId,
+          type: "standard",
+          weight: 1,
+        });
+      resolvedFlowCount += 1;
+      continue;
+    }
+    const fromTransitionId = transitionIdByName.get(from);
+    const toPlaceId = placeIdByName.get(to);
+    if (fromTransitionId && toPlaceId) {
+      transitions
+        .find((transition) => transition.id === fromTransitionId)
+        ?.outputArcs.push({ placeId: toPlaceId, weight: 1 });
+      resolvedFlowCount += 1;
+    }
+  }
+  if (resolvedFlowCount === 0) {
+    return null;
+  }
+
+  const places: SDCPN["places"] = stateNames.map((name, index) => ({
+    id: `place__mock-${index + 1}`,
+    name: identifierFrom(name, `State${index + 1}`),
+    colorId: null,
+    differentialEquationId: null,
+    dynamicsEnabled: false,
+    showAsInitialState: index === 0,
+    x: index * 450,
+    y: index % 2 === 0 ? -180 : 180,
+  }));
+  const firstPlace = places[0];
+
+  return {
+    petriNetDefinition: {
+      ...emptyNetFields,
+      places,
+      transitions,
+      scenarios: firstPlace
+        ? [
+            {
+              id: "scenario__mock-interview",
+              name: "Mock interview result",
+              description:
+                "A draft projected from experiment-only process capture calls.",
+              initialState: {
+                type: "per_place",
+                content: Object.fromEntries(
+                  places.map((place) => [
+                    place.id,
+                    place.id === firstPlace.id ? "1" : "0",
+                  ]),
+                ),
+              },
+              parameterOverrides: {},
+              scenarioParameters: [],
+            },
+          ]
+        : [],
+    },
+    warnings: [
+      "This net was generated by the mock projector and is not an authoritative Brunch projection.",
+    ],
+  };
+};
+
+export const createMockInterviewDraft = (
+  input: FinalizeInterviewInput,
+): InterviewDraftResult => {
+  const title = titleFrom(input.transcript);
+  const topic = title.replace(/ — mock draft$/u, "");
+  const projected =
+    createCapturedDraft(input.captures) ?? createFallbackDraft(topic);
+
+  return {
+    captures: structuredClone(input.captures),
+    conversationId: input.conversationId,
+    petriNetDefinition: projected.petriNetDefinition,
+    revision: input.revision,
+    source: "mock",
+    title,
+    transcript: structuredClone(input.transcript),
+    warnings: projected.warnings,
+  };
+};
+
+export const createMockInterviewProjection = (
+  input: FinalizeInterviewInput,
+): InterviewDraftResult | null => {
+  const title = titleFrom(input.transcript);
+  const projected =
+    createCapturedDraft(input.captures) ??
+    (input.readiness === "elicitor"
+      ? createFallbackDraft(title.replace(/ — mock draft$/u, ""))
+      : null);
+  if (!projected) {
+    return null;
+  }
+
+  return {
+    captures: structuredClone(input.captures),
+    conversationId: input.conversationId,
+    petriNetDefinition: projected.petriNetDefinition,
+    revision: input.revision,
+    source: "mock",
+    title,
+    transcript: structuredClone(input.transcript),
+    warnings: projected.warnings,
+  };
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-opening.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-opening.ts
new file mode 100644
index 00000000000..6f5b6619c6a
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/interview-opening.ts
@@ -0,0 +1,2 @@
+export const interviewOpeningQuestion =
+  "Hi—what process would you like us to model today?";
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.test.ts
new file mode 100644
index 00000000000..a54f13ee674
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.test.ts
@@ -0,0 +1,798 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { createOpenAIRealtimeAdapter } from "./openai-realtime-adapter";
+
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+
+const encoder = new TextEncoder();
+
+const sseResponse = (...chunks: Record<string, unknown>[]) =>
+  new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`),
+          );
+        }
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      },
+    }),
+  );
+
+class FakeDataChannel extends EventTarget {
+  public readyState: RTCDataChannelState = "connecting";
+  public readonly sent: unknown[] = [];
+
+  public close = vi.fn(() => {
+    this.readyState = "closed";
+  });
+
+  public open() {
+    this.readyState = "open";
+    this.dispatchEvent(new Event("open"));
+  }
+
+  public receive(payload: unknown) {
+    const event = new Event("message");
+    Object.defineProperty(event, "data", { value: JSON.stringify(payload) });
+    this.dispatchEvent(event);
+  }
+
+  public send(payload: string) {
+    this.sent.push(JSON.parse(payload));
+  }
+}
+
+const createHarness = ({
+  brunchResponse,
+  elicitor = "mock",
+}: {
+  brunchResponse?: Response;
+  elicitor?: "brunch" | "mock";
+} = {}) => {
+  const dataChannel = new FakeDataChannel();
+  const microphoneTrack = {
+    enabled: true,
+    stop: vi.fn(),
+  };
+  const mediaStream = {
+    getAudioTracks: () => [microphoneTrack],
+    getTracks: () => [microphoneTrack],
+  };
+  const audioElement = {
+    autoplay: false,
+    pause: vi.fn(),
+    srcObject: null,
+  };
+  const peerConnection = {
+    addTrack: vi.fn(),
+    close: vi.fn(),
+    createDataChannel: vi.fn(() => dataChannel),
+    createOffer: vi.fn(async () => ({ sdp: "offer-sdp", type: "offer" })),
+    onconnectionstatechange: null,
+    ontrack: null,
+    setLocalDescription: vi.fn(async () => undefined),
+    setRemoteDescription: vi.fn(async () => {
+      dataChannel.open();
+    }),
+  };
+  const fetch = vi
+    .fn()
+    .mockResolvedValueOnce(
+      Response.json({
+        clientSecret: "ephemeral-client-secret",
+        expiresAt: 1_800_000_000,
+      }),
+    )
+    .mockResolvedValueOnce(new Response("answer-sdp"));
+  if (brunchResponse) {
+    fetch.mockResolvedValueOnce(brunchResponse);
+  }
+  let now = 1_000;
+
+  const adapter = createOpenAIRealtimeAdapter({
+    conversationId: "voice-conversation",
+    createAudioElement: () => audioElement as unknown as HTMLAudioElement,
+    createPeerConnection: () => peerConnection as unknown as RTCPeerConnection,
+    elicitor,
+    fetch: fetch as typeof globalThis.fetch,
+    getUserMedia: vi.fn(async () => mediaStream as unknown as MediaStream),
+    now: () => ++now,
+  });
+  const events: VoiceExperimentEvent[] = [];
+  adapter.subscribe((event) => events.push(event));
+
+  return {
+    adapter,
+    audioElement,
+    dataChannel,
+    events,
+    fetch,
+    mediaStream,
+    microphoneTrack,
+    peerConnection,
+  };
+};
+
+describe("OpenAIRealtimeAdapter", () => {
+  test("connects with a server-minted secret and keeps the microphone gated", async () => {
+    const harness = createHarness();
+
+    await harness.adapter.connect();
+
+    expect(harness.fetch).toHaveBeenNthCalledWith(
+      1,
+      "/api/voice-experiment/openai-realtime-session",
+      expect.objectContaining({
+        headers: {
+          "x-voice-elicitor": "mock",
+          "x-voice-experiment": "openai-realtime",
+        },
+        method: "POST",
+      }),
+    );
+    expect(harness.fetch).toHaveBeenNthCalledWith(
+      2,
+      "https://api.openai.com/v1/realtime/calls",
+      expect.objectContaining({
+        body: "offer-sdp",
+        headers: {
+          authorization: "Bearer ephemeral-client-secret",
+          "content-type": "application/sdp",
+        },
+        method: "POST",
+      }),
+    );
+    expect(harness.fetch.mock.calls.flat().join(" ")).not.toContain(
+      "/api/chat",
+    );
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    expect(harness.events).toEqual([{ timestampMs: 1_001, type: "connected" }]);
+  });
+
+  test("opens with one interviewer question and leaves semantic VAD in control", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.adapter.startTurn();
+
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    expect(harness.dataChannel.sent).toEqual([
+      { type: "input_audio_buffer.clear" },
+      {
+        type: "response.create",
+        response: {
+          instructions:
+            'Say exactly: "Hi—what process would you like us to model today?" Do not call a tool.',
+        },
+      },
+    ]);
+    expect(harness.events).toEqual([{ timestampMs: 1_001, type: "connected" }]);
+
+    await harness.adapter.finishTurn();
+    await harness.adapter.startTurn();
+
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    expect(harness.dataChannel.sent).toEqual([
+      { type: "input_audio_buffer.clear" },
+      {
+        type: "response.create",
+        response: {
+          instructions:
+            'Say exactly: "Hi—what process would you like us to model today?" Do not call a tool.',
+        },
+      },
+    ]);
+  });
+
+  test("normalizes expert and assistant transcript events", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.delta",
+      item_id: "expert-item",
+      delta: "The support lead",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "expert-item",
+      transcript: "The support lead owns the escalation.",
+    });
+    harness.dataChannel.receive({ type: "response.created" });
+    harness.dataChannel.receive({
+      type: "response.output_audio_transcript.delta",
+      item_id: "assistant-item",
+      delta: "What happens next?",
+    });
+    harness.dataChannel.receive({
+      type: "response.output_audio_transcript.done",
+      item_id: "assistant-item",
+      transcript: "What happens next?",
+    });
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: { output: [], status: "completed" },
+    });
+
+    expect(harness.events).toContainEqual({
+      speaker: "expert",
+      timestampMs: 1_002,
+      transcript: "The support lead",
+      turnId: 1,
+      type: "partial-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      speaker: "expert",
+      timestampMs: 1_003,
+      transcript: "The support lead owns the escalation.",
+      turnId: 1,
+      type: "final-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      speaker: "assistant",
+      timestampMs: 1_005,
+      transcript: "What happens next?",
+      turnId: 1,
+      type: "partial-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      responseText: "What happens next?",
+      timestampMs: 1_007,
+      turnId: 1,
+      type: "response-completed",
+    });
+  });
+
+  test("does not render an empty finalized expert transcript", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "empty-expert-item",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "empty-expert-item",
+      transcript: "   ",
+    });
+
+    expect(
+      harness.events.some(
+        (event) =>
+          event.type === "final-transcript" && event.speaker === "expert",
+      ),
+    ).toBe(false);
+    expect(harness.dataChannel.sent).not.toContainEqual({
+      type: "response.create",
+    });
+  });
+
+  test("uses Brunch as the authoritative elicitor and Realtime only for speech", async () => {
+    const harness = createHarness({
+      elicitor: "brunch",
+      brunchResponse: sseResponse(
+        { type: "start", messageId: "assistant-ask" },
+        { type: "text-delta", id: "text-1", delta: "Thanks. " },
+        {
+          type: "tool-input-available",
+          toolCallId: "step-1",
+          toolName: "record_process_step",
+          input: {
+            description: "Assess severity",
+            name: "Triage",
+            owner: "Support lead",
+            secret: "must-not-leak",
+          },
+        },
+        {
+          type: "tool-input-available",
+          toolCallId: "sweep-1",
+          toolName: "brunch_sweep",
+          input: {},
+        },
+        {
+          type: "tool-output-available",
+          toolCallId: "sweep-1",
+          output: { status: "applied", appliedCaptureIds: ["capture-1"] },
+        },
+        {
+          type: "tool-input-available",
+          toolCallId: "ask-1",
+          toolName: "brunch_ask",
+          input: { question: "What happens next?" },
+        },
+        { type: "finish", finishReason: "tool-calls" },
+      ),
+    });
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "expert-item",
+      transcript: "The support lead triages it.",
+    });
+
+    await vi.waitFor(() => expect(harness.fetch).toHaveBeenCalledTimes(3));
+    const [chatUrl, chatRequest] = harness.fetch.mock.calls[2] as [
+      string,
+      RequestInit,
+    ];
+    expect(chatUrl).toBe("/api/voice-experiment/brunch-chat");
+    expect(JSON.parse(chatRequest.body as string)).toMatchObject({
+      id: "voice:voice-conversation",
+      messages: [
+        {
+          role: "user",
+          parts: [{ type: "text", text: "The support lead triages it." }],
+        },
+      ],
+    });
+    type SentResponseCreate = {
+      response?: {
+        conversation?: string;
+        input?: unknown[];
+        metadata?: Record<string, string>;
+        output_modalities?: string[];
+      };
+      type?: string;
+    };
+    let brunchSpeechRequest: SentResponseCreate | undefined;
+    await vi.waitFor(() => {
+      brunchSpeechRequest = (
+        harness.dataChannel.sent as SentResponseCreate[]
+      ).find(
+        (event) =>
+          event.type === "response.create" &&
+          event.response?.metadata?.source === "brunch",
+      );
+      expect(brunchSpeechRequest).toBeDefined();
+    });
+    expect(brunchSpeechRequest).toMatchObject({
+      type: "response.create",
+      response: {
+        conversation: "none",
+        input: [],
+        metadata: { source: "brunch", turnId: "1" },
+        output_modalities: ["audio"],
+      },
+    });
+
+    expect(harness.events).toContainEqual(
+      expect.objectContaining({
+        speaker: "assistant",
+        transcript: "Thanks. What happens next?",
+        turnId: 1,
+        type: "final-transcript",
+      }),
+    );
+    expect(harness.events).toContainEqual(
+      expect.objectContaining({
+        capture: {
+          captureId: "capture-step-1",
+          input: {
+            description: "Assess severity",
+            name: "Triage",
+            owner: "Support lead",
+          },
+          toolName: "record_process_step",
+        },
+        callId: "step-1",
+        toolName: "record_process_step",
+        type: "tool-called",
+      }),
+    );
+    expect(JSON.stringify(harness.events)).not.toContain("must-not-leak");
+    expect(harness.events).toContainEqual(
+      expect.objectContaining({
+        callId: "sweep-1",
+        type: "projection-ready",
+      }),
+    );
+    expect(harness.events).toContainEqual(
+      expect.objectContaining({
+        argumentSummary: "Question: What happens next?",
+        callId: "ask-1",
+        toolName: "brunch_ask",
+        type: "tool-called",
+      }),
+    );
+    expect(harness.microphoneTrack.enabled).toBe(false);
+
+    harness.dataChannel.receive({
+      type: "response.created",
+      response: { id: "brunch-speech-response" },
+    });
+    harness.dataChannel.receive({
+      type: "response.output_audio_transcript.done",
+      response_id: "brunch-speech-response",
+      item_id: "generated-speech-item",
+      transcript: "A paraphrase that is not authoritative.",
+    });
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: {
+        id: "brunch-speech-response",
+        output: [
+          {
+            type: "message",
+            content: [{ type: "audio", transcript: "Generated speech" }],
+          },
+        ],
+        status: "completed",
+      },
+    });
+
+    expect(JSON.stringify(harness.events)).not.toContain(
+      "A paraphrase that is not authoritative.",
+    );
+    expect(harness.events).toContainEqual(
+      expect.objectContaining({
+        responseText: "Thanks. What happens next?",
+        turnId: 1,
+        type: "response-completed",
+      }),
+    );
+    expect(harness.microphoneTrack.enabled).toBe(false);
+
+    harness.dataChannel.receive({
+      type: "output_audio_buffer.stopped",
+      response_id: "brunch-speech-response",
+    });
+    expect(harness.microphoneTrack.enabled).toBe(true);
+  });
+
+  test("listens only between interviewer responses", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    harness.dataChannel.receive({
+      type: "response.created",
+      response: { id: "opening-response" },
+    });
+    expect(harness.microphoneTrack.enabled).toBe(false);
+
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: {
+        id: "opening-response",
+        output: [
+          {
+            type: "message",
+            content: [{ type: "audio", transcript: "Opening question" }],
+          },
+        ],
+        status: "completed",
+      },
+    });
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    harness.dataChannel.receive({
+      type: "output_audio_buffer.stopped",
+      response_id: "opening-response",
+    });
+    expect(harness.microphoneTrack.enabled).toBe(true);
+
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-answer",
+    });
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    harness.dataChannel.receive({
+      type: "response.created",
+      response: { id: "answer-response" },
+    });
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: {
+        id: "answer-response",
+        output: [
+          {
+            type: "message",
+            content: [{ type: "audio", transcript: "Next question" }],
+          },
+        ],
+        status: "completed",
+      },
+    });
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    harness.dataChannel.receive({
+      type: "output_audio_buffer.stopped",
+      response_id: "answer-response",
+    });
+    expect(harness.microphoneTrack.enabled).toBe(true);
+  });
+
+  test("reopens the microphone as server VAD creates distinct expert turns", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-1",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "expert-item-1",
+      transcript: "The support lead triages it.",
+    });
+    harness.dataChannel.receive({ type: "response.created" });
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: { output: [], status: "completed" },
+    });
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-2",
+    });
+    harness.dataChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "expert-item-2",
+      transcript: "Then the incident owner takes over.",
+    });
+
+    expect(harness.microphoneTrack.enabled).toBe(false);
+    expect(harness.dataChannel.sent).toEqual([
+      { type: "input_audio_buffer.clear" },
+      {
+        type: "response.create",
+        response: {
+          instructions:
+            'Say exactly: "Hi—what process would you like us to model today?" Do not call a tool.',
+        },
+      },
+      { type: "response.create" },
+      { type: "input_audio_buffer.clear" },
+      { type: "response.create" },
+    ]);
+    expect(harness.events).toContainEqual({
+      speaker: "expert",
+      timestampMs: 1_002,
+      transcript: "The support lead triages it.",
+      turnId: 1,
+      type: "final-transcript",
+    });
+    expect(harness.events).toContainEqual({
+      speaker: "expert",
+      timestampMs: 1_006,
+      transcript: "Then the incident owner takes over.",
+      turnId: 2,
+      type: "final-transcript",
+    });
+  });
+
+  test("completes a cancelled response on its original turn", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "response.created",
+      response: { id: "response-1" },
+    });
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-1",
+    });
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-2",
+    });
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: { id: "response-1", status: "cancelled" },
+    });
+
+    expect(harness.events).toContainEqual({
+      timestampMs: 1_003,
+      turnId: 1,
+      type: "response-completed",
+    });
+    expect(harness.events.at(-1)).toEqual({
+      timestampMs: 1_004,
+      turnId: 3,
+      type: "recording-started",
+    });
+  });
+
+  test("keeps late assistant transcript events on their response turn", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+
+    harness.dataChannel.receive({
+      type: "response.created",
+      response: { id: "response-1" },
+    });
+    harness.dataChannel.receive({
+      type: "response.output_item.added",
+      response_id: "response-1",
+      item: { id: "assistant-item-1" },
+    });
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-1",
+    });
+    harness.dataChannel.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "expert-item-2",
+    });
+    harness.dataChannel.receive({
+      type: "response.output_audio_transcript.delta",
+      response_id: "response-1",
+      item_id: "assistant-item-1",
+      delta: "Interrupted question",
+    });
+
+    expect(harness.events.at(-1)).toEqual({
+      speaker: "assistant",
+      timestampMs: 1_003,
+      transcript: "Interrupted question",
+      turnId: 1,
+      type: "partial-transcript",
+    });
+  });
+
+  test("executes only dummy tools and continues the same turn", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+    harness.dataChannel.receive({ type: "response.created" });
+
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: {
+        output: [
+          {
+            arguments:
+              '{"name":"Triage","description":"Assess severity","owner":"Support lead","secret":"must-not-leak"}',
+            call_id: "call-1",
+            name: "record_process_step",
+            type: "function_call",
+          },
+        ],
+        status: "completed",
+      },
+    });
+
+    expect(harness.events).toContainEqual({
+      argumentSummary: "Triage · Assess severity · Owner: Support lead",
+      callId: "call-1",
+      capture: {
+        captureId: "capture-call-1",
+        input: {
+          description: "Assess severity",
+          name: "Triage",
+          owner: "Support lead",
+        },
+        toolName: "record_process_step",
+      },
+      timestampMs: 1_003,
+      toolName: "record_process_step",
+      turnId: 1,
+      type: "tool-called",
+    });
+    expect(JSON.stringify(harness.events)).not.toContain("must-not-leak");
+    expect(harness.dataChannel.sent).toContainEqual({
+      type: "conversation.item.create",
+      item: {
+        call_id: "call-1",
+        output: JSON.stringify({
+          captureId: "capture-call-1",
+          status: "accepted",
+        }),
+        type: "function_call_output",
+      },
+    });
+    expect(harness.dataChannel.sent.at(-1)).toEqual({
+      type: "response.create",
+    });
+    expect(
+      harness.events.some((event) => event.type === "response-completed"),
+    ).toBe(false);
+  });
+
+  test("ends a background-audio turn silently after wait_for_user", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+    harness.dataChannel.receive({ type: "response.created" });
+
+    harness.dataChannel.receive({
+      type: "response.done",
+      response: {
+        output: [
+          {
+            arguments: "{}",
+            call_id: "call-wait",
+            name: "wait_for_user",
+            type: "function_call",
+          },
+        ],
+        status: "completed",
+      },
+    });
+
+    expect(harness.events).toContainEqual({
+      argumentSummary: "Silent no-op",
+      callId: "call-wait",
+      timestampMs: 1_003,
+      toolName: "wait_for_user",
+      turnId: 1,
+      type: "tool-called",
+    });
+    expect(harness.dataChannel.sent).toContainEqual({
+      type: "conversation.item.create",
+      item: {
+        call_id: "call-wait",
+        output: JSON.stringify({ status: "waited" }),
+        type: "function_call_output",
+      },
+    });
+    expect(harness.dataChannel.sent).not.toContainEqual({
+      type: "response.create",
+    });
+    expect(harness.events).toContainEqual({
+      timestampMs: 1_004,
+      turnId: 1,
+      type: "response-completed",
+    });
+    expect(harness.events.at(-1)).toEqual({
+      timestampMs: 1_005,
+      turnId: 1,
+      type: "recording-started",
+    });
+  });
+
+  test("does not manually commit or recreate turns while the mic is open", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+    await harness.adapter.startTurn();
+    await harness.adapter.finishTurn();
+    harness.dataChannel.receive({ type: "response.created" });
+
+    await harness.adapter.startTurn();
+
+    expect(harness.dataChannel.sent).toEqual([
+      { type: "input_audio_buffer.clear" },
+      {
+        type: "response.create",
+        response: {
+          instructions:
+            'Say exactly: "Hi—what process would you like us to model today?" Do not call a tool.',
+        },
+      },
+    ]);
+    expect(harness.microphoneTrack.enabled).toBe(false);
+  });
+
+  test("releases media, playback, and connection resources idempotently", async () => {
+    const harness = createHarness();
+    await harness.adapter.connect();
+
+    await harness.adapter.dispose();
+    await harness.adapter.dispose();
+
+    expect(harness.microphoneTrack.stop).toHaveBeenCalledTimes(1);
+    expect(harness.audioElement.pause).toHaveBeenCalledTimes(1);
+    expect(harness.audioElement.srcObject).toBeNull();
+    expect(harness.dataChannel.close).toHaveBeenCalledTimes(1);
+    expect(harness.peerConnection.close).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.ts
new file mode 100644
index 00000000000..4e2ace57080
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/openai-realtime-adapter.ts
@@ -0,0 +1,1065 @@
+import {
+  BrunchVoiceBridge,
+  type BrunchVoiceProjectionReady,
+  type BrunchVoiceToolCall,
+} from "@hashintel/brunch-agent-transport-aisdk/voice-bridge";
+
+import { createInterviewCapture } from "./interview-draft";
+import { interviewOpeningQuestion } from "./interview-opening";
+
+import type { VoiceExperimentAdapter } from "./voice-experiment-adapter";
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+import type { VoiceElicitor } from "./voice-experiment-selection";
+
+const BRUNCH_CHAT_ENDPOINT = "/api/voice-experiment/brunch-chat";
+const SESSION_ENDPOINT = "/api/voice-experiment/openai-realtime-session";
+const REALTIME_CALLS_ENDPOINT = "https://api.openai.com/v1/realtime/calls";
+const CONNECTION_TIMEOUT_MS = 20_000;
+const WAIT_FOR_USER_TOOL_NAME = "wait_for_user";
+const DUMMY_TOOL_NAMES = new Set([
+  "record_process_decision",
+  "record_process_flow",
+  "record_process_step",
+  "record_process_state",
+  "record_model_requirement",
+  WAIT_FOR_USER_TOOL_NAME,
+]);
+
+type OpenAIRealtimeAdapterDependencies = {
+  conversationId: string;
+  createAudioElement: () => HTMLAudioElement;
+  createPeerConnection: () => RTCPeerConnection;
+  elicitor: VoiceElicitor;
+  fetch: typeof globalThis.fetch;
+  getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+  now: () => number;
+};
+
+type RealtimeEvent = {
+  type: string;
+  [key: string]: unknown;
+};
+
+type FunctionCall = {
+  arguments: string | null;
+  callId: string;
+  name: string;
+};
+
+const defaultDependencies = {
+  createAudioElement: () => document.createElement("audio"),
+  createPeerConnection: () => new RTCPeerConnection(),
+  fetch: (...args) => globalThis.fetch(...args),
+  getUserMedia: (constraints) =>
+    navigator.mediaDevices.getUserMedia(constraints),
+  now: () => Date.now(),
+} satisfies Omit<
+  OpenAIRealtimeAdapterDependencies,
+  "conversationId" | "elicitor"
+>;
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
+const getString = (
+  value: Record<string, unknown> | null,
+  key: string,
+): string | null => {
+  const candidate = value?.[key];
+  return typeof candidate === "string" ? candidate : null;
+};
+
+const parseServerEvent = (data: unknown): RealtimeEvent | null => {
+  if (typeof data !== "string") {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(data) as unknown;
+    const record = asRecord(parsed);
+    return record && typeof record.type === "string"
+      ? (record as RealtimeEvent)
+      : null;
+  } catch {
+    return null;
+  }
+};
+
+const boundedSummaryText = (value: unknown, limit = 120): string => {
+  if (typeof value !== "string") {
+    return "";
+  }
+  let sanitized = "";
+  for (const character of value.normalize("NFKC")) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint >= 32 && codePoint !== 127) {
+      sanitized += character;
+    }
+  }
+  return sanitized.replace(/\s+/gu, " ").trim().slice(0, limit);
+};
+
+const summarizeFunctionCall = ({
+  arguments: serializedArguments,
+  name,
+}: FunctionCall): string => {
+  if (name === WAIT_FOR_USER_TOOL_NAME) {
+    return "Silent no-op";
+  }
+
+  if (!serializedArguments) {
+    return "Arguments unavailable";
+  }
+
+  let input: Record<string, unknown> | null = null;
+  try {
+    input = asRecord(JSON.parse(serializedArguments));
+  } catch {
+    return "Arguments unavailable";
+  }
+
+  if (name === "record_process_state") {
+    const nameSummary = boundedSummaryText(input?.name);
+    const category = boundedSummaryText(input?.category);
+    const description = boundedSummaryText(input?.description);
+    const parts = [
+      nameSummary,
+      category ? `Type: ${category}` : "",
+      description,
+    ];
+    return (
+      parts.filter(Boolean).join(" · ").slice(0, 240) || "Arguments unavailable"
+    );
+  }
+
+  if (name === "record_process_step") {
+    const parts = [
+      boundedSummaryText(input?.name),
+      boundedSummaryText(input?.description),
+    ];
+    const owner = boundedSummaryText(input?.owner);
+    if (owner) {
+      parts.push(`Owner: ${owner}`);
+    }
+    return (
+      parts.filter(Boolean).join(" · ").slice(0, 240) || "Arguments unavailable"
+    );
+  }
+
+  if (name === "record_process_decision") {
+    const condition = boundedSummaryText(input?.condition);
+    const outcomes = Array.isArray(input?.outcomes)
+      ? input.outcomes
+          .slice(0, 4)
+          .map((outcome) => boundedSummaryText(outcome, 80))
+          .filter(Boolean)
+          .join(" / ")
+      : "";
+    const parts = [
+      condition ? `Condition: ${condition}` : "",
+      outcomes ? `Outcomes: ${outcomes}` : "",
+    ];
+    return (
+      parts.filter(Boolean).join(" · ").slice(0, 240) || "Arguments unavailable"
+    );
+  }
+
+  if (name === "record_process_flow") {
+    const from = boundedSummaryText(input?.from);
+    const to = boundedSummaryText(input?.to);
+    const condition = boundedSummaryText(input?.condition);
+    const parts = [
+      from && to ? `${from} → ${to}` : from || to,
+      condition ? `Condition: ${condition}` : "",
+    ];
+    return (
+      parts.filter(Boolean).join(" · ").slice(0, 240) || "Arguments unavailable"
+    );
+  }
+
+  if (name === "record_model_requirement") {
+    const category = boundedSummaryText(input?.category);
+    const description = boundedSummaryText(input?.description);
+    const parts = [category ? `Type: ${category}` : "", description];
+    return (
+      parts.filter(Boolean).join(" · ").slice(0, 240) || "Arguments unavailable"
+    );
+  }
+
+  return "Arguments hidden";
+};
+
+const parseFunctionCallInput = (functionCall: FunctionCall): unknown => {
+  if (!functionCall.arguments) {
+    return null;
+  }
+  try {
+    return JSON.parse(functionCall.arguments);
+  } catch {
+    return null;
+  }
+};
+
+class OpenAIRealtimeAdapter implements VoiceExperimentAdapter {
+  readonly #brunchBridge: BrunchVoiceBridge | null;
+  readonly #dependencies: OpenAIRealtimeAdapterDependencies;
+  readonly #listeners = new Set<(event: VoiceExperimentEvent) => void>();
+  readonly #pendingListeningTurnByResponseId = new Map<string, number>();
+  readonly #responsesWithAudio = new Set<string>();
+  readonly #transcriptByItemId = new Map<string, string>();
+  readonly #turnByItemId = new Map<string, number>();
+  readonly #turnByResponseId = new Map<string, number>();
+
+  #audioElement: HTMLAudioElement | null = null;
+  #brunchAbortController: AbortController | null = null;
+  #connectAbortController: AbortController | null = null;
+  #connectPromise: Promise<void> | null = null;
+  #connected = false;
+  #dataChannel: RTCDataChannel | null = null;
+  #interviewStarted = false;
+  #isReleasingResources = false;
+  #latestAssistantTranscript = "";
+  #latestTurnId = 0;
+  #mediaStream: MediaStream | null = null;
+  #microphoneTrack: MediaStreamTrack | null = null;
+  #peerConnection: RTCPeerConnection | null = null;
+  #turnId = 0;
+
+  public constructor(dependencies: OpenAIRealtimeAdapterDependencies) {
+    this.#dependencies = dependencies;
+    this.#brunchBridge =
+      dependencies.elicitor === "brunch"
+        ? new BrunchVoiceBridge({
+            chatEndpoint: BRUNCH_CHAT_ENDPOINT,
+            fetch: dependencies.fetch,
+            onProjectionReady: (event) =>
+              this.#emitBrunchProjectionReady(event),
+            onToolCall: (toolCall) => this.#emitBrunchToolCall(toolCall),
+          })
+        : null;
+  }
+
+  public subscribe(listener: (event: VoiceExperimentEvent) => void) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+
+  public async connect(): Promise<void> {
+    if (this.#connected) {
+      return;
+    }
+
+    if (this.#connectPromise) {
+      return this.#connectPromise;
+    }
+
+    this.#connectPromise = this.#establishConnection().finally(() => {
+      this.#connectPromise = null;
+    });
+
+    return this.#connectPromise;
+  }
+
+  public async startTurn(): Promise<void> {
+    const dataChannel = this.#requireOpenDataChannel();
+    const microphoneTrack = this.#microphoneTrack;
+    if (!microphoneTrack) {
+      throw new Error("The microphone is not available.");
+    }
+    if (this.#interviewStarted) {
+      return;
+    }
+
+    this.#interviewStarted = true;
+    this.#turnId += 1;
+    this.#latestTurnId = this.#turnId;
+    this.#latestAssistantTranscript =
+      this.#dependencies.elicitor === "brunch" ? interviewOpeningQuestion : "";
+
+    this.#send(dataChannel, { type: "input_audio_buffer.clear" });
+    microphoneTrack.enabled = false;
+    if (this.#dependencies.elicitor === "brunch") {
+      this.#emit({
+        timestampMs: this.#dependencies.now(),
+        turnId: this.#latestTurnId,
+        type: "response-started",
+      });
+      this.#emit({
+        speaker: "assistant",
+        timestampMs: this.#dependencies.now(),
+        transcript: interviewOpeningQuestion,
+        turnId: this.#latestTurnId,
+        type: "final-transcript",
+      });
+    }
+    this.#send(dataChannel, {
+      type: "response.create",
+      response: {
+        instructions: `Say exactly: "${interviewOpeningQuestion}" Do not call a tool.`,
+      },
+    });
+  }
+
+  public async finishTurn(): Promise<void> {
+    // Start/stop owns the session; semantic VAD owns each spoken turn.
+    this.#requireOpenDataChannel();
+  }
+
+  public async dispose(): Promise<void> {
+    this.#connectAbortController?.abort();
+    this.#releaseResources();
+  }
+
+  async #establishConnection(): Promise<void> {
+    const abortController = new AbortController();
+    this.#connectAbortController = abortController;
+    const timeout = globalThis.setTimeout(
+      () => abortController.abort(),
+      CONNECTION_TIMEOUT_MS,
+    );
+
+    try {
+      const tokenResponse = await this.#dependencies.fetch(SESSION_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "x-voice-elicitor": this.#dependencies.elicitor,
+          "x-voice-experiment": "openai-realtime",
+        },
+        signal: abortController.signal,
+      });
+      if (!tokenResponse.ok) {
+        throw new Error("The voice session could not be started.");
+      }
+
+      const tokenBody = asRecord(await tokenResponse.json());
+      const clientSecret = getString(tokenBody, "clientSecret");
+      if (!clientSecret) {
+        throw new Error("The voice session returned an invalid client secret.");
+      }
+
+      const peerConnection = this.#dependencies.createPeerConnection();
+      this.#peerConnection = peerConnection;
+
+      const audioElement = this.#dependencies.createAudioElement();
+      audioElement.autoplay = true;
+      this.#audioElement = audioElement;
+      peerConnection.ontrack = (event) => {
+        const [stream] = event.streams;
+        if (stream && this.#audioElement) {
+          this.#audioElement.srcObject = stream;
+        }
+      };
+      peerConnection.onconnectionstatechange = () => {
+        if (
+          peerConnection.connectionState === "failed" &&
+          !this.#isReleasingResources
+        ) {
+          this.#emitError("The realtime audio connection failed.");
+        }
+      };
+
+      const mediaStream = await this.#dependencies.getUserMedia({
+        audio: {
+          autoGainControl: true,
+          echoCancellation: true,
+          noiseSuppression: true,
+        },
+      });
+      this.#mediaStream = mediaStream;
+      const [microphoneTrack] = mediaStream.getAudioTracks();
+      if (!microphoneTrack) {
+        throw new Error("No microphone audio track was available.");
+      }
+      microphoneTrack.enabled = false;
+      this.#microphoneTrack = microphoneTrack;
+      peerConnection.addTrack(microphoneTrack, mediaStream);
+
+      const dataChannel = peerConnection.createDataChannel("oai-events");
+      this.#dataChannel = dataChannel;
+      dataChannel.addEventListener("message", this.#handleMessage);
+      dataChannel.addEventListener("close", this.#handleUnexpectedClose);
+
+      const offer = await peerConnection.createOffer();
+      await peerConnection.setLocalDescription(offer);
+      if (!offer.sdp) {
+        throw new Error("The browser could not create a realtime audio offer.");
+      }
+
+      const sdpResponse = await this.#dependencies.fetch(
+        REALTIME_CALLS_ENDPOINT,
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${clientSecret}`,
+            "content-type": "application/sdp",
+          },
+          body: offer.sdp,
+          signal: abortController.signal,
+        },
+      );
+      if (!sdpResponse.ok) {
+        throw new Error("OpenAI could not establish the realtime audio call.");
+      }
+
+      await peerConnection.setRemoteDescription({
+        type: "answer",
+        sdp: await sdpResponse.text(),
+      });
+      await this.#waitForDataChannelOpen(dataChannel, abortController.signal);
+
+      this.#connected = true;
+      this.#emit({
+        timestampMs: this.#dependencies.now(),
+        type: "connected",
+      });
+    } catch (error) {
+      this.#releaseResources();
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new Error("The realtime audio connection timed out.");
+      }
+      throw error;
+    } finally {
+      globalThis.clearTimeout(timeout);
+      if (this.#connectAbortController === abortController) {
+        this.#connectAbortController = null;
+      }
+    }
+  }
+
+  #waitForDataChannelOpen(
+    dataChannel: RTCDataChannel,
+    signal: AbortSignal,
+  ): Promise<void> {
+    if (dataChannel.readyState === "open") {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      const handleResult = (event: Event) => {
+        dataChannel.removeEventListener("open", handleResult);
+        dataChannel.removeEventListener("error", handleResult);
+        signal.removeEventListener("abort", handleResult);
+
+        if (event.type === "open") {
+          resolve();
+        } else if (event.type === "abort") {
+          reject(new DOMException("Connection aborted", "AbortError"));
+        } else {
+          reject(new Error("The realtime event channel failed to open."));
+        }
+      };
+
+      dataChannel.addEventListener("open", handleResult);
+      dataChannel.addEventListener("error", handleResult);
+      signal.addEventListener("abort", handleResult);
+    });
+  }
+
+  readonly #handleMessage = (message: MessageEvent<unknown>) => {
+    const event = parseServerEvent(message.data);
+    if (!event) {
+      this.#emitError("OpenAI sent an unreadable realtime event.");
+      return;
+    }
+
+    if (event.type === "input_audio_buffer.committed") {
+      // One finalized expert answer closes the listening window immediately;
+      // it reopens only after the corresponding interviewer response.
+      this.#setMicrophoneEnabled(false);
+      const itemId = getString(event, "item_id");
+      if (itemId) {
+        if (this.#turnByItemId.size > 0) {
+          this.#turnId += 1;
+          this.#latestTurnId = this.#turnId;
+          this.#latestAssistantTranscript = "";
+        }
+        this.#turnByItemId.set(itemId, this.#latestTurnId);
+      }
+      return;
+    }
+
+    if (event.type === "conversation.item.input_audio_transcription.delta") {
+      this.#handleTranscriptDelta(event, "expert");
+      return;
+    }
+
+    if (
+      event.type === "conversation.item.input_audio_transcription.completed"
+    ) {
+      const itemId = getString(event, "item_id");
+      const turnId = itemId ? this.#getTurnId(itemId) : this.#latestTurnId;
+      const transcript = this.#handleTranscriptCompleted(event, "expert");
+      if (transcript) {
+        if (this.#brunchBridge) {
+          void this.#requestBrunchTurn(transcript, turnId);
+        } else {
+          const dataChannel = this.#dataChannel;
+          if (dataChannel?.readyState === "open") {
+            this.#send(dataChannel, { type: "response.create" });
+          }
+        }
+      } else {
+        this.#openListeningWindow(turnId);
+      }
+      return;
+    }
+
+    if (event.type === "conversation.item.input_audio_transcription.failed") {
+      const itemId = getString(event, "item_id");
+      const turnId = itemId ? this.#getTurnId(itemId) : this.#latestTurnId;
+      if (itemId) {
+        this.#transcriptByItemId.delete(itemId);
+      }
+      this.#openListeningWindow(turnId);
+      return;
+    }
+
+    if (event.type === "response.created") {
+      const response = asRecord(event.response);
+      const responseId = getString(response, "id");
+      if (responseId) {
+        this.#turnByResponseId.set(responseId, this.#latestTurnId);
+      }
+      this.#setMicrophoneEnabled(false);
+      if (!this.#brunchBridge) {
+        this.#emit({
+          timestampMs: this.#dependencies.now(),
+          turnId: this.#latestTurnId,
+          type: "response-started",
+        });
+      }
+      return;
+    }
+
+    if (event.type === "response.output_item.added") {
+      const responseId = getString(event, "response_id");
+      const itemId = getString(asRecord(event.item), "id");
+      if (responseId && itemId) {
+        this.#turnByItemId.set(
+          itemId,
+          this.#turnByResponseId.get(responseId) ?? this.#latestTurnId,
+        );
+      }
+      return;
+    }
+
+    if (event.type === "response.output_audio_transcript.delta") {
+      const responseId = getString(event, "response_id");
+      if (responseId) {
+        this.#responsesWithAudio.add(responseId);
+      }
+      if (!this.#brunchBridge) {
+        this.#handleTranscriptDelta(event, "assistant");
+      }
+      return;
+    }
+
+    if (event.type === "response.output_audio_transcript.done") {
+      const responseId = getString(event, "response_id");
+      if (responseId) {
+        this.#responsesWithAudio.add(responseId);
+      }
+      if (!this.#brunchBridge) {
+        this.#handleTranscriptCompleted(event, "assistant");
+      }
+      return;
+    }
+
+    if (event.type === "response.done") {
+      this.#handleResponseDone(event);
+      return;
+    }
+
+    if (
+      event.type === "output_audio_buffer.stopped" ||
+      event.type === "output_audio_buffer.cleared"
+    ) {
+      const responseId = getString(event, "response_id");
+      const turnId = responseId
+        ? this.#pendingListeningTurnByResponseId.get(responseId)
+        : undefined;
+      if (responseId && turnId !== undefined) {
+        this.#pendingListeningTurnByResponseId.delete(responseId);
+        this.#responsesWithAudio.delete(responseId);
+        this.#openListeningWindow(turnId);
+      }
+      return;
+    }
+
+    if (event.type === "error") {
+      const error = asRecord(event.error);
+      this.#emitError(
+        getString(error, "message") ??
+          "The realtime session returned an error.",
+      );
+    }
+  };
+
+  #handleTranscriptDelta(
+    event: RealtimeEvent,
+    speaker: "assistant" | "expert",
+  ) {
+    const delta = getString(event, "delta");
+    const itemId = getString(event, "item_id");
+    if (!delta || !itemId) {
+      return;
+    }
+
+    const transcript = `${this.#transcriptByItemId.get(itemId) ?? ""}${delta}`;
+    this.#transcriptByItemId.set(itemId, transcript);
+    if (speaker === "assistant") {
+      this.#latestAssistantTranscript = transcript;
+    }
+
+    this.#emit({
+      speaker,
+      timestampMs: this.#dependencies.now(),
+      transcript,
+      turnId: this.#getTurnId(itemId, getString(event, "response_id")),
+      type: "partial-transcript",
+    });
+  }
+
+  #handleTranscriptCompleted(
+    event: RealtimeEvent,
+    speaker: "assistant" | "expert",
+  ): string | null {
+    const itemId = getString(event, "item_id");
+    if (!itemId) {
+      return null;
+    }
+
+    const transcript =
+      getString(event, "transcript") ??
+      this.#transcriptByItemId.get(itemId) ??
+      "";
+    if (!transcript.trim()) {
+      this.#transcriptByItemId.delete(itemId);
+      return null;
+    }
+    this.#transcriptByItemId.set(itemId, transcript);
+    if (speaker === "assistant") {
+      this.#latestAssistantTranscript = transcript;
+    }
+
+    this.#emit({
+      speaker,
+      timestampMs: this.#dependencies.now(),
+      transcript,
+      turnId: this.#getTurnId(itemId, getString(event, "response_id")),
+      type: "final-transcript",
+    });
+    return transcript;
+  }
+
+  async #requestBrunchTurn(transcript: string, turnId: number): Promise<void> {
+    const bridge = this.#brunchBridge;
+    if (!bridge) {
+      return;
+    }
+
+    this.#brunchAbortController?.abort();
+    const abortController = new AbortController();
+    this.#brunchAbortController = abortController;
+    let responseStarted = false;
+    let responseText = "";
+
+    try {
+      for await (const delta of bridge.respond({
+        conversationId: this.#dependencies.conversationId,
+        signal: abortController.signal,
+        transcript,
+      })) {
+        if (abortController.signal.aborted || !this.#connected) {
+          return;
+        }
+        responseText += delta;
+        if (!responseStarted) {
+          responseStarted = true;
+          this.#emit({
+            timestampMs: this.#dependencies.now(),
+            turnId,
+            type: "response-started",
+          });
+        }
+        this.#emit({
+          speaker: "assistant",
+          timestampMs: this.#dependencies.now(),
+          transcript: responseText,
+          turnId,
+          type: "partial-transcript",
+        });
+      }
+
+      if (abortController.signal.aborted || !this.#connected) {
+        return;
+      }
+      if (!responseText.trim()) {
+        this.#emit({
+          timestampMs: this.#dependencies.now(),
+          turnId,
+          type: "response-completed",
+        });
+        this.#openListeningWindow(turnId);
+        return;
+      }
+
+      if (!responseStarted) {
+        this.#emit({
+          timestampMs: this.#dependencies.now(),
+          turnId,
+          type: "response-started",
+        });
+      }
+      this.#latestAssistantTranscript = responseText;
+      this.#emit({
+        speaker: "assistant",
+        timestampMs: this.#dependencies.now(),
+        transcript: responseText,
+        turnId,
+        type: "final-transcript",
+      });
+
+      const dataChannel = this.#requireOpenDataChannel();
+      this.#send(dataChannel, {
+        type: "response.create",
+        response: {
+          conversation: "none",
+          input: [],
+          instructions: [
+            "Read the supplied interviewer text exactly as written.",
+            "Do not add, remove, paraphrase, answer, or comment on any words.",
+            `Interviewer text: ${JSON.stringify(responseText)}`,
+          ].join("\n"),
+          metadata: {
+            source: "brunch",
+            turnId: String(turnId),
+          },
+          output_modalities: ["audio"],
+        },
+      });
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return;
+      }
+      this.#emitError(
+        error instanceof Error
+          ? error.message
+          : "Brunch could not answer the voice turn.",
+      );
+      this.#openListeningWindow(turnId);
+    } finally {
+      if (this.#brunchAbortController === abortController) {
+        this.#brunchAbortController = null;
+      }
+    }
+  }
+
+  #emitBrunchToolCall({
+    input,
+    toolCallId,
+    toolName,
+  }: BrunchVoiceToolCall): void {
+    const safeToolCallId = boundedSummaryText(toolCallId, 96) || "unknown-call";
+    const safeToolName = boundedSummaryText(toolName, 96) || "unknown-tool";
+    const capture = createInterviewCapture({
+      captureId: `capture-${safeToolCallId}`,
+      input,
+      toolName: safeToolName,
+    });
+    const question =
+      toolName === "brunch_ask"
+        ? boundedSummaryText(asRecord(input)?.question, 220)
+        : "";
+    this.#emit({
+      argumentSummary:
+        toolName === "brunch_ask"
+          ? question
+            ? `Question: ${question}`
+            : "Question unavailable"
+          : toolName === "brunch_sweep"
+            ? "Settlement requested"
+            : "Arguments hidden",
+      callId: safeToolCallId,
+      ...(capture ? { capture } : {}),
+      timestampMs: this.#dependencies.now(),
+      toolName: safeToolName,
+      turnId: this.#latestTurnId,
+      type: "tool-called",
+    });
+  }
+
+  #emitBrunchProjectionReady({ toolCallId }: BrunchVoiceProjectionReady): void {
+    this.#emit({
+      callId: boundedSummaryText(toolCallId, 96) || "unknown-call",
+      timestampMs: this.#dependencies.now(),
+      type: "projection-ready",
+    });
+  }
+
+  #handleResponseDone(event: RealtimeEvent) {
+    const response = asRecord(event.response);
+    const responseTurnId = this.#getResponseTurnId(response);
+    const status = getString(response, "status");
+    if (status === "cancelled") {
+      this.#emit({
+        timestampMs: this.#dependencies.now(),
+        turnId: responseTurnId,
+        type: "response-completed",
+      });
+      this.#openListeningWindow(responseTurnId);
+      return;
+    }
+
+    const functionCalls = this.#getFunctionCalls(response?.output);
+    if (functionCalls.length > 0) {
+      const dataChannel = this.#dataChannel;
+      if (!dataChannel || dataChannel.readyState !== "open") {
+        this.#emitError("The tool result could not be returned.");
+        return;
+      }
+
+      for (const functionCall of functionCalls) {
+        const isWaitForUser = functionCall.name === WAIT_FOR_USER_TOOL_NAME;
+        const capture = createInterviewCapture({
+          captureId: `capture-${functionCall.callId}`,
+          input: parseFunctionCallInput(functionCall),
+          toolName: functionCall.name,
+        });
+        this.#emit({
+          argumentSummary: summarizeFunctionCall(functionCall),
+          callId: functionCall.callId,
+          ...(capture ? { capture } : {}),
+          timestampMs: this.#dependencies.now(),
+          toolName: functionCall.name,
+          turnId: responseTurnId,
+          type: "tool-called",
+        });
+        this.#send(dataChannel, {
+          type: "conversation.item.create",
+          item: {
+            type: "function_call_output",
+            call_id: functionCall.callId,
+            output: JSON.stringify(
+              isWaitForUser
+                ? { status: "waited" }
+                : capture
+                  ? {
+                      captureId: capture.captureId,
+                      status: "accepted",
+                    }
+                  : {
+                      status: DUMMY_TOOL_NAMES.has(functionCall.name)
+                        ? "ignored"
+                        : "unsupported",
+                    },
+            ),
+          },
+        });
+      }
+
+      if (
+        functionCalls.some(
+          (functionCall) => functionCall.name !== WAIT_FOR_USER_TOOL_NAME,
+        )
+      ) {
+        this.#send(dataChannel, { type: "response.create" });
+      } else {
+        this.#emit({
+          timestampMs: this.#dependencies.now(),
+          turnId: responseTurnId,
+          type: "response-completed",
+        });
+        this.#openListeningWindow(responseTurnId);
+      }
+      return;
+    }
+
+    if (status && status !== "completed") {
+      this.#setMicrophoneEnabled(true);
+      this.#emitError("The realtime response did not complete.");
+      return;
+    }
+
+    this.#emit({
+      ...(this.#latestAssistantTranscript
+        ? { responseText: this.#latestAssistantTranscript }
+        : {}),
+      timestampMs: this.#dependencies.now(),
+      turnId: responseTurnId,
+      type: "response-completed",
+    });
+    const responseId = getString(response, "id");
+    if (
+      responseId &&
+      (this.#responsesWithAudio.has(responseId) ||
+        this.#responseHasAudioOutput(response))
+    ) {
+      this.#pendingListeningTurnByResponseId.set(responseId, responseTurnId);
+    } else {
+      this.#openListeningWindow(responseTurnId);
+    }
+  }
+
+  #getFunctionCalls(output: unknown): FunctionCall[] {
+    if (!Array.isArray(output)) {
+      return [];
+    }
+
+    return output.flatMap((item) => {
+      const record = asRecord(item);
+      if (getString(record, "type") !== "function_call") {
+        return [];
+      }
+      const callId = getString(record, "call_id");
+      const name = getString(record, "name");
+      return callId && name
+        ? [{ arguments: getString(record, "arguments"), callId, name }]
+        : [];
+    });
+  }
+
+  #responseHasAudioOutput(response: Record<string, unknown> | null): boolean {
+    if (!Array.isArray(response?.output)) {
+      return false;
+    }
+    return response.output.some((outputItem) => {
+      const content = asRecord(outputItem)?.content;
+      return (
+        Array.isArray(content) &&
+        content.some(
+          (contentPart) => getString(asRecord(contentPart), "type") === "audio",
+        )
+      );
+    });
+  }
+
+  #getTurnId(itemId: string, responseId: string | null = null): number {
+    return (
+      this.#turnByItemId.get(itemId) ??
+      (responseId ? this.#turnByResponseId.get(responseId) : undefined) ??
+      this.#latestTurnId
+    );
+  }
+
+  #getResponseTurnId(response: Record<string, unknown> | null): number {
+    const responseId = getString(response, "id");
+    return (
+      (responseId ? this.#turnByResponseId.get(responseId) : undefined) ??
+      this.#latestTurnId
+    );
+  }
+
+  #setMicrophoneEnabled(enabled: boolean): void {
+    if (this.#microphoneTrack) {
+      this.#microphoneTrack.enabled = enabled;
+    }
+  }
+
+  #openListeningWindow(responseTurnId: number): void {
+    const dataChannel = this.#dataChannel;
+    if (dataChannel?.readyState === "open") {
+      this.#send(dataChannel, { type: "input_audio_buffer.clear" });
+    }
+    this.#setMicrophoneEnabled(true);
+    this.#emit({
+      timestampMs: this.#dependencies.now(),
+      turnId:
+        this.#turnByItemId.size === 0
+          ? responseTurnId
+          : Math.max(this.#latestTurnId + 1, responseTurnId + 1),
+      type: "recording-started",
+    });
+  }
+
+  #requireOpenDataChannel(): RTCDataChannel {
+    const dataChannel = this.#dataChannel;
+    if (!this.#connected || !dataChannel || dataChannel.readyState !== "open") {
+      throw new Error("Start the voice session before recording a turn.");
+    }
+    return dataChannel;
+  }
+
+  #send(dataChannel: RTCDataChannel, event: Record<string, unknown>) {
+    dataChannel.send(JSON.stringify(event));
+  }
+
+  #emit(event: VoiceExperimentEvent) {
+    for (const listener of this.#listeners) {
+      listener(event);
+    }
+  }
+
+  #emitError(message: string) {
+    this.#emit({
+      message,
+      timestampMs: this.#dependencies.now(),
+      type: "error",
+    });
+  }
+
+  readonly #handleUnexpectedClose = () => {
+    if (this.#connected && !this.#isReleasingResources) {
+      this.#connected = false;
+      this.#emitError("The realtime event channel closed unexpectedly.");
+    }
+  };
+
+  #releaseResources() {
+    this.#isReleasingResources = true;
+    this.#connected = false;
+    this.#brunchAbortController?.abort();
+    this.#brunchAbortController = null;
+    this.#brunchBridge?.release(this.#dependencies.conversationId);
+
+    const dataChannel = this.#dataChannel;
+    this.#dataChannel = null;
+    if (dataChannel) {
+      dataChannel.removeEventListener("message", this.#handleMessage);
+      dataChannel.removeEventListener("close", this.#handleUnexpectedClose);
+      dataChannel.close();
+    }
+
+    const mediaStream = this.#mediaStream;
+    this.#mediaStream = null;
+    this.#microphoneTrack = null;
+    for (const track of mediaStream?.getTracks() ?? []) {
+      track.stop();
+    }
+
+    const audioElement = this.#audioElement;
+    this.#audioElement = null;
+    if (audioElement) {
+      audioElement.pause();
+      audioElement.srcObject = null;
+    }
+
+    const peerConnection = this.#peerConnection;
+    this.#peerConnection = null;
+    if (peerConnection) {
+      peerConnection.onconnectionstatechange = null;
+      peerConnection.ontrack = null;
+      peerConnection.close();
+    }
+
+    this.#transcriptByItemId.clear();
+    this.#pendingListeningTurnByResponseId.clear();
+    this.#responsesWithAudio.clear();
+    this.#turnByItemId.clear();
+    this.#turnByResponseId.clear();
+    this.#interviewStarted = false;
+    this.#isReleasingResources = false;
+  }
+}
+
+export const createOpenAIRealtimeAdapter = (
+  dependencies: Partial<OpenAIRealtimeAdapterDependencies> = {},
+): VoiceExperimentAdapter =>
+  new OpenAIRealtimeAdapter({
+    ...defaultDependencies,
+    conversationId: crypto.randomUUID(),
+    elicitor: "mock",
+    ...dependencies,
+  });
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.test.ts
new file mode 100644
index 00000000000..72ca8fbb54f
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.test.ts
@@ -0,0 +1,121 @@
+import { describe, expect, test } from "vitest";
+
+import { getTranscriptEntries } from "./transcript-entries";
+
+describe("getTranscriptEntries", () => {
+  test("reconciles a late expert final around an interviewer partial", () => {
+    expect(
+      getTranscriptEntries([
+        {
+          sequence: 1,
+          event: {
+            speaker: "expert",
+            timestampMs: 1,
+            transcript: "Single",
+            turnId: 1,
+            type: "partial-transcript",
+          },
+        },
+        {
+          sequence: 2,
+          event: {
+            speaker: "assistant",
+            timestampMs: 2,
+            transcript: "Okay, thanks for that detail—let’s",
+            turnId: 1,
+            type: "partial-transcript",
+          },
+        },
+        {
+          sequence: 3,
+          event: {
+            speaker: "expert",
+            timestampMs: 3,
+            transcript: "Single battery",
+            turnId: 1,
+            type: "final-transcript",
+          },
+        },
+        {
+          sequence: 4,
+          event: {
+            speaker: "assistant",
+            timestampMs: 4,
+            transcript:
+              "What’s the starting condition for that battery when the process begins?",
+            turnId: 1,
+            type: "final-transcript",
+          },
+        },
+      ]),
+    ).toEqual([
+      {
+        id: 1,
+        isPartial: false,
+        speaker: "expert",
+        transcript: "Single battery",
+        turnId: 1,
+      },
+      {
+        id: 2,
+        isPartial: false,
+        speaker: "assistant",
+        transcript:
+          "What’s the starting condition for that battery when the process begins?",
+        turnId: 1,
+      },
+    ]);
+  });
+
+  test("collapses consecutive expert revisions into one bubble", () => {
+    expect(
+      getTranscriptEntries([
+        {
+          sequence: 1,
+          event: {
+            speaker: "expert",
+            timestampMs: 1,
+            transcript: "Test elicitation.",
+            turnId: 1,
+            type: "final-transcript",
+          },
+        },
+        {
+          sequence: 2,
+          event: {
+            speaker: "expert",
+            timestampMs: 2,
+            transcript: "Test, elicitation, one, two, three.",
+            turnId: 2,
+            type: "final-transcript",
+          },
+        },
+        {
+          sequence: 3,
+          event: {
+            speaker: "assistant",
+            timestampMs: 3,
+            transcript: "What process are we modelling?",
+            turnId: 2,
+            type: "final-transcript",
+          },
+        },
+      ]),
+    ).toEqual([
+      {
+        id: 1,
+        isPartial: false,
+        speaker: "expert",
+        transcript: "Test, elicitation, one, two, three.",
+        turnId: 2,
+      },
+      {
+        id: 3,
+        isPartial: false,
+        speaker: "assistant",
+        transcript: "What process are we modelling?",
+        turnId: 2,
+      },
+    ]);
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.ts
new file mode 100644
index 00000000000..e19b4f0a3d9
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/transcript-entries.ts
@@ -0,0 +1,66 @@
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+
+export type TranscriptEntry = {
+  id: number;
+  isPartial: boolean;
+  speaker: "assistant" | "expert";
+  transcript: string;
+  turnId: number;
+};
+
+type LoggedTranscriptSource = {
+  event: VoiceExperimentEvent;
+  sequence: number;
+};
+
+export const getTranscriptEntries = (
+  events: readonly LoggedTranscriptSource[],
+): TranscriptEntry[] => {
+  const entries: TranscriptEntry[] = [];
+  const partialEntryIndexes = new Map<string, number>();
+
+  for (const { event, sequence } of events) {
+    if (
+      event.type !== "partial-transcript" &&
+      event.type !== "final-transcript"
+    ) {
+      continue;
+    }
+
+    const entry: TranscriptEntry = {
+      id: sequence,
+      isPartial: event.type === "partial-transcript",
+      speaker: event.speaker,
+      transcript: event.transcript,
+      turnId: event.turnId,
+    };
+    const partialKey = `${event.turnId}:${event.speaker}`;
+    const partialEntryIndex = partialEntryIndexes.get(partialKey);
+    if (partialEntryIndex !== undefined) {
+      entries[partialEntryIndex] = {
+        ...entry,
+        id: entries[partialEntryIndex]?.id ?? sequence,
+      };
+      if (event.type === "final-transcript") {
+        partialEntryIndexes.delete(partialKey);
+      }
+      continue;
+    }
+
+    const lastEntry = entries.at(-1);
+    if (lastEntry?.speaker === event.speaker) {
+      entries[entries.length - 1] = { ...entry, id: lastEntry.id };
+      if (event.type === "partial-transcript") {
+        partialEntryIndexes.set(partialKey, entries.length - 1);
+      }
+      continue;
+    }
+
+    if (event.type === "partial-transcript") {
+      partialEntryIndexes.set(partialKey, entries.length);
+    }
+    entries.push(entry);
+  }
+
+  return entries;
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-adapter.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-adapter.ts
new file mode 100644
index 00000000000..1ea5d7b512a
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-adapter.ts
@@ -0,0 +1,17 @@
+import type { VoiceExperimentEvent } from "./voice-experiment-events";
+
+/**
+ * The observable contract shared by the experiment shell.
+ *
+ * Implementations own their browser audio, provider session, queued playback,
+ * and interruption state. `dispose` must be idempotent and must release all of
+ * those resources. Provider conversation and tool models stay private to the
+ * implementation.
+ */
+export type VoiceExperimentAdapter = {
+  connect(): Promise<void>;
+  startTurn(): Promise<void>;
+  finishTurn(): Promise<void>;
+  dispose(): Promise<void>;
+  subscribe(listener: (event: VoiceExperimentEvent) => void): () => void;
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-events.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-events.ts
new file mode 100644
index 00000000000..a1c01d45c3f
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-events.ts
@@ -0,0 +1,52 @@
+import type { InterviewCapture } from "./interview-draft";
+
+export type VoiceExperimentEvent =
+  | { conversationId?: string; timestampMs: number; type: "connected" }
+  | { timestampMs: number; turnId: number; type: "recording-started" }
+  | {
+      speaker: "assistant" | "expert";
+      timestampMs: number;
+      transcript: string;
+      turnId: number;
+      type: "partial-transcript";
+    }
+  | {
+      speaker: "assistant" | "expert";
+      timestampMs: number;
+      transcript: string;
+      turnId: number;
+      type: "final-transcript";
+    }
+  | { timestampMs: number; turnId: number; type: "response-started" }
+  | {
+      responseText?: string;
+      timestampMs: number;
+      turnId: number;
+      type: "response-completed";
+    }
+  | {
+      argumentSummary: string;
+      callId: string;
+      capture?: InterviewCapture;
+      timestampMs: number;
+      toolName: string;
+      turnId: number;
+      type: "tool-called";
+    }
+  | {
+      revision: number;
+      timestampMs: number;
+      type: "projection-updated";
+    }
+  | {
+      message: string;
+      revision: number;
+      timestampMs: number;
+      type: "projection-error";
+    }
+  | {
+      callId: string;
+      timestampMs: number;
+      type: "projection-ready";
+    }
+  | { message: string; timestampMs: number; type: "error" };
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.test.ts
new file mode 100644
index 00000000000..9949c4c85f4
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, test } from "vitest";
+
+import { getVoiceExperimentSelection } from "./voice-experiment-selection";
+
+describe("getVoiceExperimentSelection", () => {
+  test.each([
+    ["openai", "mock"],
+    ["openai", "brunch"],
+    ["elevenlabs", "brunch"],
+  ] as const)("selects %s voice with the %s elicitor", (provider, elicitor) => {
+    expect(
+      getVoiceExperimentSelection({
+        search: `?voiceProvider=${provider}&elicitor=${elicitor}`,
+      }),
+    ).toEqual({ elicitor, provider });
+  });
+
+  test("keeps the experiment shell hidden by default", () => {
+    expect(getVoiceExperimentSelection({ search: "" })).toBeNull();
+  });
+
+  test("enables the provider-independent mock projector", () => {
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=openai&elicitor=brunch&projector=mock",
+      }),
+    ).toEqual({
+      elicitor: "brunch",
+      projector: "mock",
+      provider: "openai",
+    });
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=elevenlabs&elicitor=brunch&projector=mock",
+      }),
+    ).toEqual({
+      elicitor: "brunch",
+      projector: "mock",
+      provider: "elevenlabs",
+    });
+  });
+
+  test("rejects partial, invalid, and unsupported combinations", () => {
+    expect(
+      getVoiceExperimentSelection({ search: "?voiceProvider=openai" }),
+    ).toBeNull();
+    expect(
+      getVoiceExperimentSelection({ search: "?elicitor=brunch" }),
+    ).toBeNull();
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=elevenlabs&elicitor=mock",
+      }),
+    ).toBeNull();
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=other&elicitor=brunch",
+      }),
+    ).toBeNull();
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=openai&elicitor=brunch&projector=real",
+      }),
+    ).toBeNull();
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceProvider=openai&elicitor=brunch&draft=mock",
+      }),
+    ).toBeNull();
+  });
+
+  test.each([
+    ["openai-realtime", { elicitor: "mock", provider: "openai" }],
+    ["elevenlabs-brunch", { elicitor: "brunch", provider: "elevenlabs" }],
+  ] as const)("keeps the legacy %s link working", (experiment, selection) => {
+    expect(
+      getVoiceExperimentSelection({
+        search: `?voiceExperiment=${experiment}`,
+      }),
+    ).toEqual(selection);
+  });
+
+  test("supports the mock projector on legacy experiment links", () => {
+    expect(
+      getVoiceExperimentSelection({
+        search: "?voiceExperiment=openai-realtime&projector=mock",
+      }),
+    ).toEqual({
+      elicitor: "mock",
+      projector: "mock",
+      provider: "openai",
+    });
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.ts
new file mode 100644
index 00000000000..696578c6f46
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/voice-experiment/voice-experiment-selection.ts
@@ -0,0 +1,68 @@
+export type VoiceProvider = "elevenlabs" | "openai";
+export type VoiceElicitor = "brunch" | "mock";
+export type VoiceProjector = "mock";
+
+export type VoiceExperimentSelection = {
+  elicitor: VoiceElicitor;
+  projector?: VoiceProjector;
+  provider: VoiceProvider;
+};
+
+const legacySelections = {
+  "elevenlabs-brunch": {
+    elicitor: "brunch",
+    provider: "elevenlabs",
+  },
+  "openai-realtime": {
+    elicitor: "mock",
+    provider: "openai",
+  },
+} as const satisfies Record<string, VoiceExperimentSelection>;
+
+export const getVoiceExperimentLabel = ({
+  elicitor,
+  projector,
+  provider,
+}: VoiceExperimentSelection): string =>
+  `${provider === "openai" ? "OpenAI Realtime" : "ElevenLabs"} · ${
+    elicitor === "brunch" ? "Brunch" : "mock tools"
+  }${projector === "mock" ? " · mock projector" : ""}`;
+
+export const getVoiceExperimentSelection = (
+  location: Pick<Location, "search">,
+): VoiceExperimentSelection | null => {
+  const searchParams = new URLSearchParams(location.search);
+  const provider = searchParams.get("voiceProvider");
+  const elicitor = searchParams.get("elicitor");
+  const projector = searchParams.get("projector");
+
+  if (
+    searchParams.has("draft") ||
+    (projector !== null && projector !== "mock")
+  ) {
+    return null;
+  }
+
+  if (provider !== null || elicitor !== null) {
+    if (
+      (provider !== "openai" && provider !== "elevenlabs") ||
+      (elicitor !== "mock" && elicitor !== "brunch") ||
+      (provider === "elevenlabs" && elicitor === "mock")
+    ) {
+      return null;
+    }
+    return {
+      elicitor,
+      ...(projector === "mock" ? { projector } : {}),
+      provider,
+    };
+  }
+
+  const legacyExperiment = searchParams.get("voiceExperiment");
+  return legacyExperiment && Object.hasOwn(legacySelections, legacyExperiment)
+    ? {
+        ...legacySelections[legacyExperiment as keyof typeof legacySelections],
+        ...(projector === "mock" ? { projector } : {}),
+      }
+    : null;
+};
diff --git a/apps/petrinaut-website/vercel.json b/apps/petrinaut-website/vercel.json
index 9931af7a709..1e294677728 100644
--- a/apps/petrinaut-website/vercel.json
+++ b/apps/petrinaut-website/vercel.json
@@ -20,6 +20,12 @@
   "functions": {
     "api/chat.ts": {
       "maxDuration": 300
+    },
+    "api/voice-experiment/openai-realtime-session.ts": {
+      "maxDuration": 15
+    },
+    "api/voice-experiment/elevenlabs-conversation-token.ts": {
+      "maxDuration": 15
     }
   }
 }
diff --git a/apps/petrinaut-website/vite.config.ts b/apps/petrinaut-website/vite.config.ts
index 9ad36010caf..fae751066c1 100644
--- a/apps/petrinaut-website/vite.config.ts
+++ b/apps/petrinaut-website/vite.config.ts
@@ -3,13 +3,19 @@ import { fileURLToPath } from "node:url";
 import babel from "@rolldown/plugin-babel";
 import react, { reactCompilerPreset } from "@vitejs/plugin-react";
 import { createServerAdapter } from "@whatwg-node/server";
-import { defineConfig, loadEnv, type Plugin } from "vite";
+import { defineConfig, loadEnv, type Plugin, type ViteDevServer } from "vite";
 
 import type { IncomingMessage, ServerResponse } from "node:http";
 
 const appRoot = fileURLToPath(new URL(".", import.meta.url));
 
 const loadServerEnv = (mode: string) => {
+  // mise injects the repository-wide Compose placeholder before Vite can load
+  // the website's real local key.
+  if (process.env.OPENAI_API_KEY === "dummy") {
+    delete process.env.OPENAI_API_KEY;
+  }
+
   const env = loadEnv(mode, appRoot, "");
 
   for (const [key, value] of Object.entries(env)) {
@@ -19,32 +25,66 @@ const loadServerEnv = (mode: string) => {
   }
 };
 
-// Plugin required to serve the chat endpoint in dev.
-// In production, it will be bundled and served by Vercel.
-const petrinautApiDevPlugin = (): Plugin => ({
-  name: "petrinaut-api-dev",
+type WebFetchApi = {
+  default: { fetch: (request: Request) => Promise<Response> };
+};
+
+const createApiAdapter = (server: ViteDevServer, modulePath: string) =>
+  createServerAdapter(async (request) => {
+    const { default: api } = (await server.ssrLoadModule(
+      modulePath,
+    )) as WebFetchApi;
+
+    try {
+      return await api.fetch(request);
+    } catch (error) {
+      server.ssrFixStacktrace(error as Error);
+      throw error;
+    }
+  });
+
+// Split chat from voice so the Brunch launcher can replace `/api/chat` while
+// retaining the same-origin provider-token endpoints.
+const petrinautChatApiDevPlugin = (): Plugin => ({
+  name: "petrinaut-chat-api-dev",
   apply: "serve",
   configureServer(server) {
-    // The chat endpoint ships a default `{ fetch }` so Vercel's Node.js
-    // runtime treats it as a Web fetch handler in production. We mirror the
-    // same shape here so dev and prod hit the same code path.
-    const adapter = createServerAdapter(async (request) => {
-      const { default: api } = (await server.ssrLoadModule("/api/chat.ts")) as {
-        default: { fetch: (request: Request) => Promise<Response> };
-      };
-
-      try {
-        return await api.fetch(request);
-      } catch (error) {
-        server.ssrFixStacktrace(error as Error);
-        throw error;
-      }
-    });
+    const chatAdapter = createApiAdapter(server, "/api/chat.ts");
 
     server.middlewares.use(
       "/api/chat",
       (request: IncomingMessage, response: ServerResponse) => {
-        void adapter(request, response);
+        void chatAdapter(request, response);
+      },
+    );
+  },
+});
+
+// Each endpoint ships a default `{ fetch }` so Vercel's Node.js runtime treats
+// it as a Web fetch handler in production. Dev mirrors that same code path.
+const petrinautVoiceApiDevPlugin = (): Plugin => ({
+  name: "petrinaut-voice-api-dev",
+  apply: "serve",
+  configureServer(server) {
+    const openAIRealtimeAdapter = createApiAdapter(
+      server,
+      "/api/voice-experiment/openai-realtime-session.ts",
+    );
+    const elevenLabsAdapter = createApiAdapter(
+      server,
+      "/api/voice-experiment/elevenlabs-conversation-token.ts",
+    );
+
+    server.middlewares.use(
+      "/api/voice-experiment/openai-realtime-session",
+      (request: IncomingMessage, response: ServerResponse) => {
+        void openAIRealtimeAdapter(request, response);
+      },
+    );
+    server.middlewares.use(
+      "/api/voice-experiment/elevenlabs-conversation-token",
+      (request: IncomingMessage, response: ServerResponse) => {
+        void elevenLabsAdapter(request, response);
       },
     );
   },
@@ -74,6 +114,15 @@ export default defineConfig(({ mode }) => {
     },
     server: {
       proxy: {
+        "/api/voice-experiment/brunch-chat": {
+          target: process.env.BRUNCH_CHAT_ORIGIN ?? "http://127.0.0.1:4321",
+          changeOrigin: true,
+          rewrite: () => "/api/chat",
+        },
+        "/api/voice-experiment/elevenlabs-brunch-diagnostics": {
+          target: process.env.BRUNCH_CHAT_ORIGIN ?? "http://127.0.0.1:4321",
+          changeOrigin: true,
+        },
         "/api/petrinaut-opt": {
           target: process.env.PETRINAUT_OPT_ORIGIN ?? "http://127.0.0.1:4004",
           changeOrigin: true,
@@ -83,7 +132,8 @@ export default defineConfig(({ mode }) => {
     },
 
     plugins: [
-      petrinautApiDevPlugin(),
+      petrinautChatApiDevPlugin(),
+      petrinautVoiceApiDevPlugin(),
       react(),
       babel({
         presets: [
diff --git a/libs/@hashintel/brunch-agent/docs/INDEX.md b/libs/@hashintel/brunch-agent/docs/INDEX.md
index ca6ea309c02..85a9ddd30c8 100644
--- a/libs/@hashintel/brunch-agent/docs/INDEX.md
+++ b/libs/@hashintel/brunch-agent/docs/INDEX.md
@@ -42,6 +42,7 @@ _(empty — items settle out via the arc-close inbox sweep)_
 | [petrinaut-integration-spec](planning/process-model-elicitation/petrinaut-integration-spec.md)                                               | active     | FE-1433                                  | Integration spec: elicitor as remote server behind the `aiAssistant` transport; suspension-borne client tools; `transport-aisdk`; principal + owner key; two gating spikes                                                                                                                                             |
 | [FE-1434 suspension verdict](planning/process-model-elicitation/spikes/fe-1434-suspension-verdict-2026-08-19.md)                             | active     | FE-1434                                  | Flue 2.0.3 carries a terminating client-tool batch through one durable pending slot and one non-user result signal; 3- and 100-result cases preserve ids in two dispatches                                                                                                                                             |
 | [FE-1434 suspension evidence](planning/process-model-elicitation/spikes/fe-1434-suspension-evidence-2026-08-19.json)                         | active     | FE-1434                                  | Deterministic transcript from the faux-provider runtime probe: native tool-result admission refused, signal resume succeeds, returned text is non-user and uncitable                                                                                                                                                   |
+| [H-6763 realtime-audio prototype](planning/process-model-elicitation/spikes/h-6763-realtime-audio-prototype-2026-08-24.md)                 | active     | H-6763                                   | Two-experiment decision plan: both paths open with the same interviewer question and alternate one endpointed expert answer with one interviewer response; OpenAI has dummy tools, while ElevenLabs wraps the real elicitor and reads panel transcripts from Brunch diagnostics                                    |
 | [adapter-panel-spike-2026-08-19](planning/process-model-elicitation/adapter-panel-spike-2026-08-19.md)                                       | settled    | FE-1435                                  | Real-panel spike verdict: AI SDK v6 SSE drives Petrinaut text/reasoning, default server-tool summaries, two live-editor client tools in one batched follow-up, and the diagnostics decorator; full POST/SSE transcript frozen as golden fixtures                                                                       |
 | [transport-aisdk-implementation-2026-08-19](planning/process-model-elicitation/transport-aisdk-implementation-2026-08-19.md)                 | settled    | FE-1436                                  | Durable real-panel transport: application `/api/chat` endpoint, substrate-neutral harness reply events, AI SDK v6 encoding, boundary gates, opt-in protocol inspection, and a clean-checkout local Petrinaut launcher                                                                                                  |
 | [ask-return-implementation-2026-08-19](planning/process-model-elicitation/ask-return-implementation-2026-08-19.md)                           | active     | FE-1449                                  | Ask suspend/return over the wire: the ask leaves as an awaiting client tool, the correlated `{ answer }` submission is admitted against durable history and resumes the conversation; stale/forged/duplicate/non-ask outputs refused before dispatch                                                                   |
diff --git a/libs/@hashintel/brunch-agent/docs/planning/process-model-elicitation/spikes/h-6763-realtime-audio-prototype-2026-08-24.md b/libs/@hashintel/brunch-agent/docs/planning/process-model-elicitation/spikes/h-6763-realtime-audio-prototype-2026-08-24.md
new file mode 100644
index 00000000000..27f4d7e7c77
--- /dev/null
+++ b/libs/@hashintel/brunch-agent/docs/planning/process-model-elicitation/spikes/h-6763-realtime-audio-prototype-2026-08-24.md
@@ -0,0 +1,126 @@
+# H-6763 realtime-audio prototype plan
+
+Date: 2026-08-24
+Status: active
+Linear: H-6763 — support for realtime audio interviewing of domain experts
+
+## Decision to make
+
+Choose the voice edge for the September Petrinaut elicitation experience without moving
+authoritative conversation state or elicitation policy out of Brunch.
+
+Two experiments answer different questions:
+
+1. **OpenAI Realtime with dummy tools** establishes the interaction-quality ceiling without
+   porting Brunch prompts, state, or tools.
+2. **ElevenLabs around the real elicitor** tests whether a speech edge can preserve the accepted
+   architecture while providing an acceptable experience.
+
+ElevenLabs is the default architectural lean. OpenAI Realtime wins only if its interaction quality
+is materially better and the team explicitly accepts the demonstrated porting cost.
+
+## Implementation progress
+
+- The shared, URL-selected shell is committed as `2903ed77bc98eeddc3c4fa3df95da7f9c11bcf2f`.
+- The OpenAI path now has a server-owned client-secret endpoint, WebRTC adapter,
+  `server_vad` (500ms silence, 300ms prefix padding), input/output transcripts, dummy tool handling, and
+  idempotent resource cleanup. Start speaks the shared opening question, then each cycle opens the
+  microphone for one expert answer and mutes it while the interviewer responds. The next listening
+  window waits for `output_audio_buffer.stopped`, not merely `response.done`, so buffered playback
+  cannot become an automatic expert turn. Server VAD, not a browser commit, closes the expert side
+  of each cycle; `create_response` is disabled and the adapter admits a model response only after a
+  non-empty finalized expert transcript.
+- The OpenAI code path does not call `/api/chat` and does not import or mutate Lu's Brunch session.
+- The ElevenLabs path is connected: Speech Engine owns ASR, TTS, and expert endpointing;
+  finalized transcripts go through `BrunchVoiceBridge` into `/api/chat`. It speaks the same opening
+  question as OpenAI before the first expert answer, then alternates one finalized expert answer
+  with one interviewer response; the microphone is muted during Brunch latency and playback.
+  `voice:dev` enables that client override and applies `patient` / `turn_v3` / 10s timeout on the
+  Speech Engine resource, so this path is not still a hold-to-speak prototype. Revised provider
+  turns are serialized behind the interrupted request, and a pending `brunch_ask` is consumed only
+  after Brunch admits its answer.
+- The voice panel's conversation list is driven by the same events as OpenAI. Speech Engine does
+  not stream those events to the browser, so Brunch records the expert utterance and spoken
+  `brunch_ask` question on `/api/chat` and the adapter polls them. Client `user_transcript` copies
+  are ignored so they do not stack as extra Expert bubbles; consecutive expert revisions collapse
+  to one line. Updates appear after the turn (500ms poll), not as live STT partials.
+- Automated endpoint and adapter coverage is in place. Credentialed microphone runs of both
+  experiments remain the next comparison step. Restart the Brunch process on `4321` to pick up
+  transcript recording; restarting `voice:dev` alone is not enough.
+
+## Accepted placement and boundaries
+
+- `apps/petrinaut-website` owns the user-facing voice controls and provider adapters.
+- `apps/brunch-agent` remains the Petrinaut-independent remote elicitor server.
+- The existing AI SDK `/api/chat` transport remains the real-elicitor seam.
+- Brunch owns authoritative session history, structured questions, captures, and provenance.
+- Providers may own browser audio, ASR, TTS, endpointing, and interruption detection, but their
+  conversation history is never authoritative.
+- Partial transcripts are display-only. Only admitted final human utterances may become evidence.
+
+## Prototype sequence
+
+### 0. Establish the base
+
+- Branch H-6763 from Lu's FE-1437 monorepo-import branch while it is under review.
+- Verify the real Petrinaut panel can reach `apps/brunch-agent` through `/api/chat`.
+- Keep the stock assistant unchanged when the prototype is disabled.
+
+### 1. Shared website shell
+
+- Add a query-enabled prototype panel to the local-storage Petrinaut application using only
+  `?voiceExperiment=openai-realtime` and `?voiceExperiment=elevenlabs-brunch`.
+- Select an experiment for the lifetime of the page. Never switch providers inside an active
+  conversation; changing experiments must dispose the adapter and reload into a new conversation.
+- Add shared hold-to-speak, start/end controls, scenario script, connection state, visible
+  transcript, and event/timing log.
+- Keep the shell behind a narrow adapter contract covering connect, turn start/finish, disposal,
+  and normalized observable events. Provider conversation and tool models stay private.
+- Keep provider credentials server-side.
+- Instrument transcript, response, and tool events for side-by-side evaluation.
+
+### 2. OpenAI Realtime experiment
+
+- Connect over WebRTC.
+- Use a small interview prompt and representative dummy tools only.
+- Record perceived latency, transcript quality, tool-call reliability, and the Brunch behavior that
+  would need to be copied or bridged.
+- Stop before porting the real elicitor.
+
+### 3. ElevenLabs experiment
+
+- Use ElevenLabs for the browser audio edge and speech conversion.
+- Submit each final transcript through the real Brunch human-input path.
+- Stream the elicitor's text response back for speech playback.
+- Prove a spoken answer resumes the same `brunch_ask` and yields the next real elicitor turn.
+
+### 4. Team decision
+
+Run the same scenario at least three times with each provider and compare interaction quality,
+transcription, tool fidelity, elicitor fidelity, state integrity, integration complexity, and
+remaining work to satisfy H-6763.
+
+## Prototype exclusions
+
+- Custom open-microphone VAD of our own; providers own endpointing (`server_vad` / Speech Engine
+  `turn_v3`). Tuning beyond the checked-in patient/low settings waits on the comparison recordings.
+- Provider abstraction intended for production reuse
+- Durable transcript persistence
+- Live capture extraction from partial transcripts
+- Net projection or client-tool mutation from the voice adapter
+- Gemini Live unless both primary experiments fail or social fluency becomes decisive
+
+## Prototype exit criteria
+
+- One draft Petrinaut website PR contains the shared shell and both experiments behind an explicit
+  query parameter.
+- OpenAI Realtime completes the scripted interview with dummy tools.
+- ElevenLabs completes at least one real `brunch_ask` suspend-and-resume cycle.
+- Both experiments have short recordings and a completed comparison table.
+- The team records a provider decision before production hardening begins.
+
+## Post-decision work
+
+The winning path then adds transcript persistence, private browser sessions, production-wide
+cancellation and stale-audio invalidation, live captures with provenance, open-mic/VAD, and the
+end-session transition to the separate IR-to-net projection and Petrinaut draft.
diff --git a/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json b/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
index 6095c8f6a15..80314cd2d95 100644
--- a/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
@@ -13,6 +13,10 @@
     "./client-tools": {
       "types": "./src/client-tools.ts",
       "import": "./dist/client-tools.js"
+    },
+    "./voice-bridge": {
+      "types": "./src/voice-bridge.ts",
+      "import": "./dist/voice-bridge.js"
     }
   },
   "scripts": {
diff --git a/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/voice-bridge.ts b/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/voice-bridge.ts
new file mode 100644
index 00000000000..332b672baf0
--- /dev/null
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/voice-bridge.ts
@@ -0,0 +1,270 @@
+export type BrunchVoiceToolCall = {
+  input: unknown;
+  toolCallId: string;
+  toolName: string;
+};
+
+export type BrunchVoiceProjectionReady = {
+  output: unknown;
+  toolCallId: string;
+};
+
+type BrunchVoiceBridgeDependencies = {
+  chatEndpoint: string;
+  createId?: () => string;
+  fetch?: typeof globalThis.fetch;
+  onProjectionReady?: (event: BrunchVoiceProjectionReady) => void;
+  onToolCall?: (toolCall: BrunchVoiceToolCall) => void;
+};
+
+type VoiceTurn = {
+  conversationId: string;
+  signal: AbortSignal;
+  transcript: string;
+};
+
+type PendingAsk = {
+  assistantMessageId: string;
+  input: unknown;
+  toolCallId: string;
+};
+
+type BridgeSessionState = {
+  pendingAsk?: PendingAsk;
+};
+
+type UiStreamChunk = Record<string, unknown> & { type: string };
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
+const stringProperty = (
+  value: Record<string, unknown> | null,
+  key: string,
+): string | null => {
+  const candidate = value?.[key];
+  return typeof candidate === "string" ? candidate : null;
+};
+
+const chunksFromFrame = (frame: string): UiStreamChunk[] => {
+  const data = frame
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice("data:".length).trimStart())
+    .join("\n");
+  if (!data || data === "[DONE]") {
+    return [];
+  }
+
+  try {
+    const parsed = JSON.parse(data) as unknown;
+    const record = asRecord(parsed);
+    return record && typeof record.type === "string"
+      ? [record as UiStreamChunk]
+      : [];
+  } catch {
+    throw new Error("Brunch returned an invalid voice response.");
+  }
+};
+
+const readUiMessageStream = async function* (
+  body: ReadableStream<Uint8Array>,
+): AsyncGenerator<UiStreamChunk> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffer += decoder.decode(value, { stream: !done });
+
+      const frames = buffer.split(/\r?\n\r?\n/u);
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        yield* chunksFromFrame(frame);
+      }
+
+      if (done) {
+        break;
+      }
+    }
+
+    if (buffer.trim()) {
+      yield* chunksFromFrame(buffer);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+};
+
+/**
+ * Translates finalized voice turns into the existing AI SDK transport.
+ * Brunch remains authoritative: this bridge retains only enough correlation to
+ * return a spoken answer to a pending `brunch_ask` affordance.
+ */
+export class BrunchVoiceBridge {
+  readonly #chatEndpoint: string;
+  readonly #createId: () => string;
+  readonly #fetch: typeof globalThis.fetch;
+  readonly #onProjectionReady:
+    | ((event: BrunchVoiceProjectionReady) => void)
+    | undefined;
+  readonly #onToolCall: ((toolCall: BrunchVoiceToolCall) => void) | undefined;
+  readonly #sessions = new Map<string, BridgeSessionState>();
+
+  public constructor(dependencies: BrunchVoiceBridgeDependencies) {
+    this.#chatEndpoint = dependencies.chatEndpoint;
+    this.#createId = dependencies.createId ?? (() => crypto.randomUUID());
+    this.#fetch = dependencies.fetch ?? globalThis.fetch;
+    this.#onProjectionReady = dependencies.onProjectionReady;
+    this.#onToolCall = dependencies.onToolCall;
+  }
+
+  public async *respond({
+    conversationId,
+    signal,
+    transcript,
+  }: VoiceTurn): AsyncGenerator<string> {
+    const normalizedTranscript = transcript.trim();
+    if (!normalizedTranscript) {
+      return;
+    }
+
+    const state = this.#sessions.get(conversationId) ?? {};
+    this.#sessions.set(conversationId, state);
+    const pendingAsk = state.pendingAsk;
+
+    const brunchConversationId = `voice:${conversationId}`;
+    const body = pendingAsk
+      ? {
+          id: brunchConversationId,
+          trigger: "submit-message",
+          messageId: pendingAsk.assistantMessageId,
+          messages: [
+            {
+              id: pendingAsk.assistantMessageId,
+              role: "assistant",
+              parts: [
+                {
+                  type: "dynamic-tool",
+                  toolName: "brunch_ask",
+                  toolCallId: pendingAsk.toolCallId,
+                  state: "output-available",
+                  input: pendingAsk.input,
+                  output: { answer: normalizedTranscript },
+                },
+              ],
+            },
+          ],
+        }
+      : {
+          id: brunchConversationId,
+          trigger: "submit-message",
+          messages: [
+            {
+              id: this.#createId(),
+              role: "user",
+              parts: [{ type: "text", text: normalizedTranscript }],
+            },
+          ],
+        };
+
+    const response = await this.#fetch(this.#chatEndpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-request-id": this.#createId(),
+      },
+      body: JSON.stringify(body),
+      signal,
+    });
+    if (!response.ok || !response.body) {
+      throw new Error("Brunch could not answer the voice turn.");
+    }
+    if (pendingAsk && state.pendingAsk === pendingAsk) {
+      // Receiving response headers means Brunch admitted the ask reply. Keep
+      // the correlation available when interruption aborts before admission.
+      state.pendingAsk = undefined;
+    }
+
+    let assistantMessageId: string | null =
+      pendingAsk?.assistantMessageId ?? null;
+    let spokenText = "";
+    const sweepToolCallIds = new Set<string>();
+    for await (const chunk of readUiMessageStream(response.body)) {
+      if (chunk.type === "start") {
+        assistantMessageId = stringProperty(chunk, "messageId");
+        continue;
+      }
+
+      if (chunk.type === "text-delta") {
+        const delta = stringProperty(chunk, "delta");
+        if (delta) {
+          spokenText += delta;
+          yield delta;
+        }
+        continue;
+      }
+
+      if (chunk.type === "tool-input-available") {
+        const toolCallId = stringProperty(chunk, "toolCallId");
+        const toolName = stringProperty(chunk, "toolName");
+        if (toolCallId && toolName) {
+          this.#onToolCall?.({
+            input: chunk.input,
+            toolCallId,
+            toolName,
+          });
+          if (toolName === "brunch_sweep") {
+            sweepToolCallIds.add(toolCallId);
+          }
+        }
+        if (toolName !== "brunch_ask") {
+          continue;
+        }
+
+        const input = chunk.input;
+        if (!assistantMessageId || !toolCallId) {
+          throw new Error("Brunch returned an invalid voice response.");
+        }
+        state.pendingAsk = { assistantMessageId, input, toolCallId };
+
+        const question = stringProperty(asRecord(input), "question");
+        if (
+          question &&
+          !spokenText
+            .trim()
+            .toLocaleLowerCase()
+            .endsWith(question.trim().toLocaleLowerCase())
+        ) {
+          yield question;
+        }
+        continue;
+      }
+
+      if (chunk.type === "tool-output-available") {
+        const toolCallId = stringProperty(chunk, "toolCallId");
+        const output = asRecord(chunk.output);
+        if (
+          toolCallId &&
+          sweepToolCallIds.has(toolCallId) &&
+          stringProperty(output, "status") === "applied"
+        ) {
+          this.#onProjectionReady?.({ output: chunk.output, toolCallId });
+        }
+        continue;
+      }
+
+      if (chunk.type === "error") {
+        throw new Error("Brunch could not answer the voice turn.");
+      }
+    }
+  }
+
+  public release(conversationId: string): void {
+    this.#sessions.delete(conversationId);
+  }
+}
diff --git a/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts b/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts
index 77a7a9fe479..27cee69b122 100644
--- a/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts
@@ -12,6 +12,9 @@ export default defineConfig({
           new URL("src/client-tools.ts", import.meta.url),
         ),
         index: fileURLToPath(new URL("src/index.ts", import.meta.url)),
+        "voice-bridge": fileURLToPath(
+          new URL("src/voice-bridge.ts", import.meta.url),
+        ),
       },
       fileName: (_format, entryName) => `${entryName}.js`,
       formats: ["es"],
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/ai-cta-modal.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/ai-cta-modal.tsx
index bb677eae955..bd42a04e423 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/ai-cta-modal.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/ai-cta-modal.tsx
@@ -96,6 +96,12 @@ export const AiCtaModal = ({
       if (!(target instanceof Node)) {
         return;
       }
+      if (
+        target instanceof Element &&
+        target.closest("[data-ai-cta-dismiss-exempt]")
+      ) {
+        return;
+      }
       if (formRef.current?.contains(target)) {
         return;
       }
diff --git a/yarn.lock b/yarn.lock
index df8f3cfdc8b..c30d9b9d90e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -435,6 +435,7 @@ __metadata:
   resolution: "@apps/brunch-agent@workspace:apps/brunch-agent"
   dependencies:
     "@earendil-works/pi-ai": "npm:0.83.0"
+    "@elevenlabs/elevenlabs-js": "npm:2.64.0"
     "@flue/react": "npm:2.0.3"
     "@flue/runtime": "npm:2.0.3"
     "@flue/sdk": "npm:2.0.3"
@@ -914,6 +915,7 @@ __metadata:
   resolution: "@apps/petrinaut-website@workspace:apps/petrinaut-website"
   dependencies:
     "@ai-sdk/openai": "npm:3.0.63"
+    "@elevenlabs/client": "npm:1.18.0"
     "@hashintel/brunch-agent-transport-aisdk": "workspace:*"
     "@hashintel/ds-components": "workspace:*"
     "@hashintel/ds-helpers": "workspace:*"
@@ -4351,6 +4353,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@bufbuild/protobuf@npm:^1.10.0":
+  version: 1.10.1
+  resolution: "@bufbuild/protobuf@npm:1.10.1"
+  checksum: 10c0/a89572ae99aa193dd232fca0cdc9ece1dfe2f3d8b061be1f966a4f88fb63410aeb0fe7de927037e970aefcb52036eec58a7f89a40fe1286eed1448ea1bd2634e
+  languageName: node
+  linkType: hard
+
 "@bufbuild/protobuf@npm:^2.6.2":
   version: 2.12.1
   resolution: "@bufbuild/protobuf@npm:2.12.1"
@@ -5283,6 +5292,34 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@elevenlabs/client@npm:1.18.0":
+  version: 1.18.0
+  resolution: "@elevenlabs/client@npm:1.18.0"
+  dependencies:
+    "@elevenlabs/types": "npm:0.20.0"
+    livekit-client: "npm:^2.21.0"
+  checksum: 10c0/331fe90bffe89005fadece646ef72dfdc6858a1ae87089d6fa9c33c25ce7df01f0d8fe9f5e2cd39c4822de9edc9ffcedfc3982d416abc800e7bfe16cca0b6fc7
+  languageName: node
+  linkType: hard
+
+"@elevenlabs/elevenlabs-js@npm:2.64.0":
+  version: 2.64.0
+  resolution: "@elevenlabs/elevenlabs-js@npm:2.64.0"
+  dependencies:
+    command-exists: "npm:^1.2.9"
+    node-fetch: "npm:^2.7.0"
+    ws: "npm:^8.18.3"
+  checksum: 10c0/6cb8f9bcf70e237bc15d664ec3569ade1d72591c775d45e599b44c46bb08d306685c6d5be77791547bb11877169802a2fb9065b18b285386bf0ba5d6af477e97
+  languageName: node
+  linkType: hard
+
+"@elevenlabs/types@npm:0.20.0":
+  version: 0.20.0
+  resolution: "@elevenlabs/types@npm:0.20.0"
+  checksum: 10c0/726454bdfbf8c4272858a8e2bac31d6e190bdff6b228a9428674b3bf7685effcf67010293252aa2358dfb629d5cfdd30574724db756c3246573ac12de3a763b3
+  languageName: node
+  linkType: hard
+
 "@emmetio/abbreviation@npm:^2.3.3":
   version: 2.3.3
   resolution: "@emmetio/abbreviation@npm:2.3.3"
@@ -9112,6 +9149,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@livekit/mutex@npm:1.1.1":
+  version: 1.1.1
+  resolution: "@livekit/mutex@npm:1.1.1"
+  checksum: 10c0/d4bb1bd34e20939dfc8af0ae10b86918f3944336d0236d219e80a8c554207e8bfaf21e86794f0c56d2c28b43d74ca966111172a95eacb0e12b72133dd184d49a
+  languageName: node
+  linkType: hard
+
+"@livekit/protocol@npm:1.50.4":
+  version: 1.50.4
+  resolution: "@livekit/protocol@npm:1.50.4"
+  dependencies:
+    "@bufbuild/protobuf": "npm:^1.10.0"
+  checksum: 10c0/6e986854bdae38991d60f6dca204b1ad90d8f033d699fb5a317abbfe97df9da8f8a5f905f94de0e25300cede03462bfcc0802232660e599daa97205302cc7384
+  languageName: node
+  linkType: hard
+
 "@llamaindex/core@npm:0.6.22":
   version: 0.6.22
   resolution: "@llamaindex/core@npm:0.6.22"
@@ -24135,6 +24188,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"command-exists@npm:^1.2.9":
+  version: 1.2.9
+  resolution: "command-exists@npm:1.2.9"
+  checksum: 10c0/75040240062de46cd6cd43e6b3032a8b0494525c89d3962e280dde665103f8cc304a8b313a5aa541b91da2f5a9af75c5959dc3a77893a2726407a5e9a0234c16
+  languageName: node
+  linkType: hard
+
 "command-line-args@npm:^4.0.6":
   version: 4.0.7
   resolution: "command-line-args@npm:4.0.7"
@@ -32346,10 +32406,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jose@npm:^6.1.3":
-  version: 6.1.3
-  resolution: "jose@npm:6.1.3"
-  checksum: 10c0/b9577b4a7a5e84131011c23823db9f5951eae3ba796771a6a2401ae5dd50daf71104febc8ded9c38146aa5ebe94a92ac09c725e699e613ef26949b9f5a8bc30f
+"jose@npm:^6.1.0, jose@npm:^6.1.3":
+  version: 6.2.9
+  resolution: "jose@npm:6.2.9"
+  checksum: 10c0/fc6d79b11fdd5cc1393bccd644533b3e2445fd8eb2468066eb23c01ed7f6b41deca710e8aabe9379a382cca7920740900c7f610bdf0be4ff5e7ee44412730d4c
   languageName: node
   linkType: hard
 
@@ -33495,6 +33555,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"livekit-client@npm:^2.21.0":
+  version: 2.22.0
+  resolution: "livekit-client@npm:2.22.0"
+  dependencies:
+    "@livekit/mutex": "npm:1.1.1"
+    "@livekit/protocol": "npm:1.50.4"
+    events: "npm:^3.3.0"
+    jose: "npm:^6.1.0"
+    loglevel: "npm:^1.9.2"
+    sdp-transform: "npm:^2.15.0"
+    tslib: "npm:2.8.1"
+    typed-emitter: "npm:^2.1.0"
+    webrtc-adapter: "npm:9.0.6"
+  peerDependencies:
+    "@types/dom-mediacapture-record": ^1
+  checksum: 10c0/a881f7477f6d675a291e146f27e748137ca0d37a9601eb4488818c29817417412588d78a52eff08ff7a523926e334ddc94b85f3f9da50ef43c2f1266eda49276
+  languageName: node
+  linkType: hard
+
 "llamaindex@npm:0.12.1":
   version: 0.12.1
   resolution: "llamaindex@npm:0.12.1"
@@ -33767,7 +33846,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"loglevel@npm:^1.6.8":
+"loglevel@npm:^1.6.8, loglevel@npm:^1.9.2":
   version: 1.9.2
   resolution: "loglevel@npm:1.9.2"
   checksum: 10c0/1e317fa4648fe0b4a4cffef6de037340592cee8547b07d4ce97a487abe9153e704b98451100c799b032c72bb89c9366d71c9fb8192ada8703269263ae77acdc7
@@ -36001,7 +36080,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-fetch@npm:2.7.0, node-fetch@npm:^2.6.1, node-fetch@npm:^2.6.7, node-fetch@npm:^2.6.9":
+"node-fetch@npm:2.7.0, node-fetch@npm:^2.6.1, node-fetch@npm:^2.6.7, node-fetch@npm:^2.6.9, node-fetch@npm:^2.7.0":
   version: 2.7.0
   resolution: "node-fetch@npm:2.7.0"
   dependencies:
@@ -41000,7 +41079,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rxjs@npm:7.8.2, rxjs@npm:^7.8.1, rxjs@npm:^7.8.2":
+"rxjs@npm:*, rxjs@npm:7.8.2, rxjs@npm:^7.8.1, rxjs@npm:^7.8.2":
   version: 7.8.2
   resolution: "rxjs@npm:7.8.2"
   dependencies:
@@ -41240,6 +41319,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"sdp-transform@npm:^2.15.0":
+  version: 2.15.0
+  resolution: "sdp-transform@npm:2.15.0"
+  bin:
+    sdp-verify: checker.js
+  checksum: 10c0/96c060f113a3d5418defa168db609f7e23e5bd7954fa1cf7784f103dbe702e24d667e5310d2ac6d88abdb32322af83d6ebd0df08e07f4f172d5ed5888f921386
+  languageName: node
+  linkType: hard
+
+"sdp@npm:^3.2.0":
+  version: 3.2.2
+  resolution: "sdp@npm:3.2.2"
+  checksum: 10c0/62913cbd92b0cca8feb17850dee9e331d6e38402385d4985aac80bde6b35032bfb7453c00096c4d7e6a91a9d73a7ba6235c2368998a54a8edd1c0dd4ec94d9e3
+  languageName: node
+  linkType: hard
+
 "selderee@npm:^0.11.0":
   version: 0.11.0
   resolution: "selderee@npm:0.11.0"
@@ -44085,6 +44180,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typed-emitter@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "typed-emitter@npm:2.1.0"
+  dependencies:
+    rxjs: "npm:*"
+  dependenciesMeta:
+    rxjs:
+      optional: true
+  checksum: 10c0/01fc354ba8e87bd39b1bf4fe1c96fe7ecff7fde83161003b0f8c7f4b285a368052e185ba655dd8c102c4445301b7a1e032c8972f181b440fc95bd810450f1314
+  languageName: node
+  linkType: hard
+
 "typedarray@npm:^0.0.6":
   version: 0.0.6
   resolution: "typedarray@npm:0.0.6"
@@ -46142,6 +46249,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"webrtc-adapter@npm:9.0.6":
+  version: 9.0.6
+  resolution: "webrtc-adapter@npm:9.0.6"
+  dependencies:
+    sdp: "npm:^3.2.0"
+  checksum: 10c0/19b44f507d4583df300ce338a24fe343473edf433228978666eacfc7eee27d2603cb8683da8f1bb380031ac5e827e224824d2921395e008fea85d14ad59b1aba
+  languageName: node
+  linkType: hard
+
 "websocket-driver@npm:>=0.5.1, websocket-driver@npm:^0.7.4":
   version: 0.7.5
   resolution: "websocket-driver@npm:0.7.5"