diff --git a/.changeset/stable-composer-controls.md b/.changeset/stable-composer-controls.md
index d1df963bd70..1bccd0dbc6c 100644
--- a/.changeset/stable-composer-controls.md
+++ b/.changeset/stable-composer-controls.md
@@ -4,4 +4,5 @@
 
 Add a generic host-rendered AI composer control with stable finalized-text submission,
 conversation identity, stop handling, schema-validated interactive-tool text mapping, and an
-explicit separate-message target for corrections.
+explicit separate-message target for corrections. Add a queue-aware voice submission path so a
+finalized spoken turn is retained while another response settles.
diff --git a/apps/petrinaut-website/.env.example b/apps/petrinaut-website/.env.example
index dfb9d72a1b6..2e3a4e81d8a 100644
--- a/apps/petrinaut-website/.env.example
+++ b/apps/petrinaut-website/.env.example
@@ -1 +1,4 @@
 OPENAI_API_KEY=sk-xxxx
+OPENAI_VOICE_API_KEY=
+PETRINAUT_OPENAI_VOICE_ENABLED=false
+VITE_BRUNCH_CHAT_ENDPOINT=
diff --git a/apps/petrinaut-website/README.md b/apps/petrinaut-website/README.md
index 83e8927096e..583ccbe749c 100644
--- a/apps/petrinaut-website/README.md
+++ b/apps/petrinaut-website/README.md
@@ -7,7 +7,8 @@ role: Demo site and embed host for the Petrinaut editor
 
 A website for demoing Petrinaut (libs/@hashintel/petrinaut).
 
-A SPA with API functions for AI assistance and JSON oEmbed discovery.
+A SPA with API functions for AI assistance, voice initialization, and JSON
+oEmbed discovery.
 
 ## Quickstart
 
@@ -18,7 +19,7 @@ cp .env.example .env.local
 turbo run dev
 ```
 
-The dev server runs at [http://localhost:5173](http://localhost:5173). A plugin in `vite.config.ts` loads the API function.
+The dev server runs at [http://localhost:5173](http://localhost:5173). A plugin in `vite.config.ts` loads the API functions.
 
 In production, the functions in the `api` folder are automatically deployed as
 Vercel Functions.
@@ -60,15 +61,39 @@ provides a fake 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. |
-
-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.
+| Name                             | Required         | Used by          | Notes                                                      |
+| -------------------------------- | ---------------- | ---------------- | ---------------------------------------------------------- |
+| `OPENAI_API_KEY`                 | for chat to work | `api/chat.ts`    | OpenAI key the function uses to call `streamText`.         |
+| `OPENAI_VOICE_API_KEY`           | for voice input  | voice API        | Dedicated OpenAI key used only by the Realtime call proxy. |
+| `PETRINAUT_OPENAI_VOICE_ENABLED` | no               | voice API        | Set to `true` to enable voice outside production.          |
+| `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_BRUNCH_CHAT_ENDPOINT`      | for voice input  | website          | Full Brunch Petrinaut chat endpoint used by the panel.     |
+| `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 API functions. In production, set these in the Vercel project settings.
+
+### Brunch voice-input preview
+
+Voice input is disabled by default and always unavailable when `VERCEL_ENV` is
+`production`. To exercise the preview locally or in a Vercel preview, set a
+real `VITE_BRUNCH_CHAT_ENDPOINT`, `PETRINAUT_OPENAI_VOICE_ENABLED=true`, and a
+dedicated `OPENAI_VOICE_API_KEY`. The browser sends its SDP offer to this app;
+the server initializes an OpenAI transcription-only Realtime session and keeps
+the provider key, model, language, and vocabulary policy private. The session
+uses `gpt-live-transcribe`'s default server VAD because OpenAI's unified call
+currently times out when explicit turn detection is included during setup.
+
+Only finalized transcripts enter the existing Petrinaut composer and Brunch AI
+SDK transport. Partial transcripts remain display-only. The preview derives a
+stable conversation id from the locally saved net; it is diagnostic identity,
+not production authentication or conversation authority.
+
+The Brunch deployment must allow the website origin through its
+`BRUNCH_PETRINAUT_ORIGINS` setting. Starting voice input requests browser
+microphone permission. Denying permission leaves the existing text composer
+available and does not submit anything to Brunch.
 
 ## Testing the API against the built output
 
diff --git a/apps/petrinaut-website/api/voice/config.ts b/apps/petrinaut-website/api/voice/config.ts
new file mode 100644
index 00000000000..c6239de88db
--- /dev/null
+++ b/apps/petrinaut-website/api/voice/config.ts
@@ -0,0 +1,9 @@
+import { createOpenAIVoiceConfigHandler } from "../../src/server/voice/openai-voice-config";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+export default {
+  fetch: createOpenAIVoiceConfigHandler(process.env),
+};
diff --git a/apps/petrinaut-website/api/voice/realtime-call.ts b/apps/petrinaut-website/api/voice/realtime-call.ts
new file mode 100644
index 00000000000..b9b1b1f78ee
--- /dev/null
+++ b/apps/petrinaut-website/api/voice/realtime-call.ts
@@ -0,0 +1,12 @@
+import { createOpenAIRealtimeCallHandler } from "../../src/server/voice/openai-realtime-call";
+
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+export default {
+  fetch: createOpenAIRealtimeCallHandler({
+    environment: process.env,
+    fetch: globalThis.fetch.bind(globalThis),
+  }),
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.ts
new file mode 100644
index 00000000000..c7db816a6b9
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, test } from "vitest";
+
+import { brunchAskFromComposerText } from "./brunch-ask-mapping";
+
+describe("Brunch ask composer mapping", () => {
+  test("maps finalized composer text to the pending ask answer", () => {
+    expect(
+      brunchAskFromComposerText({
+        input: { question: "Who triages the incident?" },
+        text: "The support lead.",
+      }),
+    ).toEqual({ answer: "The support lead." });
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.tsx
new file mode 100644
index 00000000000..1e8bed24fc6
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.tsx
@@ -0,0 +1,151 @@
+import { type FormEvent, useId, useState } from "react";
+
+import {
+  ASK_TOOL_NAME,
+  type BrunchAskInput,
+  type BrunchAskOutput,
+  parseBrunchAskInput,
+  parseBrunchAskOutput,
+} from "@hashintel/brunch-agent-transport-aisdk/client-tools";
+import { css } from "@hashintel/ds-helpers/css";
+import {
+  definePetrinautAiInteractiveTool,
+  type PetrinautAiInteractiveToolWidgetProps,
+} from "@hashintel/petrinaut/ui";
+
+import { brunchAskFromComposerText } from "./brunch-ask-mapping";
+
+const containerStyle = css({
+  display: "flex",
+  flexDirection: "column",
+  gap: "2",
+  padding: "3",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "blue.a30",
+  borderRadius: "lg",
+  backgroundColor: "blue.a10",
+});
+
+const questionStyle = css({
+  color: "neutral.s100",
+  fontSize: "sm",
+  fontWeight: "medium",
+  lineHeight: "relaxed",
+});
+
+const formStyle = css({
+  display: "flex",
+  flexDirection: "column",
+  gap: "2",
+});
+
+const labelStyle = css({
+  color: "neutral.s90",
+  fontSize: "xs",
+  fontWeight: "medium",
+});
+
+const textareaStyle = css({
+  width: "full",
+  minHeight: "20",
+  padding: "2",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a30",
+  borderRadius: "md",
+  backgroundColor: "neutral.s00",
+  color: "neutral.s100",
+  fontSize: "sm",
+  resize: "vertical",
+  _focusVisible: {
+    borderColor: "blue.a70",
+    outline: "2px solid",
+    outlineColor: "blue.a30",
+    outlineOffset: "[1px]",
+  },
+});
+
+const submitButtonStyle = css({
+  alignSelf: "flex-end",
+  paddingX: "3",
+  paddingY: "2",
+  borderRadius: "md",
+  backgroundColor: "blue.a85",
+  color: "white",
+  cursor: "pointer",
+  fontSize: "sm",
+  fontWeight: "medium",
+  _hover: {
+    backgroundColor: "blue.a100",
+  },
+  _disabled: {
+    cursor: "not-allowed",
+    opacity: 0.45,
+  },
+});
+
+const answerStyle = css({
+  padding: "2",
+  borderRadius: "md",
+  backgroundColor: "neutral.s00",
+  color: "neutral.s90",
+  fontSize: "sm",
+});
+
+const BrunchAskWidget = ({
+  input,
+  state,
+  submit,
+  submittedOutput,
+}: PetrinautAiInteractiveToolWidgetProps<BrunchAskInput, BrunchAskOutput>) => {
+  const answerId = useId();
+  const [answer, setAnswer] = useState("");
+
+  const onSubmit = (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    const trimmedAnswer = answer.trim();
+    if (!trimmedAnswer) {
+      return;
+    }
+    submit({ answer: trimmedAnswer });
+  };
+
+  return (
+    <section className={containerStyle}>
+      <p className={questionStyle}>{input.question}</p>
+      {state === "submitted" ? (
+        <p className={answerStyle}>{submittedOutput.answer}</p>
+      ) : (
+        <form className={formStyle} onSubmit={onSubmit}>
+          <label className={labelStyle} htmlFor={answerId}>
+            Your answer
+          </label>
+          <textarea
+            className={textareaStyle}
+            id={answerId}
+            onChange={(event) => setAnswer(event.target.value)}
+            placeholder="Write what you know; uncertainty is useful too."
+            rows={3}
+            value={answer}
+          />
+          <button
+            className={submitButtonStyle}
+            disabled={answer.trim().length === 0}
+            type="submit"
+          >
+            Send answer
+          </button>
+        </form>
+      )}
+    </section>
+  );
+};
+
+export const brunchAskInteractiveTool = definePetrinautAiInteractiveTool({
+  toolName: ASK_TOOL_NAME,
+  inputSchema: { parse: parseBrunchAskInput },
+  outputSchema: { parse: parseBrunchAskOutput },
+  fromComposerText: brunchAskFromComposerText,
+  component: BrunchAskWidget,
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-mapping.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-mapping.ts
new file mode 100644
index 00000000000..833f3243c3a
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-mapping.ts
@@ -0,0 +1,11 @@
+import type {
+  BrunchAskInput,
+  BrunchAskOutput,
+} from "@hashintel/brunch-agent-transport-aisdk/client-tools";
+
+export const brunchAskFromComposerText = ({
+  text,
+}: {
+  input: BrunchAskInput;
+  text: string;
+}): BrunchAskOutput => ({ answer: text });
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.test.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.test.ts
new file mode 100644
index 00000000000..b02c248d94a
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  createBrunchPreviewConversationId,
+  resolveBrunchPreviewConfig,
+} from "./brunch-preview-config";
+
+describe("Brunch preview host configuration", () => {
+  test("keeps the local generic chat fallback voice-free", () => {
+    expect(resolveBrunchPreviewConfig(undefined)).toEqual({
+      chatEndpoint: "/api/chat",
+      isBrunchConfigured: false,
+    });
+  });
+
+  test("uses an explicitly configured Brunch transport endpoint", () => {
+    expect(
+      resolveBrunchPreviewConfig("  https://brunch.test/api/petrinaut/chat  "),
+    ).toEqual({
+      chatEndpoint: "https://brunch.test/api/petrinaut/chat",
+      isBrunchConfigured: true,
+    });
+  });
+
+  test("derives a stable preview conversation identity from the saved net", () => {
+    expect(createBrunchPreviewConversationId("net-123")).toBe(
+      "petrinaut-preview:net-123",
+    );
+    expect(createBrunchPreviewConversationId("net-123")).toBe(
+      "petrinaut-preview:net-123",
+    );
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.ts b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.ts
new file mode 100644
index 00000000000..99952d1c4cf
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.ts
@@ -0,0 +1,9 @@
+export const resolveBrunchPreviewConfig = (endpoint: string | undefined) => {
+  const configuredEndpoint = endpoint?.trim();
+  return configuredEndpoint
+    ? { chatEndpoint: configuredEndpoint, isBrunchConfigured: true }
+    : { chatEndpoint: "/api/chat", isBrunchConfigured: false };
+};
+
+export const createBrunchPreviewConversationId = (netId: string): string =>
+  `petrinaut-preview:${netId}`;
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.test.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.test.tsx
new file mode 100644
index 00000000000..619709b1d04
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.test.tsx
@@ -0,0 +1,45 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { isValidElement, type ReactNode } from "react";
+import { describe, expect, test, vi } from "vitest";
+
+import { VoiceInterviewControl } from "../voice-interview/voice-interview-control";
+import { getBrunchVoiceComposerControl } from "./local-storage-demo-app";
+
+vi.mock("@hashintel/petrinaut/ui", () => ({
+  DefaultChatTransport: class {},
+  Petrinaut: () => null,
+  WalkthroughProvider: ({ children }: { children: ReactNode }) => children,
+  definePetrinautAiInteractiveTool: (definition: unknown) => definition,
+}));
+
+describe("local storage demo Brunch voice integration", () => {
+  test("does not install voice on the generic local chat fallback", () => {
+    expect(getBrunchVoiceComposerControl(false)).toBeUndefined();
+  });
+
+  test("installs the app-owned voice control for a configured Brunch transport", () => {
+    const renderControl = getBrunchVoiceComposerControl(true);
+    const control = renderControl?.({
+      conversationId: "petrinaut-preview:net-1",
+      messages: [],
+      status: "ready",
+      stop: vi.fn(async () => undefined),
+      submitText: vi.fn(async () => ({
+        kind: "message" as const,
+        messageId: "message-1",
+      })),
+      submitVoiceInput: vi.fn(async () => ({
+        kind: "message" as const,
+        messageId: "voice-message-1",
+      })),
+    });
+
+    expect(isValidElement(control)).toBe(true);
+    if (!isValidElement(control)) {
+      throw new Error("Expected the configured composer control to render.");
+    }
+    expect(control.type).toBe(VoiceInterviewControl);
+  });
+});
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 faba99f18ca..47715043984 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
@@ -17,13 +17,18 @@ import {
 import {
   DefaultChatTransport,
   Petrinaut,
+  type PetrinautAiComposerControl,
+  type PetrinautAiComposerControlContext,
   type PetrinautAiMessage,
   WalkthroughProvider,
 } from "@hashintel/petrinaut/ui";
 
 import { useSentryFeedbackAction } from "../sentry-feedback-button";
+import { VoiceInterviewControl } from "../voice-interview/voice-interview-control";
+import { brunchAskInteractiveTool } from "./brunch-ask-interactive-tool";
 import { getOrCreateBrunchConversationId } from "./brunch-conversation-id";
 import { createBrunchPanelTransport } from "./brunch-panel-transport";
+import { resolveBrunchPreviewConfig } from "./brunch-preview-config";
 import { getOrCreateBrunchPrincipal } from "./brunch-principal";
 import { useFlueChatHistory } from "./use-flue-chat-history";
 import { useLocalStorageAiMessages } from "./use-local-storage-ai-messages";
@@ -81,6 +86,23 @@ const DEMO_CAPABILITIES = {
   disabledExtensions: [],
 } satisfies PetrinautHandleCapabilities;
 
+const brunchPreviewConfig = resolveBrunchPreviewConfig(
+  import.meta.env.VITE_BRUNCH_CHAT_ENDPOINT,
+);
+
+const renderBrunchVoiceComposerControl = (
+  context: PetrinautAiComposerControlContext,
+) => <VoiceInterviewControl {...context} />;
+
+export const getBrunchVoiceComposerControl = (
+  isBrunchConfigured: boolean,
+): PetrinautAiComposerControl | undefined =>
+  isBrunchConfigured ? renderBrunchVoiceComposerControl : undefined;
+
+const brunchVoiceComposerControl = getBrunchVoiceComposerControl(
+  brunchPreviewConfig.isBrunchConfigured,
+);
+
 const createHandle = (net: SDCPNInLocalStorage): PetrinautDocHandle =>
   createJsonDocHandle({
     id: net.id,
@@ -91,7 +113,7 @@ const createHandle = (net: SDCPNInLocalStorage): PetrinautDocHandle =>
 const brunchPrincipal = getOrCreateBrunchPrincipal();
 
 const stockChatTransport = new DefaultChatTransport({
-  api: "/api/chat",
+  api: brunchPreviewConfig.chatEndpoint,
   headers: () => ({
     [BRUNCH_PRINCIPAL_HEADER]: brunchPrincipal,
   }),
@@ -281,6 +303,8 @@ export const LocalStorageDemoApp = () => {
 
   const aiAssistant = useMemo(
     () => ({
+      ...(conversationId === null ? {} : { conversationId }),
+      interactiveTools: [brunchAskInteractiveTool],
       transport: petrinautAiChatTransport,
       messages: flueHistory.ready
         ? flueHistory.messages
@@ -308,9 +332,15 @@ export const LocalStorageDemoApp = () => {
           return next;
         });
       },
+      ...(brunchVoiceComposerControl
+        ? {
+            renderComposerControl: brunchVoiceComposerControl,
+          }
+        : {}),
     }),
     [
       aiMessagesByNetId,
+      conversationId,
       currentNetId,
       flueHistory.messages,
       flueHistory.ready,
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.test.ts b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.test.ts
new file mode 100644
index 00000000000..322d3beaccb
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.test.ts
@@ -0,0 +1,377 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import {
+  OpenAIRealtimeSession,
+  type OpenAIRealtimeSessionEvent,
+} from "./openai-realtime-session";
+
+class FakeDataChannel extends EventTarget {
+  public readyState: RTCDataChannelState = "connecting";
+
+  public readonly 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: typeof payload === "string" ? payload : JSON.stringify(payload),
+    });
+    this.dispatchEvent(event);
+  }
+}
+
+const createHarness = () => {
+  const channels: FakeDataChannel[] = [];
+  const peers: Array<{
+    addTrack: ReturnType<typeof vi.fn>;
+    close: ReturnType<typeof vi.fn>;
+    connectionState: RTCPeerConnectionState;
+    createDataChannel: ReturnType<typeof vi.fn>;
+    createOffer: ReturnType<typeof vi.fn>;
+    onconnectionstatechange: (() => void) | null;
+    setLocalDescription: ReturnType<typeof vi.fn>;
+    setRemoteDescription: ReturnType<typeof vi.fn<() => Promise<void>>>;
+  }> = [];
+  const tracks: Array<{ enabled: boolean; stop: ReturnType<typeof vi.fn> }> =
+    [];
+  const fetch = vi.fn<typeof globalThis.fetch>(
+    async () =>
+      new Response("v=0\r\no=OpenAI answer", {
+        headers: { "content-type": "application/sdp" },
+      }),
+  );
+  const getUserMedia = vi.fn(async () => {
+    const track = { enabled: true, stop: vi.fn() };
+    tracks.push(track);
+    return {
+      getAudioTracks: () => [track],
+      getTracks: () => [track],
+    } as unknown as MediaStream;
+  });
+  const createPeerConnection = () => {
+    const channel = new FakeDataChannel();
+    channels.push(channel);
+    const peer = {
+      addTrack: vi.fn(),
+      close: vi.fn(),
+      connectionState: "new" as RTCPeerConnectionState,
+      createDataChannel: vi.fn(() => channel),
+      createOffer: vi.fn(async () => ({
+        type: "offer",
+        sdp: "v=0\r\no=browser offer",
+      })),
+      onconnectionstatechange: null as (() => void) | null,
+      setLocalDescription: vi.fn(async () => undefined),
+      setRemoteDescription: vi.fn(async () => {
+        channel.open();
+      }),
+    };
+    peers.push(peer);
+    return peer as unknown as RTCPeerConnection;
+  };
+  const session = new OpenAIRealtimeSession({
+    connectionTimeoutMs: 15_000,
+    createPeerConnection,
+    fetch,
+    getUserMedia,
+  });
+  const events: OpenAIRealtimeSessionEvent[] = [];
+  session.subscribe((event) => events.push(event));
+
+  return { channels, events, fetch, getUserMedia, peers, session, tracks };
+};
+
+describe("OpenAIRealtimeSession", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("negotiates through the app server and starts with the microphone closed", async () => {
+    const harness = createHarness();
+
+    await expect(harness.session.connect()).resolves.toBe(1);
+
+    expect(harness.getUserMedia).toHaveBeenCalledWith({
+      audio: {
+        autoGainControl: true,
+        echoCancellation: true,
+        noiseSuppression: true,
+      },
+    });
+    expect(harness.tracks[0]!.enabled).toBe(false);
+    expect(harness.fetch).toHaveBeenCalledWith(
+      "/api/voice/realtime-call",
+      expect.objectContaining({
+        body: "v=0\r\no=browser offer",
+        headers: { "content-type": "application/sdp" },
+        method: "POST",
+      }),
+    );
+    expect(JSON.stringify(harness.fetch.mock.calls)).not.toContain(
+      "authorization",
+    );
+    expect(harness.peers[0]!.setRemoteDescription).toHaveBeenCalledWith({
+      sdp: "v=0\r\no=OpenAI answer",
+      type: "answer",
+    });
+
+    harness.session.setMicrophoneEnabled(true);
+    expect(harness.tracks[0]!.enabled).toBe(true);
+  });
+
+  test("emits only strict input transcription events with stable source identity", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+    harness.session.setMicrophoneEnabled(true);
+
+    harness.channels[0]!.receive("not-json");
+    harness.channels[0]!.receive({ type: "response.created" });
+    harness.channels[0]!.receive({
+      type: "conversation.item.input_audio_transcription.delta",
+      item_id: "item-a",
+      content_index: "0",
+      delta: "ignored",
+    });
+    harness.channels[0]!.receive({
+      type: "conversation.item.input_audio_transcription.delta",
+      item_id: "item-a",
+      content_index: 0,
+      delta: "The support lead",
+    });
+    harness.channels[0]!.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "item-a",
+      content_index: 0,
+      transcript: "The support lead triages it.",
+    });
+
+    expect(harness.events).toEqual([
+      {
+        key: { connectionEpoch: 1, contentIndex: 0, itemId: "item-a" },
+        text: "The support lead",
+        type: "partial",
+      },
+      {
+        key: { connectionEpoch: 1, contentIndex: 0, itemId: "item-a" },
+        text: "The support lead triages it.",
+        type: "completed",
+      },
+    ]);
+    expect(harness.tracks[0]!.enabled).toBe(false);
+  });
+
+  test("surfaces failed input transcription as a recoverable error", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+
+    harness.channels[0]!.receive({
+      type: "conversation.item.input_audio_transcription.failed",
+      item_id: "item-a",
+      content_index: 0,
+      error: { message: "private provider diagnostic" },
+    });
+
+    expect(harness.events).toEqual([
+      {
+        message: "Voice transcription failed. Try reconnecting.",
+        type: "error",
+      },
+    ]);
+    expect(JSON.stringify(harness.events)).not.toContain(
+      "private provider diagnostic",
+    );
+    expect(harness.tracks[0]!.stop).toHaveBeenCalledOnce();
+    expect(harness.channels[0]!.close).toHaveBeenCalledOnce();
+    expect(harness.peers[0]!.close).toHaveBeenCalledOnce();
+  });
+
+  test("surfaces OpenAI data-channel errors without exposing diagnostics", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+
+    harness.channels[0]!.receive({
+      type: "error",
+      error: { message: "private provider diagnostic" },
+    });
+
+    expect(harness.events).toEqual([
+      {
+        message: "The voice service reported an error. Try reconnecting.",
+        type: "error",
+      },
+    ]);
+    expect(JSON.stringify(harness.events)).not.toContain(
+      "private provider diagnostic",
+    );
+    expect(harness.tracks[0]!.stop).toHaveBeenCalledOnce();
+    expect(harness.channels[0]!.close).toHaveBeenCalledOnce();
+    expect(harness.peers[0]!.close).toHaveBeenCalledOnce();
+  });
+
+  test("closes the microphone when VAD commits an input item", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+    harness.session.setMicrophoneEnabled(true);
+
+    harness.channels[0]!.receive({
+      type: "input_audio_buffer.committed",
+      item_id: "item-a",
+    });
+
+    expect(harness.tracks[0]!.enabled).toBe(false);
+    expect(harness.events).toEqual([
+      { connectionEpoch: 1, itemId: "item-a", type: "input-committed" },
+    ]);
+  });
+
+  test("disposes all WebRTC resources and rejects stale events after reconnect", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+    const firstChannel = harness.channels[0]!;
+
+    await expect(harness.session.connect()).resolves.toBe(2);
+
+    expect(harness.tracks[0]!.stop).toHaveBeenCalledOnce();
+    expect(firstChannel.close).toHaveBeenCalledOnce();
+    expect(harness.peers[0]!.close).toHaveBeenCalledOnce();
+    firstChannel.receive({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "stale-item",
+      content_index: 0,
+      transcript: "Stale transcript",
+    });
+    expect(harness.events).toEqual([]);
+
+    await harness.session.disconnect();
+    expect(harness.tracks[1]!.stop).toHaveBeenCalledOnce();
+    expect(harness.channels[1]!.close).toHaveBeenCalledOnce();
+    expect(harness.peers[1]!.close).toHaveBeenCalledOnce();
+  });
+
+  test("reports microphone permission denial without leaking browser diagnostics", async () => {
+    const harness = createHarness();
+    harness.getUserMedia.mockRejectedValueOnce(
+      new DOMException("private browser detail", "NotAllowedError"),
+    );
+
+    await expect(harness.session.connect()).rejects.toThrow(
+      "Microphone access is required to start voice input.",
+    );
+  });
+
+  test("times out startup and cleans up resources", async () => {
+    vi.useFakeTimers();
+    const harness = createHarness();
+    harness.fetch.mockImplementationOnce(
+      (_input, init) =>
+        new Promise((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () =>
+            reject(new DOMException("aborted", "AbortError")),
+          );
+        }),
+    );
+
+    const connection = expect(harness.session.connect()).rejects.toThrow(
+      "The voice connection timed out. Try reconnecting.",
+    );
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await connection;
+    expect(harness.tracks[0]!.stop).toHaveBeenCalledOnce();
+    expect(harness.channels[0]!.close).toHaveBeenCalledOnce();
+    expect(harness.peers[0]!.close).toHaveBeenCalledOnce();
+  });
+
+  test("times out when abort occurs before waiting for the data channel", async () => {
+    vi.useFakeTimers();
+    const harness = createHarness();
+    let resolveAnswer: ((answer: string) => void) | undefined;
+    harness.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: () =>
+        new Promise<string>((resolve) => {
+          resolveAnswer = resolve;
+        }),
+    } as Response);
+    let settled = false;
+    const connection = harness.session.connect().then(
+      () => new Error("Connection unexpectedly succeeded."),
+      (error: unknown) => {
+        settled = true;
+        return error;
+      },
+    );
+    await vi.waitFor(() => expect(harness.fetch).toHaveBeenCalledOnce());
+    harness.peers[0]!.setRemoteDescription.mockResolvedValueOnce(undefined);
+
+    await vi.advanceTimersByTimeAsync(15_000);
+    resolveAnswer?.("v=0\r\no=late OpenAI answer");
+
+    await vi.waitFor(() => expect(settled).toBe(true));
+    await expect(connection).resolves.toEqual(
+      new Error("The voice connection timed out. Try reconnecting."),
+    );
+  });
+
+  test("times out a stalled permission prompt and stops a late media stream", async () => {
+    vi.useFakeTimers();
+    const harness = createHarness();
+    const lateTrack = { enabled: true, stop: vi.fn() };
+    const lateStream = {
+      getAudioTracks: () => [lateTrack],
+      getTracks: () => [lateTrack],
+    } as unknown as MediaStream;
+    let resolveMedia: ((stream: MediaStream) => void) | undefined;
+    harness.getUserMedia.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveMedia = resolve;
+        }),
+    );
+    let settled = false;
+    const connection = harness.session.connect().then(
+      () => new Error("Connection unexpectedly succeeded."),
+      (error: unknown) => {
+        settled = true;
+        return error;
+      },
+    );
+
+    await vi.advanceTimersByTimeAsync(15_000);
+    const settledAtTimeout = settled;
+    resolveMedia?.(lateStream);
+    const error = await connection;
+
+    expect(settledAtTimeout).toBe(true);
+    expect(error).toEqual(
+      new Error("The voice connection timed out. Try reconnecting."),
+    );
+    expect(lateTrack.stop).toHaveBeenCalledOnce();
+  });
+
+  test("closes the microphone and emits a recoverable connection error", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+    harness.session.setMicrophoneEnabled(true);
+
+    harness.peers[0]!.connectionState = "failed";
+    harness.peers[0]!.onconnectionstatechange?.();
+
+    expect(harness.tracks[0]!.enabled).toBe(false);
+    expect(harness.tracks[0]!.stop).toHaveBeenCalledOnce();
+    expect(harness.channels[0]!.close).toHaveBeenCalledOnce();
+    expect(harness.peers[0]!.close).toHaveBeenCalledOnce();
+    expect(harness.events).toEqual([
+      {
+        message: "The voice connection failed. Try reconnecting.",
+        type: "error",
+      },
+    ]);
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.ts b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.ts
new file mode 100644
index 00000000000..78dfd774469
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.ts
@@ -0,0 +1,409 @@
+export interface OpenAIRealtimeTranscriptKey {
+  readonly connectionEpoch: number;
+  readonly contentIndex: number;
+  readonly itemId: string;
+}
+
+export type OpenAIRealtimeSessionEvent =
+  | {
+      readonly connectionEpoch: number;
+      readonly itemId: string;
+      readonly type: "input-committed";
+    }
+  | {
+      readonly key: OpenAIRealtimeTranscriptKey;
+      readonly text: string;
+      readonly type: "partial" | "completed";
+    }
+  | { readonly message: string; readonly type: "error" };
+
+interface OpenAIRealtimeSessionDependencies {
+  readonly connectionTimeoutMs: number;
+  readonly createPeerConnection: () => RTCPeerConnection;
+  readonly fetch: typeof globalThis.fetch;
+  readonly getUserMedia: (
+    constraints: MediaStreamConstraints,
+  ) => Promise<MediaStream>;
+}
+
+type SessionListener = (event: OpenAIRealtimeSessionEvent) => void;
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null
+    ? (value as Record<string, unknown>)
+    : null;
+
+const parseRealtimeEvent = (value: unknown): Record<string, unknown> | null => {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  try {
+    return asRecord(JSON.parse(value));
+  } catch {
+    return null;
+  }
+};
+
+const stopStream = (stream: MediaStream): void => {
+  for (const track of stream.getTracks()) {
+    track.stop();
+  }
+};
+
+const waitForAbort = <Value>(
+  promise: Promise<Value>,
+  signal: AbortSignal,
+): Promise<Value> => {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+
+  return new Promise((resolve, reject) => {
+    const handleAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", handleAbort, { once: true });
+    void promise.then(
+      (value) => {
+        signal.removeEventListener("abort", handleAbort);
+        resolve(value);
+      },
+      (error: unknown) => {
+        signal.removeEventListener("abort", handleAbort);
+        reject(error);
+      },
+    );
+  });
+};
+
+export class OpenAIRealtimeSession {
+  readonly #dependencies: OpenAIRealtimeSessionDependencies;
+  readonly #listeners = new Set<SessionListener>();
+  #abortController: AbortController | null = null;
+  #activeEpoch: number | null = null;
+  #connected = false;
+  #dataChannel: RTCDataChannel | null = null;
+  #epoch = 0;
+  #mediaStream: MediaStream | null = null;
+  #messageListener: ((event: MessageEvent<unknown>) => void) | null = null;
+  #microphoneTrack: MediaStreamTrack | null = null;
+  #peerConnection: RTCPeerConnection | null = null;
+  #unexpectedCloseListener: (() => void) | null = null;
+
+  public constructor(dependencies: OpenAIRealtimeSessionDependencies) {
+    this.#dependencies = dependencies;
+  }
+
+  public subscribe(listener: SessionListener): () => void {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+
+  public async connect(): Promise<number> {
+    this.#releaseResources();
+
+    const connectionEpoch = ++this.#epoch;
+    this.#activeEpoch = connectionEpoch;
+    const abortController = new AbortController();
+    this.#abortController = abortController;
+    const timeoutError = new DOMException(
+      "Connection timed out",
+      "TimeoutError",
+    );
+    const timeout = globalThis.setTimeout(() => {
+      abortController.abort(timeoutError);
+    }, this.#dependencies.connectionTimeoutMs);
+
+    try {
+      let mediaStream: MediaStream;
+      try {
+        const mediaStreamPromise = this.#dependencies.getUserMedia({
+          audio: {
+            autoGainControl: true,
+            echoCancellation: true,
+            noiseSuppression: true,
+          },
+        });
+        void mediaStreamPromise.then(
+          (lateMediaStream) => {
+            if (this.#activeEpoch !== connectionEpoch) {
+              stopStream(lateMediaStream);
+            }
+          },
+          () => undefined,
+        );
+        mediaStream = await waitForAbort(
+          mediaStreamPromise,
+          abortController.signal,
+        );
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "NotAllowedError") {
+          throw new Error(
+            "Microphone access is required to start voice input.",
+          );
+        }
+        throw error;
+      }
+
+      if (this.#activeEpoch !== connectionEpoch) {
+        stopStream(mediaStream);
+        throw new DOMException("Connection replaced", "AbortError");
+      }
+      this.#mediaStream = mediaStream;
+
+      const [microphoneTrack] = mediaStream.getAudioTracks();
+      if (!microphoneTrack) {
+        throw new Error("No microphone is available for voice input.");
+      }
+      microphoneTrack.enabled = false;
+      this.#microphoneTrack = microphoneTrack;
+
+      const peerConnection = this.#dependencies.createPeerConnection();
+      this.#peerConnection = peerConnection;
+      peerConnection.addTrack(microphoneTrack, mediaStream);
+      peerConnection.onconnectionstatechange = () => {
+        if (
+          this.#activeEpoch === connectionEpoch &&
+          peerConnection.connectionState === "failed"
+        ) {
+          this.#handleConnectionFailure();
+        }
+      };
+
+      const dataChannel = peerConnection.createDataChannel("oai-events");
+      this.#dataChannel = dataChannel;
+      const messageListener = (event: MessageEvent<unknown>) => {
+        if (this.#activeEpoch === connectionEpoch) {
+          this.#handleMessage(event, connectionEpoch);
+        }
+      };
+      const unexpectedCloseListener = () => {
+        if (this.#activeEpoch === connectionEpoch && this.#connected) {
+          this.#handleConnectionFailure();
+        }
+      };
+      this.#messageListener = messageListener;
+      this.#unexpectedCloseListener = unexpectedCloseListener;
+      dataChannel.addEventListener("message", messageListener);
+      dataChannel.addEventListener("close", unexpectedCloseListener);
+
+      const offer = await peerConnection.createOffer();
+      await peerConnection.setLocalDescription(offer);
+      const offerSdp = peerConnection.localDescription?.sdp ?? offer.sdp;
+      if (!offerSdp) {
+        throw new Error("The browser could not create a voice connection.");
+      }
+
+      const response = await this.#dependencies.fetch(
+        "/api/voice/realtime-call",
+        {
+          body: offerSdp,
+          headers: { "content-type": "application/sdp" },
+          method: "POST",
+          signal: abortController.signal,
+        },
+      );
+      if (!response.ok) {
+        throw new Error("The voice connection could not be established.");
+      }
+      const answerSdp = await response.text();
+      if (!answerSdp.trim()) {
+        throw new Error("The voice connection returned an invalid answer.");
+      }
+
+      await peerConnection.setRemoteDescription({
+        sdp: answerSdp,
+        type: "answer",
+      });
+      await this.#waitForDataChannelOpen(dataChannel, abortController.signal);
+      if (this.#activeEpoch !== connectionEpoch) {
+        throw new DOMException("Connection replaced", "AbortError");
+      }
+
+      this.#connected = true;
+      return connectionEpoch;
+    } catch (error) {
+      if (this.#activeEpoch === connectionEpoch) {
+        this.#releaseResources();
+      }
+      if (abortController.signal.reason === timeoutError) {
+        throw new Error("The voice connection timed out. Try reconnecting.");
+      }
+      if (error instanceof Error && !(error instanceof DOMException)) {
+        throw error;
+      }
+      throw new Error("The voice connection could not be established.");
+    } finally {
+      globalThis.clearTimeout(timeout);
+      if (this.#abortController === abortController) {
+        this.#abortController = null;
+      }
+    }
+  }
+
+  public setMicrophoneEnabled(enabled: boolean): void {
+    if (this.#microphoneTrack) {
+      this.#microphoneTrack.enabled = enabled && this.#connected;
+    }
+  }
+
+  public async disconnect(): Promise<void> {
+    this.#releaseResources();
+  }
+
+  #emit(event: OpenAIRealtimeSessionEvent): void {
+    for (const listener of this.#listeners) {
+      listener(event);
+    }
+  }
+
+  #handleConnectionFailure(): void {
+    if (!this.#connected) {
+      return;
+    }
+    this.#releaseResources();
+    this.#emit({
+      message: "The voice connection failed. Try reconnecting.",
+      type: "error",
+    });
+  }
+
+  #handleMessage(event: MessageEvent<unknown>, connectionEpoch: number): void {
+    const parsed = parseRealtimeEvent(event.data);
+    if (!parsed || typeof parsed.type !== "string") {
+      return;
+    }
+
+    if (parsed.type === "input_audio_buffer.committed") {
+      if (typeof parsed.item_id !== "string" || !parsed.item_id) {
+        return;
+      }
+      this.setMicrophoneEnabled(false);
+      this.#emit({
+        connectionEpoch,
+        itemId: parsed.item_id,
+        type: "input-committed",
+      });
+      return;
+    }
+
+    if (parsed.type === "error") {
+      this.#releaseResources();
+      this.#emit({
+        message: "The voice service reported an error. Try reconnecting.",
+        type: "error",
+      });
+      return;
+    }
+
+    if (parsed.type === "conversation.item.input_audio_transcription.failed") {
+      this.#releaseResources();
+      this.#emit({
+        message: "Voice transcription failed. Try reconnecting.",
+        type: "error",
+      });
+      return;
+    }
+
+    const transcriptEventType =
+      parsed.type === "conversation.item.input_audio_transcription.delta"
+        ? "partial"
+        : parsed.type ===
+            "conversation.item.input_audio_transcription.completed"
+          ? "completed"
+          : null;
+    if (
+      transcriptEventType === null ||
+      typeof parsed.item_id !== "string" ||
+      !parsed.item_id ||
+      !Number.isInteger(parsed.content_index) ||
+      (parsed.content_index as number) < 0
+    ) {
+      return;
+    }
+
+    const text =
+      transcriptEventType === "partial" ? parsed.delta : parsed.transcript;
+    if (typeof text !== "string") {
+      return;
+    }
+    if (transcriptEventType === "completed") {
+      this.setMicrophoneEnabled(false);
+    }
+    this.#emit({
+      key: {
+        connectionEpoch,
+        contentIndex: parsed.content_index as number,
+        itemId: parsed.item_id,
+      },
+      text,
+      type: transcriptEventType,
+    });
+  }
+
+  #releaseResources(): void {
+    this.#activeEpoch = null;
+    this.#connected = false;
+    this.#abortController?.abort();
+    this.#abortController = null;
+
+    if (this.#dataChannel && this.#messageListener) {
+      this.#dataChannel.removeEventListener("message", this.#messageListener);
+    }
+    if (this.#dataChannel && this.#unexpectedCloseListener) {
+      this.#dataChannel.removeEventListener(
+        "close",
+        this.#unexpectedCloseListener,
+      );
+    }
+    this.#messageListener = null;
+    this.#unexpectedCloseListener = null;
+    this.#dataChannel?.close();
+    this.#dataChannel = null;
+
+    if (this.#peerConnection) {
+      this.#peerConnection.onconnectionstatechange = null;
+      this.#peerConnection.close();
+      this.#peerConnection = null;
+    }
+    if (this.#mediaStream) {
+      if (this.#microphoneTrack) {
+        this.#microphoneTrack.enabled = false;
+      }
+      stopStream(this.#mediaStream);
+      this.#mediaStream = null;
+    }
+    this.#microphoneTrack = null;
+  }
+
+  #waitForDataChannelOpen(
+    dataChannel: RTCDataChannel,
+    signal: AbortSignal,
+  ): Promise<void> {
+    if (signal.aborted) {
+      return Promise.reject(signal.reason);
+    }
+    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 voice event channel failed to open."));
+        }
+      };
+
+      dataChannel.addEventListener("open", handleResult);
+      dataChannel.addEventListener("error", handleResult);
+      signal.addEventListener("abort", handleResult, { once: true });
+    });
+  }
+}
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.test.tsx b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.test.tsx
new file mode 100644
index 00000000000..106d3ce7857
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.test.tsx
@@ -0,0 +1,179 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { renderToStaticMarkup } from "react-dom/server";
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import {
+  loadOpenAIVoiceConfig,
+  VoiceInterviewControl,
+  VoiceInterviewControlView,
+} from "./voice-interview-control";
+
+describe("voice interview control", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  test("loads only a schema-valid, available server configuration", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(async () =>
+      Response.json({ available: true, connectionTimeoutMs: 15_000 }),
+    );
+
+    await expect(loadOpenAIVoiceConfig(fetch)).resolves.toEqual({
+      available: true,
+      connectionTimeoutMs: 15_000,
+    });
+    const [url, request] = fetch.mock.calls[0]!;
+    expect(url).toBe("/api/voice/config");
+    expect(request).toMatchObject({
+      cache: "no-store",
+      method: "GET",
+    });
+    expect(request?.signal).toBeInstanceOf(AbortSignal);
+
+    fetch.mockResolvedValueOnce(
+      Response.json({ available: false, connectionTimeoutMs: 15_000 }),
+    );
+    await expect(loadOpenAIVoiceConfig(fetch)).resolves.toBeNull();
+    fetch.mockResolvedValueOnce(
+      Response.json({ available: true, connectionTimeoutMs: "15000" }),
+    );
+    await expect(loadOpenAIVoiceConfig(fetch)).resolves.toBeNull();
+  });
+
+  test("renders an accessible idle voice action and live status", () => {
+    const html = renderToStaticMarkup(
+      <VoiceInterviewControlView
+        correction=""
+        onCorrectionChange={vi.fn()}
+        onEnd={vi.fn()}
+        onReconnect={vi.fn()}
+        onStart={vi.fn()}
+        onSubmitCorrection={vi.fn()}
+        snapshot={{
+          errorMessage: "",
+          lastCommittedText: "",
+          partialText: "",
+          phase: "idle",
+        }}
+      />,
+    );
+
+    expect(html).toContain("Start voice input");
+    expect(html).toContain('aria-live="polite"');
+    expect(html).toContain("Voice input is off.");
+  });
+
+  test("labels the half-duplex listening state and keeps partial text visibly provisional", () => {
+    const html = renderToStaticMarkup(
+      <VoiceInterviewControlView
+        correction="The incident manager closes it."
+        onCorrectionChange={vi.fn()}
+        onEnd={vi.fn()}
+        onReconnect={vi.fn()}
+        onStart={vi.fn()}
+        onSubmitCorrection={vi.fn()}
+        snapshot={{
+          errorMessage: "",
+          lastCommittedText: "The support lead closes it.",
+          partialText: "The next activity",
+          phase: "listening",
+        }}
+      />,
+    );
+
+    expect(html).toContain("Microphone on. Listening.");
+    expect(html).toContain("Live transcript (not sent)");
+    expect(html).toContain("The next activity");
+    expect(html).toContain(
+      "Microphone on. Listening. Live transcript (not sent): The next activity",
+    );
+    expect(html).toContain("End voice input");
+    expect(html).toContain("Correct last voice answer");
+    expect(html).toContain("Send correction");
+  });
+
+  test("offers reconnection without reopening the microphone after failure", () => {
+    const html = renderToStaticMarkup(
+      <VoiceInterviewControlView
+        correction=""
+        onCorrectionChange={vi.fn()}
+        onEnd={vi.fn()}
+        onReconnect={vi.fn()}
+        onStart={vi.fn()}
+        onSubmitCorrection={vi.fn()}
+        snapshot={{
+          errorMessage: "Microphone access is required.",
+          lastCommittedText: "",
+          partialText: "",
+          phase: "recoverable-error",
+        }}
+      />,
+    );
+
+    expect(html).toContain("Microphone off. Microphone access is required.");
+    expect(html).toContain("Reconnect voice input");
+  });
+
+  test("remains interactive after Strict Mode replays its effects", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(async () =>
+      Response.json({ available: true, connectionTimeoutMs: 15_000 }),
+    );
+    const getUserMedia = vi.fn(async () => {
+      throw new DOMException("Permission denied", "NotAllowedError");
+    });
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    vi.stubGlobal("fetch", fetch);
+    vi.stubGlobal("navigator", { mediaDevices: { getUserMedia } });
+
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+
+    try {
+      await act(async () => {
+        root.render(
+          <StrictMode>
+            <VoiceInterviewControl
+              conversationId="petrinaut-preview:net-1"
+              messages={[]}
+              status="ready"
+              stop={vi.fn(async () => undefined)}
+              submitText={vi.fn(async () => ({
+                kind: "message" as const,
+                messageId: "message-1",
+              }))}
+              submitVoiceInput={vi.fn(async () => ({
+                kind: "message" as const,
+                messageId: "voice-message-1",
+              }))}
+            />
+          </StrictMode>,
+        );
+      });
+
+      const startButton = container.querySelector<HTMLButtonElement>(
+        'button[aria-label="Start voice input"]',
+      );
+      expect(startButton).not.toBeNull();
+
+      await act(async () => {
+        startButton!.click();
+      });
+
+      expect(getUserMedia).toHaveBeenCalledOnce();
+      expect(container.textContent).toContain(
+        "Microphone access is required to start voice input.",
+      );
+      expect(
+        container.querySelector('button[aria-label="Reconnect voice input"]'),
+      ).not.toBeNull();
+    } finally {
+      await act(async () => root.unmount());
+      container.remove();
+    }
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.tsx b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.tsx
new file mode 100644
index 00000000000..32afc58f1d0
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.tsx
@@ -0,0 +1,390 @@
+import {
+  type FormEvent,
+  useEffect,
+  useLayoutEffect,
+  useState,
+  useSyncExternalStore,
+} from "react";
+import { FaMicrophone, FaMicrophoneSlash } from "react-icons/fa6";
+
+import { Button } from "@hashintel/ds-components";
+import { css } from "@hashintel/ds-helpers/css";
+
+import { OpenAIRealtimeSession } from "./openai-realtime-session";
+import {
+  VoiceTurnController,
+  type VoiceTurnSnapshot,
+} from "./voice-turn-controller";
+
+import type { PetrinautAiComposerControlContext } from "@hashintel/petrinaut/ui";
+
+export interface OpenAIVoiceConfig {
+  readonly available: true;
+  readonly connectionTimeoutMs: number;
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+export const loadOpenAIVoiceConfig = async (
+  fetch: typeof globalThis.fetch,
+  signal: AbortSignal = new AbortController().signal,
+): Promise<OpenAIVoiceConfig | null> => {
+  try {
+    const response = await fetch("/api/voice/config", {
+      cache: "no-store",
+      method: "GET",
+      signal,
+    });
+    if (!response.ok) {
+      return null;
+    }
+
+    const body: unknown = await response.json();
+    if (
+      !isRecord(body) ||
+      body.available !== true ||
+      !Number.isInteger(body.connectionTimeoutMs) ||
+      (body.connectionTimeoutMs as number) < 1_000 ||
+      (body.connectionTimeoutMs as number) > 60_000
+    ) {
+      return null;
+    }
+    return {
+      available: true,
+      connectionTimeoutMs: body.connectionTimeoutMs as number,
+    };
+  } catch {
+    return null;
+  }
+};
+
+const controlStyle = css({
+  position: "relative",
+  flexShrink: "0",
+});
+
+const panelStyle = css({
+  position: "absolute",
+  right: "0",
+  bottom: "[calc(100% + 8px)]",
+  zIndex: "overlay",
+  display: "flex",
+  width: "[280px]",
+  flexDirection: "column",
+  gap: "2",
+  padding: "3",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "lg",
+  backgroundColor: "neutral.s00",
+  boxShadow: "lg",
+});
+
+const statusStyle = css({
+  color: "neutral.s90",
+  fontSize: "xs",
+  fontWeight: "medium",
+  lineHeight: "relaxed",
+});
+
+const liveRegionStyle = css({
+  position: "absolute",
+  width: "[1px]",
+  height: "[1px]",
+  padding: "0",
+  margin: "[-1px]",
+  overflow: "hidden",
+  clip: "[rect(0, 0, 0, 0)]",
+  whiteSpace: "nowrap",
+  borderWidth: "0",
+});
+
+const partialStyle = css({
+  display: "flex",
+  flexDirection: "column",
+  gap: "1",
+  padding: "2",
+  borderRadius: "md",
+  backgroundColor: "neutral.s10",
+  color: "neutral.s100",
+  fontSize: "sm",
+});
+
+const partialLabelStyle = css({
+  color: "neutral.s80",
+  fontSize: "xs",
+});
+
+const correctionFormStyle = css({
+  display: "flex",
+  flexDirection: "column",
+  gap: "2",
+});
+
+const correctionInputStyle = css({
+  width: "full",
+  paddingX: "2",
+  paddingY: "1.5",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a30",
+  borderRadius: "md",
+  backgroundColor: "neutral.s00",
+  color: "neutral.s100",
+  fontSize: "sm",
+  _focusVisible: {
+    borderColor: "blue.a70",
+    outline: "2px solid",
+    outlineColor: "blue.a30",
+    outlineOffset: "[1px]",
+  },
+});
+
+const panelActionsStyle = css({
+  display: "flex",
+  justifyContent: "flex-end",
+  gap: "2",
+});
+
+const statusText = (snapshot: VoiceTurnSnapshot): string => {
+  switch (snapshot.phase) {
+    case "idle":
+      return "Voice input is off.";
+    case "connecting":
+      return "Microphone off. Connecting voice input.";
+    case "listening":
+      return "Microphone on. Listening.";
+    case "transcribing":
+      return "Microphone off. Finalizing the transcript.";
+    case "delivering":
+      return "Microphone off. Sending the finalized transcript to Brunch.";
+    case "waiting":
+      return "Microphone off. Waiting for Brunch.";
+    case "recoverable-error":
+      return `Microphone off. ${snapshot.errorMessage}`;
+  }
+};
+
+interface VoiceInterviewControlViewProps {
+  readonly correction: string;
+  readonly onCorrectionChange: (value: string) => void;
+  readonly onEnd: () => void;
+  readonly onReconnect: () => void;
+  readonly onStart: () => void;
+  readonly onSubmitCorrection: () => void;
+  readonly snapshot: VoiceTurnSnapshot;
+}
+
+export const VoiceInterviewControlView = ({
+  correction,
+  onCorrectionChange,
+  onEnd,
+  onReconnect,
+  onStart,
+  onSubmitCorrection,
+  snapshot,
+}: VoiceInterviewControlViewProps) => {
+  const isIdle = snapshot.phase === "idle";
+  const isConnecting = snapshot.phase === "connecting";
+  const hasError = snapshot.phase === "recoverable-error";
+  const canCorrect =
+    snapshot.phase === "listening" && snapshot.lastCommittedText.length > 0;
+
+  const submitCorrection = (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    onSubmitCorrection();
+  };
+
+  return (
+    <div className={controlStyle}>
+      {isIdle ? (
+        <Button
+          aria-label="Start voice input"
+          prefix={<FaMicrophone aria-hidden="true" />}
+          shape="round"
+          size="sm"
+          tooltip="Start voice input"
+          type="button"
+          variant="subtle"
+          onClick={onStart}
+        />
+      ) : (
+        <Button
+          aria-label={hasError ? "Reconnect voice input" : "End voice input"}
+          disabled={isConnecting}
+          prefix={<FaMicrophoneSlash aria-hidden="true" />}
+          shape="round"
+          size="sm"
+          tooltip={hasError ? "Reconnect voice input" : "End voice input"}
+          type="button"
+          variant="subtle"
+          onClick={hasError ? onReconnect : onEnd}
+        />
+      )}
+
+      <span
+        className={liveRegionStyle}
+        role="status"
+        aria-atomic="true"
+        aria-live="polite"
+      >
+        {statusText(snapshot)}
+        {snapshot.partialText &&
+          ` Live transcript (not sent): ${snapshot.partialText}`}
+      </span>
+
+      {!isIdle && (
+        <section className={panelStyle} aria-label="Voice input status">
+          <p className={statusStyle}>{statusText(snapshot)}</p>
+          {snapshot.partialText && (
+            <p className={partialStyle}>
+              <span className={partialLabelStyle}>
+                Live transcript (not sent)
+              </span>
+              {snapshot.partialText}
+            </p>
+          )}
+          {canCorrect && (
+            <form className={correctionFormStyle} onSubmit={submitCorrection}>
+              <label className={partialLabelStyle} htmlFor="voice-correction">
+                Correct last voice answer
+              </label>
+              <input
+                className={correctionInputStyle}
+                id="voice-correction"
+                onChange={(event) => onCorrectionChange(event.target.value)}
+                placeholder="Enter the corrected answer"
+                value={correction}
+              />
+              <Button
+                disabled={!correction.trim()}
+                size="xs"
+                type="submit"
+                variant="subtle"
+              >
+                Send correction
+              </Button>
+            </form>
+          )}
+          <div className={panelActionsStyle}>
+            {hasError ? (
+              <Button
+                size="xs"
+                type="button"
+                variant="subtle"
+                onClick={onReconnect}
+              >
+                Reconnect voice input
+              </Button>
+            ) : (
+              <Button
+                disabled={isConnecting}
+                size="xs"
+                type="button"
+                variant="subtle"
+                onClick={onEnd}
+              >
+                End voice input
+              </Button>
+            )}
+          </div>
+        </section>
+      )}
+    </div>
+  );
+};
+
+const AvailableVoiceInterviewControl = ({
+  config,
+  context,
+}: {
+  config: OpenAIVoiceConfig;
+  context: PetrinautAiComposerControlContext & { conversationId: string };
+}) => {
+  const [store] = useState(() => {
+    const session = new OpenAIRealtimeSession({
+      connectionTimeoutMs: config.connectionTimeoutMs,
+      createPeerConnection: () => new RTCPeerConnection(),
+      fetch: globalThis.fetch.bind(globalThis),
+      getUserMedia: (constraints) =>
+        navigator.mediaDevices.getUserMedia(constraints),
+    });
+    const controller = new VoiceTurnController({
+      conversationId: context.conversationId,
+      session,
+      submitText: context.submitVoiceInput,
+    });
+    return {
+      controller,
+      getSnapshot: () => controller.getSnapshot(),
+      subscribe: (listener: (snapshot: VoiceTurnSnapshot) => void) =>
+        controller.subscribe(listener),
+    };
+  });
+  const snapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot,
+  );
+  const [correction, setCorrection] = useState("");
+
+  useLayoutEffect(() => {
+    store.controller.updateChatStatus(context.status);
+  }, [context.status, store]);
+
+  useEffect(
+    () => () => {
+      void store.controller.end();
+    },
+    [store],
+  );
+
+  return (
+    <VoiceInterviewControlView
+      correction={correction}
+      onCorrectionChange={setCorrection}
+      onEnd={() => void store.controller.end()}
+      onReconnect={() => void store.controller.reconnect()}
+      onStart={() => void store.controller.start()}
+      onSubmitCorrection={() => {
+        const value = correction;
+        setCorrection("");
+        void store.controller.submitCorrection(value);
+      }}
+      snapshot={snapshot}
+    />
+  );
+};
+
+export const VoiceInterviewControl = (
+  context: PetrinautAiComposerControlContext,
+) => {
+  const [config, setConfig] = useState<OpenAIVoiceConfig | null>();
+
+  useEffect(() => {
+    const abortController = new AbortController();
+    void loadOpenAIVoiceConfig(
+      globalThis.fetch.bind(globalThis),
+      abortController.signal,
+    ).then((loadedConfig) => {
+      if (!abortController.signal.aborted) {
+        setConfig(loadedConfig);
+      }
+    });
+    return () => abortController.abort();
+  }, []);
+
+  if (!config || !context.conversationId) {
+    return null;
+  }
+
+  return (
+    <AvailableVoiceInterviewControl
+      key={context.conversationId}
+      config={config}
+      context={{ ...context, conversationId: context.conversationId }}
+    />
+  );
+};
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.test.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.test.ts
new file mode 100644
index 00000000000..4f1384d530b
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.test.ts
@@ -0,0 +1,543 @@
+import { describe, expect, test, vi } from "vitest";
+
+import {
+  createVoiceMessageId,
+  VoiceTurnController,
+} from "./voice-turn-controller";
+
+import type { OpenAIRealtimeSessionEvent } from "./openai-realtime-session";
+
+const createHarness = () => {
+  let epoch = 0;
+  let listener: ((event: OpenAIRealtimeSessionEvent) => void) | undefined;
+  const session = {
+    connect: vi.fn(async () => ++epoch),
+    disconnect: vi.fn(async () => undefined),
+    setMicrophoneEnabled: vi.fn(),
+    subscribe: vi.fn((next: (event: OpenAIRealtimeSessionEvent) => void) => {
+      listener = next;
+      return () => {
+        listener = undefined;
+      };
+    }),
+  };
+  const submitText = vi.fn(async () => ({ kind: "message" as const }));
+  const controller = new VoiceTurnController({
+    conversationId: "preview/net 1",
+    session,
+    submitText,
+  });
+
+  return {
+    controller,
+    emit: (event: OpenAIRealtimeSessionEvent) => listener?.(event),
+    session,
+    submitText,
+  };
+};
+
+const key = (connectionEpoch: number, itemId: string, contentIndex = 0) => ({
+  connectionEpoch,
+  contentIndex,
+  itemId,
+});
+
+describe("VoiceTurnController", () => {
+  test("refuses to open the microphone while Brunch is busy", async () => {
+    const harness = createHarness();
+    harness.controller.updateChatStatus("streaming");
+
+    await harness.controller.start();
+
+    expect(harness.session.connect).not.toHaveBeenCalled();
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      errorMessage: "Wait for Brunch to finish before starting voice input.",
+      phase: "recoverable-error",
+    });
+  });
+
+  test("keeps the microphone closed if Brunch becomes busy while connecting", async () => {
+    const harness = createHarness();
+
+    const starting = harness.controller.start();
+    harness.controller.updateChatStatus("streaming");
+    await starting;
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot().phase).toBe("waiting");
+
+    harness.controller.updateChatStatus("ready");
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+  });
+
+  test("pauses an open microphone for a non-voice Brunch turn", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.controller.updateChatStatus("submitted");
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot().phase).toBe("waiting");
+
+    harness.controller.updateChatStatus("ready");
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+  });
+
+  test("does not start a second connection from a non-idle transition", async () => {
+    const harness = createHarness();
+
+    await harness.controller.start();
+    await harness.controller.start();
+
+    expect(harness.session.connect).toHaveBeenCalledOnce();
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+  });
+
+  test("submits one completed transcript through the composer and keeps partials display-only", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "The ",
+      type: "partial",
+    });
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "support",
+      type: "partial",
+    });
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      partialText: "The support",
+      phase: "transcribing",
+    });
+    expect(harness.submitText).not.toHaveBeenCalled();
+
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "The support lead triages it.",
+      type: "completed",
+    });
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+
+    expect(harness.submitText).toHaveBeenCalledWith({
+      id: createVoiceMessageId("preview/net 1", key(1, "item-a")),
+      text: "The support lead triages it.",
+    });
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      lastCommittedText: "The support lead triages it.",
+      partialText: "",
+      phase: "waiting",
+    });
+
+    harness.controller.updateChatStatus("ready");
+    expect(harness.controller.getSnapshot().phase).toBe("waiting");
+    harness.controller.updateChatStatus("streaming");
+    harness.controller.updateChatStatus("ready");
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+  });
+
+  test("queues a late finalized transcript until Brunch is ready", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.controller.updateChatStatus("streaming");
+    expect(harness.controller.getSnapshot().phase).toBe("waiting");
+
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "late-item",
+      type: "input-committed",
+    });
+    harness.emit({
+      key: key(1, "late-item"),
+      text: "The support lead triages it.",
+      type: "completed",
+    });
+
+    expect(harness.submitText).not.toHaveBeenCalled();
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      lastCommittedText: "The support lead triages it.",
+      partialText: "",
+      phase: "waiting",
+    });
+
+    harness.controller.updateChatStatus("ready");
+
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    expect(harness.submitText).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "The support lead triages it." }),
+    );
+  });
+
+  test("preserves the first pending transcript while Brunch is busy", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.controller.updateChatStatus("streaming");
+
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "first-item",
+      type: "input-committed",
+    });
+    harness.emit({
+      key: key(1, "first-item"),
+      text: "The support lead triages it.",
+      type: "completed",
+    });
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "second-item",
+      type: "input-committed",
+    });
+    harness.emit({
+      key: key(1, "second-item"),
+      text: "The incident manager closes it.",
+      type: "completed",
+    });
+
+    harness.controller.updateChatStatus("ready");
+
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    expect(harness.submitText).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "The support lead triages it." }),
+    );
+    expect(harness.controller.getSnapshot().lastCommittedText).toBe(
+      "The support lead triages it.",
+    );
+  });
+
+  test("retries a finalized transcript rejected by a concurrent Brunch turn", async () => {
+    const harness = createHarness();
+    harness.submitText.mockImplementationOnce(async () => {
+      harness.controller.updateChatStatus("streaming");
+      throw new Error("Brunch became busy");
+    });
+    await harness.controller.start();
+
+    harness.emit({
+      key: key(1, "racing-item"),
+      text: "The incident manager owns it.",
+      type: "completed",
+    });
+
+    await vi.waitFor(() =>
+      expect(harness.controller.getSnapshot().phase).toBe("waiting"),
+    );
+    expect(harness.controller.getSnapshot().errorMessage).toBe("");
+
+    harness.controller.updateChatStatus("ready");
+
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledTimes(2));
+    expect(harness.submitText).toHaveBeenLastCalledWith(
+      expect.objectContaining({ text: "The incident manager owns it." }),
+    );
+  });
+
+  test("closes the microphone when a partial transcript arrives", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "The support",
+      type: "partial",
+    });
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot().phase).toBe("transcribing");
+  });
+
+  test("ignores duplicate, stale, and out-of-order completed items", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.emit({
+      key: key(2, "stale"),
+      text: "Stale",
+      type: "completed",
+    });
+    harness.emit({ key: key(1, "item-a"), text: "First", type: "partial" });
+    harness.emit({
+      key: key(1, "item-b"),
+      text: "Out of order",
+      type: "completed",
+    });
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "Accepted final",
+      type: "completed",
+    });
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "Duplicate final",
+      type: "completed",
+    });
+
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    expect(harness.submitText).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "Accepted final" }),
+    );
+  });
+
+  test("does not let a late duplicate block the next listening turn", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "First final",
+      type: "completed",
+    });
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    harness.controller.updateChatStatus("streaming");
+    harness.controller.updateChatStatus("ready");
+
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "Late duplicate",
+      type: "completed",
+    });
+    harness.emit({
+      key: key(1, "item-b"),
+      text: "Second final",
+      type: "completed",
+    });
+
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledTimes(2));
+    expect(harness.submitText).toHaveBeenLastCalledWith(
+      expect.objectContaining({ text: "Second final" }),
+    );
+  });
+
+  test("closes the listening window when VAD commits an item", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "item-a",
+      type: "input-committed",
+    });
+
+    expect(harness.controller.getSnapshot().phase).toBe("transcribing");
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+  });
+
+  test("reopens listening after an empty completed transcript", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "empty-item",
+      type: "input-committed",
+    });
+
+    harness.emit({
+      key: key(1, "empty-item"),
+      text: "   ",
+      type: "completed",
+    });
+
+    expect(harness.submitText).not.toHaveBeenCalled();
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      partialText: "",
+      phase: "listening",
+    });
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+  });
+
+  test("keeps the microphone closed when Brunch becomes busy before an empty transcript completes", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({
+      connectionEpoch: 1,
+      itemId: "empty-item",
+      type: "input-committed",
+    });
+    harness.controller.updateChatStatus("streaming");
+
+    harness.emit({
+      key: key(1, "empty-item"),
+      text: "   ",
+      type: "completed",
+    });
+
+    expect(harness.submitText).not.toHaveBeenCalled();
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot().phase).toBe("waiting");
+
+    harness.controller.updateChatStatus("ready");
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+  });
+
+  test("rejects events from a stopped epoch after reconnect", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({ key: key(1, "old"), text: "Old", type: "partial" });
+
+    await harness.controller.end();
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      partialText: "",
+      phase: "idle",
+    });
+    await harness.controller.start();
+    harness.emit({
+      key: key(1, "old"),
+      text: "Stale final",
+      type: "completed",
+    });
+
+    expect(harness.submitText).not.toHaveBeenCalled();
+    expect(harness.controller.getSnapshot().phase).toBe("listening");
+    expect(harness.session.connect).toHaveBeenCalledTimes(2);
+    expect(harness.session.disconnect).toHaveBeenCalledOnce();
+  });
+
+  test("discards a partial when voice ends before completion", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({
+      key: key(1, "unfinished"),
+      text: "Not finalized",
+      type: "partial",
+    });
+
+    await harness.controller.end();
+    harness.emit({
+      key: key(1, "unfinished"),
+      text: "Late final",
+      type: "completed",
+    });
+
+    expect(harness.submitText).not.toHaveBeenCalled();
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      partialText: "",
+      phase: "idle",
+    });
+  });
+
+  test("does not retract a finalized turn when voice ends during delivery", async () => {
+    const harness = createHarness();
+    let finishDelivery: (() => void) | undefined;
+    harness.submitText.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finishDelivery = () => resolve({ kind: "message" as const });
+        }),
+    );
+    await harness.controller.start();
+
+    harness.emit({
+      key: key(1, "accepted"),
+      text: "Accepted final",
+      type: "completed",
+    });
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    await harness.controller.end();
+    finishDelivery?.();
+    await Promise.resolve();
+
+    expect(harness.submitText).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "Accepted final" }),
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      lastCommittedText: "Accepted final",
+      phase: "idle",
+    });
+  });
+
+  test("keeps the microphone closed and exposes recoverable failures", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+
+    harness.emit({
+      message: "The voice connection failed. Try reconnecting.",
+      type: "error",
+    });
+
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      errorMessage: "The voice connection failed. Try reconnecting.",
+      phase: "recoverable-error",
+    });
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+  });
+
+  test("does not let a late delivery overwrite a connection failure", async () => {
+    const harness = createHarness();
+    let finishDelivery: (() => void) | undefined;
+    harness.submitText.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finishDelivery = () => resolve({ kind: "message" as const });
+        }),
+    );
+    await harness.controller.start();
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "The support lead triages it.",
+      type: "completed",
+    });
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+
+    harness.emit({
+      message: "The voice connection failed. Try reconnecting.",
+      type: "error",
+    });
+    finishDelivery?.();
+    await Promise.resolve();
+
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      errorMessage: "The voice connection failed. Try reconnecting.",
+      phase: "recoverable-error",
+    });
+  });
+
+  test("submits corrections as new explicit text turns", async () => {
+    const harness = createHarness();
+    await harness.controller.start();
+    harness.emit({
+      key: key(1, "item-a"),
+      text: "The support lead closes it.",
+      type: "completed",
+    });
+    await vi.waitFor(() => expect(harness.submitText).toHaveBeenCalledOnce());
+    harness.controller.updateChatStatus("streaming");
+    harness.controller.updateChatStatus("ready");
+
+    await harness.controller.submitCorrection(
+      "The incident manager closes it.",
+    );
+
+    expect(harness.submitText).toHaveBeenCalledTimes(2);
+    expect(harness.submitText).toHaveBeenLastCalledWith({
+      target: "message",
+      text: 'Correction to my previous voice answer "The support lead closes it.": The incident manager closes it.',
+    });
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+  });
+});
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.ts
new file mode 100644
index 00000000000..adffa720b0c
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.ts
@@ -0,0 +1,409 @@
+import type {
+  OpenAIRealtimeSessionEvent,
+  OpenAIRealtimeTranscriptKey,
+} from "./openai-realtime-session";
+
+export type VoiceTurnPhase =
+  | "idle"
+  | "connecting"
+  | "listening"
+  | "transcribing"
+  | "delivering"
+  | "waiting"
+  | "recoverable-error";
+
+export interface VoiceTurnSnapshot {
+  readonly errorMessage: string;
+  readonly lastCommittedText: string;
+  readonly partialText: string;
+  readonly phase: VoiceTurnPhase;
+}
+
+type ChatStatus = "ready" | "submitted" | "streaming" | "error";
+
+interface RealtimeSession {
+  connect(): Promise<number>;
+  disconnect(): Promise<void>;
+  setMicrophoneEnabled(enabled: boolean): void;
+  subscribe(listener: (event: OpenAIRealtimeSessionEvent) => void): () => void;
+}
+
+interface SubmitTextInput {
+  readonly id?: string;
+  readonly target?: "auto" | "message";
+  readonly text: string;
+}
+
+interface VoiceTurnControllerDependencies {
+  readonly conversationId: string;
+  readonly session: RealtimeSession;
+  readonly submitText: (input: SubmitTextInput) => Promise<unknown>;
+}
+
+type SnapshotListener = (snapshot: VoiceTurnSnapshot) => void;
+
+const transcriptKey = (key: OpenAIRealtimeTranscriptKey): string =>
+  `${key.connectionEpoch}:${key.itemId}:${key.contentIndex}`;
+
+export const createVoiceMessageId = (
+  conversationId: string,
+  key: OpenAIRealtimeTranscriptKey,
+): string =>
+  [
+    "voice",
+    encodeURIComponent(conversationId),
+    key.connectionEpoch,
+    encodeURIComponent(key.itemId),
+    key.contentIndex,
+  ].join(":");
+
+const initialSnapshot: VoiceTurnSnapshot = {
+  errorMessage: "",
+  lastCommittedText: "",
+  partialText: "",
+  phase: "idle",
+};
+
+export class VoiceTurnController {
+  readonly #conversationId: string;
+  readonly #listeners = new Set<SnapshotListener>();
+  readonly #session: RealtimeSession;
+  readonly #submitText: (input: SubmitTextInput) => Promise<unknown>;
+  readonly #completedKeys = new Set<string>();
+  #activeEpoch: number | null = null;
+  #activeItemId: string | null = null;
+  #activeKey: string | null = null;
+  #awaitingChatCycle = false;
+  #chatStatus: ChatStatus = "ready";
+  #generation = 0;
+  #pendingDelivery: SubmitTextInput | null = null;
+  #sawBusyChatStatus = false;
+  #snapshot = initialSnapshot;
+
+  public constructor({
+    conversationId,
+    session,
+    submitText,
+  }: VoiceTurnControllerDependencies) {
+    this.#conversationId = conversationId;
+    this.#session = session;
+    this.#submitText = submitText;
+    session.subscribe((event) => this.#handleSessionEvent(event));
+  }
+
+  public getSnapshot(): VoiceTurnSnapshot {
+    return this.#snapshot;
+  }
+
+  public subscribe(listener: SnapshotListener): () => void {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+
+  public async start(): Promise<void> {
+    if (this.#snapshot.phase !== "idle") {
+      return;
+    }
+    if (!this.#isChatReady()) {
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({
+        errorMessage: "Wait for Brunch to finish before starting voice input.",
+        phase: "recoverable-error",
+      });
+      return;
+    }
+
+    const generation = ++this.#generation;
+    this.#update({ errorMessage: "", phase: "connecting" });
+    try {
+      const connectionEpoch = await this.#session.connect();
+      if (generation !== this.#generation) {
+        return;
+      }
+      this.#activeEpoch = connectionEpoch;
+      this.#activeItemId = null;
+      this.#activeKey = null;
+      this.#completedKeys.clear();
+      const canListen = this.#isChatReady();
+      this.#session.setMicrophoneEnabled(canListen);
+      this.#update({
+        partialText: "",
+        phase: canListen ? "listening" : "waiting",
+      });
+    } catch (error) {
+      if (generation !== this.#generation) {
+        return;
+      }
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({
+        errorMessage:
+          error instanceof Error
+            ? error.message
+            : "Voice input could not be started. Try reconnecting.",
+        phase: "recoverable-error",
+      });
+    }
+  }
+
+  public async end(): Promise<void> {
+    ++this.#generation;
+    this.#activeEpoch = null;
+    this.#activeItemId = null;
+    this.#activeKey = null;
+    this.#awaitingChatCycle = false;
+    this.#pendingDelivery = null;
+    this.#sawBusyChatStatus = false;
+    this.#session.setMicrophoneEnabled(false);
+    await this.#session.disconnect();
+    this.#update({
+      errorMessage: "",
+      partialText: "",
+      phase: "idle",
+    });
+  }
+
+  public async reconnect(): Promise<void> {
+    await this.end();
+    await this.start();
+  }
+
+  public async submitCorrection(correction: string): Promise<void> {
+    const correctedText = correction.trim();
+    const previousText = this.#snapshot.lastCommittedText;
+    if (
+      !correctedText ||
+      !previousText ||
+      this.#snapshot.phase !== "listening"
+    ) {
+      return;
+    }
+
+    this.#session.setMicrophoneEnabled(false);
+    this.#update({ errorMessage: "", phase: "delivering" });
+    await this.#deliver({
+      target: "message",
+      text: `Correction to my previous voice answer "${previousText}": ${correctedText}`,
+    });
+  }
+
+  public updateChatStatus(status: ChatStatus): void {
+    this.#chatStatus = status;
+    if (!this.#awaitingChatCycle) {
+      if (status === "ready" && this.#pendingDelivery !== null) {
+        const pendingDelivery = this.#pendingDelivery;
+        this.#pendingDelivery = null;
+        this.#session.setMicrophoneEnabled(false);
+        this.#update({ errorMessage: "", phase: "delivering" });
+        void this.#deliver(pendingDelivery);
+        return;
+      }
+      if (
+        (status === "submitted" || status === "streaming") &&
+        (this.#snapshot.phase === "listening" ||
+          this.#snapshot.phase === "transcribing")
+      ) {
+        this.#session.setMicrophoneEnabled(false);
+        this.#update({ phase: "waiting" });
+      } else if (
+        status === "ready" &&
+        this.#activeEpoch !== null &&
+        this.#snapshot.phase === "waiting"
+      ) {
+        this.#session.setMicrophoneEnabled(true);
+        this.#update({ errorMessage: "", phase: "listening" });
+      } else if (status === "error" && this.#snapshot.phase === "waiting") {
+        this.#session.setMicrophoneEnabled(false);
+        this.#update({
+          errorMessage:
+            "Brunch could not complete the current turn. Use the composer to retry.",
+          phase: "recoverable-error",
+        });
+      }
+      return;
+    }
+
+    if (status === "submitted" || status === "streaming") {
+      this.#sawBusyChatStatus = true;
+      this.#update({ phase: "waiting" });
+      return;
+    }
+    if (status === "error") {
+      this.#awaitingChatCycle = false;
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({
+        errorMessage:
+          "Brunch could not accept the voice turn. Use the composer to retry.",
+        phase: "recoverable-error",
+      });
+      return;
+    }
+    this.#reopenListeningIfReady();
+  }
+
+  async #deliver(input: SubmitTextInput): Promise<void> {
+    if (!this.#isChatReady()) {
+      this.#pendingDelivery = input;
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({ phase: "waiting" });
+      return;
+    }
+
+    const generation = this.#generation;
+    this.#awaitingChatCycle = true;
+    this.#sawBusyChatStatus = false;
+    try {
+      await this.#submitText(input);
+      if (
+        generation !== this.#generation ||
+        !this.#isAwaitingCurrentChatCycle()
+      ) {
+        return;
+      }
+      this.#update({ phase: "waiting" });
+      this.#reopenListeningIfReady();
+    } catch {
+      if (generation !== this.#generation) {
+        return;
+      }
+      if (!this.#isChatReady()) {
+        this.#pendingDelivery = input;
+        this.#awaitingChatCycle = false;
+        this.#session.setMicrophoneEnabled(false);
+        this.#update({ phase: "waiting" });
+        return;
+      }
+      this.#awaitingChatCycle = false;
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({
+        errorMessage:
+          "Brunch could not accept the voice turn. Use the composer to retry.",
+        phase: "recoverable-error",
+      });
+    }
+  }
+
+  #isAwaitingCurrentChatCycle(): boolean {
+    return this.#awaitingChatCycle;
+  }
+
+  #isChatReady(): boolean {
+    return this.#chatStatus === "ready";
+  }
+
+  #handleSessionEvent(event: OpenAIRealtimeSessionEvent): void {
+    if (event.type === "error") {
+      ++this.#generation;
+      this.#activeEpoch = null;
+      this.#activeItemId = null;
+      this.#activeKey = null;
+      this.#awaitingChatCycle = false;
+      this.#pendingDelivery = null;
+      this.#sawBusyChatStatus = false;
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({ errorMessage: event.message, phase: "recoverable-error" });
+      return;
+    }
+    if (this.#pendingDelivery !== null) {
+      return;
+    }
+    if (event.type === "input-committed") {
+      if (
+        event.connectionEpoch !== this.#activeEpoch ||
+        (this.#activeItemId !== null && this.#activeItemId !== event.itemId) ||
+        (this.#snapshot.phase !== "listening" &&
+          this.#snapshot.phase !== "transcribing" &&
+          this.#snapshot.phase !== "waiting")
+      ) {
+        return;
+      }
+      this.#activeItemId = event.itemId;
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({ phase: "transcribing" });
+      return;
+    }
+
+    if (
+      event.key.connectionEpoch !== this.#activeEpoch ||
+      (this.#snapshot.phase !== "listening" &&
+        this.#snapshot.phase !== "transcribing" &&
+        this.#snapshot.phase !== "waiting")
+    ) {
+      return;
+    }
+    const key = transcriptKey(event.key);
+    if (this.#completedKeys.has(key)) {
+      return;
+    }
+    if (
+      (this.#activeItemId !== null &&
+        this.#activeItemId !== event.key.itemId) ||
+      (this.#activeKey !== null && this.#activeKey !== key)
+    ) {
+      return;
+    }
+    this.#activeItemId = event.key.itemId;
+    this.#activeKey = key;
+
+    if (event.type === "partial") {
+      this.#session.setMicrophoneEnabled(false);
+      this.#update({
+        partialText: `${this.#snapshot.partialText}${event.text}`,
+        phase: "transcribing",
+      });
+      return;
+    }
+    this.#completedKeys.add(key);
+
+    const finalText = event.text.trim();
+    this.#activeItemId = null;
+    this.#activeKey = null;
+    if (!finalText) {
+      const canListen = this.#isChatReady();
+      this.#session.setMicrophoneEnabled(canListen);
+      this.#update({
+        partialText: "",
+        phase: canListen ? "listening" : "waiting",
+      });
+      return;
+    }
+
+    this.#session.setMicrophoneEnabled(false);
+    const input = {
+      id: createVoiceMessageId(this.#conversationId, event.key),
+      text: finalText,
+    };
+    const canDeliver = this.#isChatReady();
+    this.#update({
+      errorMessage: "",
+      lastCommittedText: finalText,
+      partialText: "",
+      phase: canDeliver ? "delivering" : "waiting",
+    });
+    if (canDeliver) {
+      void this.#deliver(input);
+    } else {
+      this.#pendingDelivery = input;
+    }
+  }
+
+  #reopenListeningIfReady(): void {
+    if (
+      !this.#awaitingChatCycle ||
+      !this.#sawBusyChatStatus ||
+      this.#chatStatus !== "ready"
+    ) {
+      return;
+    }
+    this.#awaitingChatCycle = false;
+    this.#sawBusyChatStatus = false;
+    this.#session.setMicrophoneEnabled(true);
+    this.#update({ errorMessage: "", phase: "listening" });
+  }
+
+  #update(update: Partial<VoiceTurnSnapshot>): void {
+    this.#snapshot = { ...this.#snapshot, ...update };
+    for (const listener of this.#listeners) {
+      listener(this.#snapshot);
+    }
+  }
+}
diff --git a/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts b/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
new file mode 100644
index 00000000000..7c2a182ec96
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
@@ -0,0 +1,263 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import { createOpenAIRealtimeCallHandler } from "./openai-realtime-call";
+
+const enabledEnvironment = {
+  OPENAI_VOICE_API_KEY: "server-secret",
+  PETRINAUT_OPENAI_VOICE_ENABLED: "true",
+  VERCEL_ENV: "preview",
+};
+
+const createRequest = (
+  body = "v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\n",
+  overrides: ConstructorParameters<typeof Request>[1] = {},
+) =>
+  new Request("https://petrinaut.test/api/voice/realtime-call", {
+    body,
+    headers: {
+      "content-type": "application/sdp",
+      origin: "https://petrinaut.test",
+    },
+    method: "POST",
+    ...overrides,
+  });
+
+describe("OpenAI Realtime call handler", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("rejects unavailable, cross-origin, and malformed requests without calling OpenAI", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>();
+    const disabledHandler = createOpenAIRealtimeCallHandler({
+      environment: {},
+      fetch,
+    });
+
+    const disabled = await disabledHandler(createRequest());
+    expect(disabled.status).toBe(404);
+    expect(disabled.headers.get("cache-control")).toBe("no-store");
+
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+    const cases = [
+      createRequest(undefined, { method: "GET", body: undefined }),
+      createRequest(undefined, {
+        headers: {
+          "content-type": "application/sdp",
+          origin: "https://attacker.test",
+        },
+      }),
+      createRequest(undefined, {
+        headers: { origin: "https://petrinaut.test" },
+      }),
+      createRequest("   "),
+      createRequest("not-an-sdp-offer"),
+      createRequest("x", {
+        headers: {
+          "content-length": "65537",
+          "content-type": "application/sdp",
+          origin: "https://petrinaut.test",
+        },
+      }),
+    ];
+
+    const responses = await Promise.all(
+      cases.map((request) => handler(request)),
+    );
+
+    expect(responses.map(({ status }) => status)).toEqual([
+      405, 403, 415, 400, 400, 413,
+    ]);
+    expect(
+      responses.every(
+        (response) => response.headers.get("cache-control") === "no-store",
+      ),
+    ).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  test("forwards only the SDP and server-owned transcription policy", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(
+      async () =>
+        new Response("v=0\r\no=OpenAI answer", {
+          headers: { "content-type": "text/plain; charset=utf-8" },
+        }),
+    );
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+
+    const response = await handler(createRequest());
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("cache-control")).toBe("no-store");
+    expect(response.headers.get("content-type")).toContain("application/sdp");
+    expect(await response.text()).toBe("v=0\r\no=OpenAI answer");
+    expect(fetch).toHaveBeenCalledOnce();
+
+    const [url, request] = fetch.mock.calls[0]!;
+    expect(url).toBe("https://api.openai.com/v1/realtime/calls");
+    expect(request?.method).toBe("POST");
+    expect(new Headers(request?.headers).get("authorization")).toBe(
+      "Bearer server-secret",
+    );
+    expect(request?.signal).toBeInstanceOf(AbortSignal);
+
+    const form = request?.body as FormData;
+    expect(form).toBeInstanceOf(FormData);
+    const sdp = form.get("sdp");
+    const session = form.get("session");
+    expect(sdp).toBe("v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\n");
+    expect(typeof session).toBe("string");
+    expect(JSON.parse(session as string)).toMatchObject({
+      type: "transcription",
+      audio: {
+        input: {
+          transcription: { model: "gpt-live-transcribe", languages: ["en"] },
+        },
+      },
+    });
+    expect(session as string).not.toContain("response.create");
+  });
+
+  test("sanitizes upstream failures", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(
+      async () => new Response("upstream secret diagnostics", { status: 400 }),
+    );
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+
+    const response = await handler(createRequest());
+
+    expect(response.status).toBe(502);
+    const responseBody = await response.text();
+    expect(responseBody).toBe("The voice connection could not be established.");
+    expect(responseBody).not.toContain("secret");
+    expect(response.headers.get("cache-control")).toBe("no-store");
+  });
+
+  test("rejects a non-SDP upstream answer", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(
+      async () =>
+        new Response("v=0\r\no=not actually SDP", {
+          headers: { "content-type": "application/json" },
+        }),
+    );
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+
+    const response = await handler(createRequest());
+
+    expect(response.status).toBe(502);
+    expect(await response.text()).toBe(
+      "The voice connection could not be established.",
+    );
+  });
+
+  test("sanitizes failures while reading the SDP offer", async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>();
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+    const request = createRequest();
+    vi.spyOn(request, "arrayBuffer").mockRejectedValue(
+      new DOMException("client disconnected", "AbortError"),
+    );
+
+    const response = await handler(request);
+
+    expect(response.status).toBe(502);
+    expect(await response.text()).toBe(
+      "The voice connection could not be established.",
+    );
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  test("does not contact OpenAI when the request aborts while its body is read", async () => {
+    const requestAbortController = new AbortController();
+    const fetch = vi.fn<typeof globalThis.fetch>();
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+    const request = createRequest(undefined, {
+      signal: requestAbortController.signal,
+    });
+    const encodedOffer = new TextEncoder().encode(
+      "v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\n",
+    );
+    vi.spyOn(request, "arrayBuffer").mockImplementation(() => {
+      requestAbortController.abort();
+      return Promise.resolve(encodedOffer.buffer);
+    });
+
+    const response = await handler(request);
+
+    expect(response.status).toBe(502);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  test("aborts a slow upstream call after the server timeout", async () => {
+    vi.useFakeTimers();
+    const fetch = vi.fn<typeof globalThis.fetch>(
+      (_input, init) =>
+        new Promise((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () =>
+            reject(new DOMException("aborted", "AbortError")),
+          );
+        }),
+    );
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+
+    const responsePromise = handler(createRequest());
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    const response = await responsePromise;
+    expect(response.status).toBe(504);
+    expect(await response.text()).toBe(
+      "The voice connection could not be established.",
+    );
+    expect(response.headers.get("cache-control")).toBe("no-store");
+  });
+
+  test("propagates a disconnected browser request to OpenAI", async () => {
+    const requestAbortController = new AbortController();
+    let upstreamSignal: AbortSignal | null = null;
+    const fetch = vi.fn<typeof globalThis.fetch>(
+      (_input, init) =>
+        new Promise((_resolve, reject) => {
+          upstreamSignal = init?.signal ?? null;
+          init?.signal?.addEventListener("abort", () =>
+            reject(new DOMException("aborted", "AbortError")),
+          );
+        }),
+    );
+    const handler = createOpenAIRealtimeCallHandler({
+      environment: enabledEnvironment,
+      fetch,
+    });
+
+    const responsePromise = handler(
+      createRequest(undefined, { signal: requestAbortController.signal }),
+    );
+    await vi.waitFor(() => expect(upstreamSignal).not.toBeNull());
+    requestAbortController.abort();
+
+    const response = await responsePromise;
+    expect(fetch.mock.calls[0]?.[1]?.signal?.aborted).toBe(true);
+    expect(response.status).toBe(502);
+    expect(response.headers.get("cache-control")).toBe("no-store");
+  });
+});
diff --git a/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
new file mode 100644
index 00000000000..c2bb864e37b
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
@@ -0,0 +1,143 @@
+import {
+  createOpenAITranscriptionSession,
+  getOpenAIVoiceAvailability,
+  OPENAI_REALTIME_CONNECTION_TIMEOUT_MS,
+} from "./openai-voice-policy";
+
+const OPENAI_REALTIME_CALLS_ENDPOINT =
+  "https://api.openai.com/v1/realtime/calls";
+const MAX_SDP_BYTES = 65_536;
+const CONNECTION_ERROR_MESSAGE =
+  "The voice connection could not be established.";
+const timeoutError = new DOMException("Upstream timed out", "TimeoutError");
+
+interface VoiceEnvironment {
+  readonly OPENAI_VOICE_API_KEY?: string;
+  readonly PETRINAUT_OPENAI_VOICE_ENABLED?: string;
+  readonly VERCEL_ENV?: string;
+}
+
+interface OpenAIRealtimeCallDependencies {
+  readonly environment: VoiceEnvironment;
+  readonly fetch: typeof globalThis.fetch;
+}
+
+const response = (
+  body: string,
+  status: number,
+  headers?: HeadersInit,
+): Response => {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("cache-control", "no-store");
+  return new Response(body, { status, headers: responseHeaders });
+};
+
+const readSdpOffer = async (request: Request): Promise<string | Response> => {
+  const declaredLength = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_SDP_BYTES) {
+    return response("The SDP offer is too large.", 413);
+  }
+
+  const body = await request.arrayBuffer();
+  if (body.byteLength > MAX_SDP_BYTES) {
+    return response("The SDP offer is too large.", 413);
+  }
+
+  const sdp = new TextDecoder().decode(body);
+  const normalizedSdp = sdp.trim();
+  if (!normalizedSdp || !normalizedSdp.startsWith("v=0")) {
+    return response("The SDP offer is invalid.", 400);
+  }
+  return sdp;
+};
+
+export const createOpenAIRealtimeCallHandler =
+  ({ environment, fetch }: OpenAIRealtimeCallDependencies) =>
+  async (request: Request): Promise<Response> => {
+    if (request.method !== "POST") {
+      return response("Method not allowed.", 405, { allow: "POST" });
+    }
+
+    const requestOrigin = new URL(request.url).origin;
+    if (request.headers.get("origin") !== requestOrigin) {
+      return response("Forbidden.", 403);
+    }
+
+    const contentType = request.headers
+      .get("content-type")
+      ?.split(";", 1)[0]
+      ?.trim()
+      .toLowerCase();
+    if (contentType !== "application/sdp") {
+      return response("The request must contain an SDP offer.", 415);
+    }
+
+    if (!getOpenAIVoiceAvailability(environment).available) {
+      return response("Not found.", 404);
+    }
+
+    const abortController = new AbortController();
+    const abortForTimeout = () => abortController.abort(timeoutError);
+    const abortForRequest = () => abortController.abort();
+    const timeout = globalThis.setTimeout(
+      abortForTimeout,
+      OPENAI_REALTIME_CONNECTION_TIMEOUT_MS,
+    );
+    request.signal.addEventListener("abort", abortForRequest, { once: true });
+    if (request.signal.aborted) {
+      abortForRequest();
+    }
+
+    try {
+      abortController.signal.throwIfAborted();
+
+      const sdp = await readSdpOffer(request);
+      abortController.signal.throwIfAborted();
+      if (sdp instanceof Response) {
+        return sdp;
+      }
+
+      const session = createOpenAITranscriptionSession();
+      const form = new FormData();
+      form.set("sdp", sdp);
+      form.set("session", JSON.stringify(session));
+
+      const upstreamResponse = await fetch(OPENAI_REALTIME_CALLS_ENDPOINT, {
+        body: form,
+        headers: {
+          authorization: `Bearer ${environment.OPENAI_VOICE_API_KEY!.trim()}`,
+        },
+        method: "POST",
+        signal: abortController.signal,
+      });
+      if (!upstreamResponse.ok) {
+        return response(CONNECTION_ERROR_MESSAGE, 502);
+      }
+      const upstreamContentType = upstreamResponse.headers
+        .get("content-type")
+        ?.split(";", 1)[0]
+        ?.trim()
+        .toLowerCase();
+      if (
+        upstreamContentType !== "application/sdp" &&
+        upstreamContentType !== "text/plain"
+      ) {
+        return response(CONNECTION_ERROR_MESSAGE, 502);
+      }
+
+      const answer = await upstreamResponse.text();
+      if (!answer.trim() || !answer.trimStart().startsWith("v=0")) {
+        return response(CONNECTION_ERROR_MESSAGE, 502);
+      }
+
+      return response(answer, 200, { "content-type": "application/sdp" });
+    } catch {
+      return response(
+        CONNECTION_ERROR_MESSAGE,
+        abortController.signal.reason === timeoutError ? 504 : 502,
+      );
+    } finally {
+      globalThis.clearTimeout(timeout);
+      request.signal.removeEventListener("abort", abortForRequest);
+    }
+  };
diff --git a/apps/petrinaut-website/src/server/voice/openai-voice-config.test.ts b/apps/petrinaut-website/src/server/voice/openai-voice-config.test.ts
new file mode 100644
index 00000000000..c6a795a8def
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-config.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, test } from "vitest";
+
+import { createOpenAIVoiceConfigHandler } from "./openai-voice-config";
+
+describe("OpenAI voice config handler", () => {
+  test("returns only server-derived availability and the client timeout", async () => {
+    const handler = createOpenAIVoiceConfigHandler({
+      OPENAI_VOICE_API_KEY: "server-secret",
+      PETRINAUT_OPENAI_VOICE_ENABLED: "true",
+      VERCEL_ENV: "preview",
+    });
+
+    const response = await handler(
+      new Request("https://petrinaut.test/api/voice/config"),
+    );
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("cache-control")).toBe("no-store");
+    expect(await response.json()).toEqual({
+      available: true,
+      connectionTimeoutMs: 15_000,
+    });
+  });
+
+  test("rejects non-GET requests", async () => {
+    const handler = createOpenAIVoiceConfigHandler({});
+
+    const response = await handler(
+      new Request("https://petrinaut.test/api/voice/config", {
+        method: "POST",
+      }),
+    );
+
+    expect(response.status).toBe(405);
+    expect(response.headers.get("allow")).toBe("GET");
+    expect(response.headers.get("cache-control")).toBe("no-store");
+  });
+});
diff --git a/apps/petrinaut-website/src/server/voice/openai-voice-config.ts b/apps/petrinaut-website/src/server/voice/openai-voice-config.ts
new file mode 100644
index 00000000000..f43ce99bc14
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-config.ts
@@ -0,0 +1,22 @@
+import { getOpenAIVoiceAvailability } from "./openai-voice-policy";
+
+interface VoiceEnvironment {
+  readonly OPENAI_VOICE_API_KEY?: string;
+  readonly PETRINAUT_OPENAI_VOICE_ENABLED?: string;
+  readonly VERCEL_ENV?: string;
+}
+
+export const createOpenAIVoiceConfigHandler =
+  (environment: VoiceEnvironment) =>
+  async (request: Request): Promise<Response> => {
+    if (request.method !== "GET") {
+      return new Response("Method not allowed.", {
+        status: 405,
+        headers: { allow: "GET", "cache-control": "no-store" },
+      });
+    }
+
+    return Response.json(getOpenAIVoiceAvailability(environment), {
+      headers: { "cache-control": "no-store" },
+    });
+  };
diff --git a/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts b/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
new file mode 100644
index 00000000000..e773803338a
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  createOpenAITranscriptionSession,
+  getOpenAIVoiceAvailability,
+  OPENAI_TRANSCRIPTION_POLICY_VERSION,
+} from "./openai-voice-policy";
+
+describe("OpenAI voice policy", () => {
+  test("keeps voice unavailable unless the server explicitly enables it", () => {
+    expect(getOpenAIVoiceAvailability({})).toEqual({
+      available: false,
+      connectionTimeoutMs: 15_000,
+    });
+    expect(
+      getOpenAIVoiceAvailability({
+        OPENAI_VOICE_API_KEY: "server-secret",
+      }),
+    ).toEqual({ available: false, connectionTimeoutMs: 15_000 });
+  });
+
+  test("fails closed in production while authentication and quotas are unavailable", () => {
+    expect(
+      getOpenAIVoiceAvailability({
+        OPENAI_VOICE_API_KEY: "server-secret",
+        PETRINAUT_OPENAI_VOICE_ENABLED: "true",
+        VERCEL_ENV: "production",
+      }),
+    ).toEqual({ available: false, connectionTimeoutMs: 15_000 });
+
+    expect(
+      getOpenAIVoiceAvailability({
+        NODE_ENV: "production",
+        OPENAI_VOICE_API_KEY: "server-secret",
+        PETRINAUT_OPENAI_VOICE_ENABLED: "true",
+      }),
+    ).toEqual({ available: false, connectionTimeoutMs: 15_000 });
+
+    expect(
+      getOpenAIVoiceAvailability({
+        NODE_ENV: "production",
+        OPENAI_VOICE_API_KEY: "server-secret",
+        PETRINAUT_OPENAI_VOICE_ENABLED: "true",
+        VERCEL_ENV: "preview",
+      }),
+    ).toEqual({ available: true, connectionTimeoutMs: 15_000 });
+  });
+
+  test("owns a transcription-only session policy with provider-default VAD", () => {
+    expect(OPENAI_TRANSCRIPTION_POLICY_VERSION).toBe("process-modeling-en-v2");
+    expect(createOpenAITranscriptionSession()).toEqual({
+      type: "transcription",
+      audio: {
+        input: {
+          transcription: {
+            model: "gpt-live-transcribe",
+            prompt:
+              "Transcribe an English domain-expert interview about process models. Preserve the supplied technical vocabulary verbatim.",
+            keywords: [
+              "SDCPN",
+              "stochastic",
+              "Petri net",
+              "place",
+              "transition",
+              "arc",
+              "token",
+              "marking",
+              "guard",
+              "rate",
+              "distribution",
+              "parameter",
+              "subnet",
+              "scenario",
+              "metric",
+            ],
+            languages: ["en"],
+          },
+        },
+      },
+    });
+  });
+
+  test("never enables Realtime response generation", () => {
+    const serializedPolicy = JSON.stringify(createOpenAITranscriptionSession());
+
+    expect(serializedPolicy).not.toContain("response.create");
+    expect(serializedPolicy).not.toContain("create_response");
+    expect(serializedPolicy).not.toContain("interrupt_response");
+    expect(serializedPolicy).not.toContain("output_audio");
+    expect(serializedPolicy).not.toContain('"language"');
+  });
+});
diff --git a/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts b/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
new file mode 100644
index 00000000000..e6163e62c0d
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
@@ -0,0 +1,54 @@
+export const OPENAI_REALTIME_CONNECTION_TIMEOUT_MS = 15_000;
+export const OPENAI_TRANSCRIPTION_POLICY_VERSION = "process-modeling-en-v2";
+
+interface VoiceEnvironment {
+  readonly NODE_ENV?: string;
+  readonly OPENAI_VOICE_API_KEY?: string;
+  readonly PETRINAUT_OPENAI_VOICE_ENABLED?: string;
+  readonly VERCEL_ENV?: string;
+}
+
+const isNonProductionRuntime = (environment: VoiceEnvironment): boolean =>
+  environment.VERCEL_ENV === "preview" ||
+  environment.VERCEL_ENV === "development" ||
+  (environment.VERCEL_ENV === undefined &&
+    environment.NODE_ENV !== "production");
+
+export const getOpenAIVoiceAvailability = (environment: VoiceEnvironment) => ({
+  available:
+    isNonProductionRuntime(environment) &&
+    environment.PETRINAUT_OPENAI_VOICE_ENABLED === "true" &&
+    Boolean(environment.OPENAI_VOICE_API_KEY?.trim()),
+  connectionTimeoutMs: OPENAI_REALTIME_CONNECTION_TIMEOUT_MS,
+});
+
+export const createOpenAITranscriptionSession = () => ({
+  type: "transcription" as const,
+  audio: {
+    input: {
+      transcription: {
+        model: "gpt-live-transcribe",
+        prompt:
+          "Transcribe an English domain-expert interview about process models. Preserve the supplied technical vocabulary verbatim.",
+        keywords: [
+          "SDCPN",
+          "stochastic",
+          "Petri net",
+          "place",
+          "transition",
+          "arc",
+          "token",
+          "marking",
+          "guard",
+          "rate",
+          "distribution",
+          "parameter",
+          "subnet",
+          "scenario",
+          "metric",
+        ],
+        languages: ["en"],
+      },
+    },
+  },
+});
diff --git a/apps/petrinaut-website/src/vite-env.d.ts b/apps/petrinaut-website/src/vite-env.d.ts
index c48e7248333..f2248893fb9 100644
--- a/apps/petrinaut-website/src/vite-env.d.ts
+++ b/apps/petrinaut-website/src/vite-env.d.ts
@@ -4,5 +4,6 @@ declare const __SENTRY_DSN__: string | undefined;
 declare const __ENVIRONMENT__: string;
 
 interface ImportMetaEnv {
+  readonly VITE_BRUNCH_CHAT_ENDPOINT?: string;
   readonly VITE_PETRINAUT_OPT_PROVIDER?: "service";
 }
diff --git a/apps/petrinaut-website/vercel.json b/apps/petrinaut-website/vercel.json
index 6b17c8f9340..ee12cb859b6 100644
--- a/apps/petrinaut-website/vercel.json
+++ b/apps/petrinaut-website/vercel.json
@@ -61,6 +61,9 @@
     },
     "api/oembed.ts": {
       "maxDuration": 10
+    },
+    "api/voice/realtime-call.ts": {
+      "maxDuration": 30
     }
   }
 }
diff --git a/apps/petrinaut-website/vite.config.ts b/apps/petrinaut-website/vite.config.ts
index 36ed58463c7..ff28dedd11d 100644
--- a/apps/petrinaut-website/vite.config.ts
+++ b/apps/petrinaut-website/vite.config.ts
@@ -24,6 +24,8 @@ const loadServerEnv = (mode: string) => {
 const apiModules = [
   ["/api/chat", "/api/chat.ts"],
   ["/api/oembed", "/api/oembed.ts"],
+  ["/api/voice/config", "/api/voice/config.ts"],
+  ["/api/voice/realtime-call", "/api/voice/realtime-call.ts"],
 ] as const;
 
 // Plugin required to serve the Vercel fetch handlers in dev. In production,
diff --git a/libs/@hashintel/brunch-agent/docs/adr/0009-openai-voice-ui-turn-shell.md b/libs/@hashintel/brunch-agent/docs/adr/0009-openai-voice-ui-turn-shell.md
index 2ffcd99e737..b6b3db45e68 100644
--- a/libs/@hashintel/brunch-agent/docs/adr/0009-openai-voice-ui-turn-shell.md
+++ b/libs/@hashintel/brunch-agent/docs/adr/0009-openai-voice-ui-turn-shell.md
@@ -33,9 +33,11 @@ production recovery or public availability.
    diagnostic.
 3. **Realtime is transcription-only.** The server atomically combines browser SDP with trusted
    transcription policy and calls OpenAI's unified WebRTC initialization endpoint. The fixed
-   model is `gpt-live-transcribe`. Semantic VAD begins at low eagerness as a tunable evaluation
-   setting. Provider keys, prompts, vocabulary, language policy, and model selection remain
-   server-side. Realtime never generates assistant responses.
+   model is `gpt-live-transcribe`. Turn detection uses that model's default server VAD because the
+   unified endpoint currently times out when either VAD mode is configured during initialization;
+   semantic VAD remains a tunable evaluation setting once initialization supports it. Provider
+   keys, prompts, vocabulary, language policy, and model selection remain server-side. Realtime
+   never generates assistant responses.
 4. **Completed provider items are the only admitted audio input.** Partials are display-only.
    Completed items are keyed by connection epoch, provider item ID, and content index, then enter
    the existing Petrinaut composer and AI SDK transport once. A pending `brunch_ask` uses its
diff --git a/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json b/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
index 9a58144ce85..2d9591e4d43 100644
--- a/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/package.json
@@ -10,6 +10,10 @@
       "types": "./src/index.ts",
       "import": "./dist/index.js"
     },
+    "./client-tools": {
+      "types": "./src/client-tools.ts",
+      "import": "./dist/client-tools.js"
+    },
     "./headers": {
       "types": "./src/headers.ts",
       "import": "./dist/headers.js"
@@ -23,6 +27,7 @@
     "test:unit": "vitest run"
   },
   "dependencies": {
+    "@hashintel/brunch-agent": "workspace:*",
     "ai": "6.0.182",
     "valibot": "1.4.2"
   },
diff --git a/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/client-tools.ts b/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/client-tools.ts
new file mode 100644
index 00000000000..a61e161d6dd
--- /dev/null
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/src/client-tools.ts
@@ -0,0 +1,23 @@
+/**
+ * Browser-safe wire contract for the Brunch tools a host UI executes.
+ */
+
+import * as v from "valibot";
+
+import {
+  AskInput,
+  AskSubmission,
+  toolName,
+} from "@hashintel/brunch-agent/client-tools";
+
+export const ASK_TOOL_NAME = toolName("ask");
+export const SWEEP_TOOL_NAME = toolName("sweep");
+
+export type BrunchAskInput = v.InferOutput<typeof AskInput>;
+export type BrunchAskOutput = v.InferOutput<typeof AskSubmission>;
+
+export const parseBrunchAskInput = (input: unknown): BrunchAskInput =>
+  v.parse(AskInput, input);
+
+export const parseBrunchAskOutput = (output: unknown): BrunchAskOutput =>
+  v.parse(AskSubmission, output);
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 a23d137f9ac..369dc937a5d 100644
--- a/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts
+++ b/libs/@hashintel/brunch-agent/packages/transport-aisdk/vite.config.ts
@@ -8,6 +8,9 @@ export default defineConfig({
   build: {
     lib: {
       entry: {
+        "client-tools": fileURLToPath(
+          new URL("src/client-tools.ts", import.meta.url),
+        ),
         headers: fileURLToPath(new URL("src/headers.ts", import.meta.url)),
         index: fileURLToPath(new URL("src/index.ts", import.meta.url)),
       },
@@ -15,7 +18,7 @@ export default defineConfig({
       formats: ["es"],
     },
     rolldownOptions: {
-      external: ["ai", "valibot"],
+      external: [/^@hashintel\/brunch-agent(?:\/.*)?$/u, "ai", "valibot"],
     },
     sourcemap: true,
   },
diff --git a/libs/@hashintel/petrinaut/docs/ai-assistant.md b/libs/@hashintel/petrinaut/docs/ai-assistant.md
index 8133679e777..3f1ea025b9a 100644
--- a/libs/@hashintel/petrinaut/docs/ai-assistant.md
+++ b/libs/@hashintel/petrinaut/docs/ai-assistant.md
@@ -25,6 +25,8 @@ behaves like text sent with the keyboard: it joins the same conversation and, wh
 question is waiting for an answer, completes that question rather than starting an unrelated
 message. A host can explicitly submit a separate message instead when the text is a correction or
 other follow-up that must not answer the pending question.
+If the host offers voice input, a finalized spoken turn is held while an existing response
+finishes and is submitted when the conversation is ready.
 
 **Clear AI chat** via the delete button in the top right of the panel: wipes the conversation, stops any in-flight stream, and tells the host app to forget the messages (if the host persists them).
 
diff --git a/libs/@hashintel/petrinaut/src/ui/types/ai-assistant-composer-control.ts b/libs/@hashintel/petrinaut/src/ui/types/ai-assistant-composer-control.ts
index d1fb912ae5d..596c54a152a 100644
--- a/libs/@hashintel/petrinaut/src/ui/types/ai-assistant-composer-control.ts
+++ b/libs/@hashintel/petrinaut/src/ui/types/ai-assistant-composer-control.ts
@@ -13,6 +13,13 @@ export type PetrinautAiComposerSubmitTextResult =
   | { kind: "message"; messageId: string }
   | { kind: "interactive-tool"; toolCallId: string };
 
+export type PetrinautAiComposerSubmitText = (params: {
+  id?: string;
+  /** Defaults to `auto`; use `message` for text that must not answer a pending tool. */
+  target?: "auto" | "message";
+  text: string;
+}) => Promise<PetrinautAiComposerSubmitTextResult>;
+
 /** Stable controls and current conversation state supplied to a host control. */
 export type PetrinautAiComposerControlContext = {
   /** Effective AI SDK identity, whether host-supplied or generated by `useChat`. */
@@ -22,12 +29,12 @@ export type PetrinautAiComposerControlContext = {
   /** Call from an event handler or effect, never while rendering. */
   stop: () => Promise<void>;
   /** Call from an event handler or effect, never while rendering. */
-  submitText: (params: {
-    id?: string;
-    /** Defaults to `auto`; use `message` for text that must not answer a pending tool. */
-    target?: "auto" | "message";
-    text: string;
-  }) => Promise<PetrinautAiComposerSubmitTextResult>;
+  submitText: PetrinautAiComposerSubmitText;
+  /**
+   * Submit one voice turn, deferring it while another AI response is active.
+   * Call from an event handler or effect, never while rendering.
+   */
+  submitVoiceInput: PetrinautAiComposerSubmitText;
 };
 
 /** Render callback for a host-owned control inside the assistant composer. */
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.test.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.test.tsx
index 9a5bcd50dc4..5a34cd779fb 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.test.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.test.tsx
@@ -358,6 +358,91 @@ describe("AiAssistantPanel composer submissions", () => {
     expect(observedConversationIds).toEqual(new Set(["voice-conversation-1"]));
   });
 
+  test("queues one voice input while the current response is streaming", async () => {
+    const requestMessages: PetrinautAiMessage[][] = [];
+    let finishFirstResponse: (() => void) | undefined;
+    const transport: PetrinautAiTransport = {
+      reconnectToStream: () => Promise.resolve(null),
+      sendMessages: vi.fn(({ messages }) => {
+        requestMessages.push(structuredClone(messages));
+        if (requestMessages.length > 1) {
+          return Promise.resolve(
+            streamChunks(textChunks("voice-response", "Voice input accepted")),
+          );
+        }
+
+        return Promise.resolve(
+          new ReadableStream<UIMessageChunk>({
+            start(controller) {
+              controller.enqueue({ type: "start-step" });
+              controller.enqueue({ type: "text-start", id: "first-response" });
+              controller.enqueue({
+                type: "text-delta",
+                id: "first-response",
+                delta: "First response",
+              });
+              finishFirstResponse = () => {
+                controller.enqueue({
+                  type: "text-end",
+                  id: "first-response",
+                });
+                controller.close();
+              };
+            },
+          }),
+        );
+      }),
+    };
+
+    renderTestPanel({
+      aiAssistant: {
+        renderComposerControl: ({ submitText, submitVoiceInput }) => (
+          <>
+            <button
+              type="button"
+              onClick={() => {
+                void submitText({ text: "Start generic response" });
+              }}
+            >
+              Start generic response
+            </button>
+            <button
+              type="button"
+              onClick={() => {
+                void submitVoiceInput({
+                  id: "queued-voice-turn",
+                  text: "Queued voice turn",
+                });
+              }}
+            >
+              Submit queued voice input
+            </button>
+          </>
+        ),
+        transport,
+      },
+    });
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Start generic response" }),
+    );
+    await screen.findByText("First response");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Submit queued voice input" }),
+    );
+
+    expect(requestMessages).toHaveLength(1);
+    finishFirstResponse?.();
+
+    await screen.findByText("Voice input accepted");
+    expect(requestMessages).toHaveLength(2);
+    expect(requestMessages[1]?.at(-1)).toMatchObject({
+      id: "queued-voice-turn",
+      parts: [{ text: "Queued voice turn", type: "text" }],
+      role: "user",
+    });
+  });
+
   test("stops the current response through the host composer control", async () => {
     const aborted = vi.fn();
     const transport: PetrinautAiTransport = {
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.tsx
index 39af27effd6..7f86c04a7d3 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel.tsx
@@ -57,6 +57,7 @@ import {
 import type { PetrinautAiAssistant } from "../../../petrinaut";
 import type {
   PetrinautAiComposerControlContext,
+  PetrinautAiComposerSubmitText,
   PetrinautAiComposerSubmitTextResult,
 } from "../../../types/ai-assistant-composer-control";
 import type { PetrinautAiMessage } from "./ai-assistant-panel/types";
@@ -733,6 +734,60 @@ export const AiAssistantPanel = ({
     [composerSubmissionStateRef],
   );
 
+  const pendingVoiceInputRef = useRef<{
+    input: Parameters<PetrinautAiComposerSubmitText>[0];
+    reject: (reason: unknown) => void;
+    resolve: (result: PetrinautAiComposerSubmitTextResult) => void;
+  } | null>(null);
+  const submitVoiceInput = useCallback<PetrinautAiComposerSubmitText>(
+    (voiceInput) => {
+      const currentStatus = composerSubmissionStateRef.current.status;
+      if (currentStatus !== "submitted" && currentStatus !== "streaming") {
+        return submitText(voiceInput);
+      }
+
+      if (pendingVoiceInputRef.current) {
+        const submissionError = new Error(
+          "Wait for the queued voice input before submitting another.",
+        );
+        setStreamError(submissionError);
+        return Promise.reject(submissionError);
+      }
+
+      return new Promise((resolve, reject) => {
+        pendingVoiceInputRef.current = {
+          input: voiceInput,
+          reject,
+          resolve,
+        };
+      });
+    },
+    [composerSubmissionStateRef, submitText],
+  );
+
+  useEffect(() => {
+    const pendingVoiceInput = pendingVoiceInputRef.current;
+    if (!pendingVoiceInput) {
+      return;
+    }
+    if (status === "error") {
+      pendingVoiceInputRef.current = null;
+      pendingVoiceInput.reject(
+        new Error("Brunch could not accept the queued voice input."),
+      );
+      return;
+    }
+    if (status !== "ready") {
+      return;
+    }
+
+    pendingVoiceInputRef.current = null;
+    void submitText(pendingVoiceInput.input).then(
+      pendingVoiceInput.resolve,
+      pendingVoiceInput.reject,
+    );
+  }, [status, submitText]);
+
   const stopStateRef = useLatest({ status, stop });
 
   // Like submitText, stop is exposed to host controls and must stay stable.
@@ -802,6 +857,7 @@ export const AiAssistantPanel = ({
     status,
     stop: stopComposer,
     submitText,
+    submitVoiceInput,
   };
   /* eslint-disable react-hooks-js/refs -- The public render prop receives
      stable event callbacks that read their refs only when the host invokes
diff --git a/yarn.lock b/yarn.lock
index 8cd375cffde..91401d202c6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7437,6 +7437,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@hashintel/brunch-agent-transport-aisdk@workspace:libs/@hashintel/brunch-agent/packages/transport-aisdk"
   dependencies:
+    "@hashintel/brunch-agent": "workspace:*"
     "@types/node": "npm:22.18.13"
     "@typescript/native-preview": "npm:7.0.0-dev.20260511.1"
     ai: "npm:6.0.182"