From 9d0d35d45b3ac05c8df1459f2441c4c497e90218 Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Thu, 27 Aug 2026 00:07:35 +0200
Subject: [PATCH 1/8] Add OpenAI Realtime voice input

Initialize transcription-only WebRTC sessions through an app-owned, fail-closed server boundary. Admit only stable finalized transcript items through the existing Petrinaut composer and Brunch transport, with half-duplex lifecycle, stale-event rejection, correction handling, preview gating, and accessible controls.

Amp-Thread-ID: https://ampcode.com/threads/T-01a03fb3-fd3d-737f-b4c6-1fc9282950bf
Co-authored-by: Amp <amp@ampcode.com>
---
 apps/petrinaut-website/.env.example           |   3 +
 apps/petrinaut-website/README.md              |  45 +-
 apps/petrinaut-website/api/voice/config.ts    |   9 +
 .../api/voice/realtime-call.ts                |  12 +
 .../brunch-ask-interactive-tool.test.ts       |  14 +
 .../brunch-ask-interactive-tool.tsx           | 151 +++++++
 .../local-storage-demo/brunch-ask-mapping.ts  |  11 +
 .../brunch-preview-config.test.ts             |  33 ++
 .../brunch-preview-config.ts                  |   9 +
 .../local-storage-demo-app.test.tsx           |  41 ++
 .../local-storage-demo-app.tsx                |  32 +-
 .../openai-realtime-session.test.ts           | 298 +++++++++++++
 .../openai-realtime-session.ts                | 388 +++++++++++++++++
 .../voice-interview-control.test.tsx          | 110 +++++
 .../voice-interview-control.tsx               | 389 +++++++++++++++++
 .../voice-turn-controller.test.ts             | 401 ++++++++++++++++++
 .../voice-interview/voice-turn-controller.ts  | 374 ++++++++++++++++
 .../server/voice/openai-realtime-call.test.ts | 223 ++++++++++
 .../src/server/voice/openai-realtime-call.ts  | 138 ++++++
 .../server/voice/openai-voice-config.test.ts  |  38 ++
 .../src/server/voice/openai-voice-config.ts   |  22 +
 .../server/voice/openai-voice-policy.test.ts  |  96 +++++
 .../src/server/voice/openai-voice-policy.ts   |  58 +++
 apps/petrinaut-website/src/vite-env.d.ts      |   1 +
 apps/petrinaut-website/vercel.json            |   3 +
 apps/petrinaut-website/vite.config.ts         |   2 +
 26 files changed, 2889 insertions(+), 12 deletions(-)
 create mode 100644 apps/petrinaut-website/api/voice/config.ts
 create mode 100644 apps/petrinaut-website/api/voice/realtime-call.ts
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.ts
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.tsx
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-mapping.ts
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.test.ts
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/brunch-preview-config.ts
 create mode 100644 apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.test.tsx
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.test.ts
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.ts
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.test.tsx
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.tsx
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.test.ts
 create mode 100644 apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-voice-config.test.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-voice-config.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
 create mode 100644 apps/petrinaut-website/src/server/voice/openai-voice-policy.ts

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..a9f53674254 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,37 @@ 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, language, vocabulary, and VAD policy private.
+
+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..72e031327fd
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/local-storage-demo-app.test.tsx
@@ -0,0 +1,41 @@
+/**
+ * @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",
+      })),
+    });
+
+    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..7ff93705108 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 { getOrCreateBrunchConversationId } from "./brunch-conversation-id";
+import { VoiceInterviewControl } from "../voice-interview/voice-interview-control";
+import { brunchAskInteractiveTool } from "./brunch-ask-interactive-tool";
 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..7f4c32eac86
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.test.ts
@@ -0,0 +1,298 @@
+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("closes the microphone when semantic 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 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..c5f6911d21f
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/openai-realtime-session.ts
@@ -0,0 +1,388 @@
+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;
+    }
+
+    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 (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..8f238ee3177
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.test.tsx
@@ -0,0 +1,110 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test, vi } from "vitest";
+
+import {
+  loadOpenAIVoiceConfig,
+  VoiceInterviewControlView,
+} from "./voice-interview-control";
+
+describe("voice interview control", () => {
+  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");
+  });
+});
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..f75842ab863
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-control.tsx
@@ -0,0 +1,389 @@
+import {
+  type FormEvent,
+  useEffect,
+  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.submitText,
+    });
+    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("");
+
+  useEffect(() => {
+    store.controller.updateChatStatus(context.status);
+  }, [context.status, store]);
+
+  useEffect(
+    () => () => {
+      void store.controller.dispose();
+    },
+    [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..0b6cf96239d
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.test.ts
@@ -0,0 +1,401 @@
+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("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 semantic 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("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..5ab2e7c6b38
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-turn-controller.ts
@@ -0,0 +1,374 @@
+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 #unsubscribeFromSession: () => void;
+  readonly #completedKeys = new Set<string>();
+  #activeEpoch: number | null = null;
+  #activeItemId: string | null = null;
+  #activeKey: string | null = null;
+  #awaitingChatCycle = false;
+  #chatStatus: ChatStatus = "ready";
+  #generation = 0;
+  #sawBusyChatStatus = false;
+  #snapshot = initialSnapshot;
+
+  public constructor({
+    conversationId,
+    session,
+    submitText,
+  }: VoiceTurnControllerDependencies) {
+    this.#conversationId = conversationId;
+    this.#session = session;
+    this.#submitText = submitText;
+    this.#unsubscribeFromSession = 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.#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 === "submitted" || status === "streaming") &&
+        this.#snapshot.phase === "listening"
+      ) {
+        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();
+  }
+
+  public async dispose(): Promise<void> {
+    await this.end();
+    this.#unsubscribeFromSession();
+    this.#listeners.clear();
+  }
+
+  async #deliver(input: SubmitTextInput): Promise<void> {
+    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;
+      }
+      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.#session.setMicrophoneEnabled(false);
+      this.#update({ errorMessage: event.message, phase: "recoverable-error" });
+      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")
+      ) {
+        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")
+    ) {
+      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.#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);
+    this.#update({
+      errorMessage: "",
+      lastCommittedText: finalText,
+      partialText: "",
+      phase: "delivering",
+    });
+    void this.#deliver({
+      id: createVoiceMessageId(this.#conversationId, event.key),
+      text: finalText,
+    });
+  }
+
+  #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..9375bb21e1d
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
@@ -0,0 +1,223 @@
+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",
+  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": "application/sdp" },
+        }),
+    );
+    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).toBeInstanceOf(Blob);
+    expect(session).toBeInstanceOf(Blob);
+    expect((sdp as Blob).type).toBe("application/sdp");
+    expect(await (sdp as Blob).text()).toBe("v=0\r\no=- 0 0 IN IP4 127.0.0.1");
+    expect((session as Blob).type).toBe("application/json");
+    expect(JSON.parse(await (session as Blob).text())).toMatchObject({
+      type: "transcription",
+      audio: {
+        input: {
+          transcription: { model: "gpt-live-transcribe", languages: ["en"] },
+          turn_detection: { type: "semantic_vad", eagerness: "low" },
+        },
+      },
+    });
+    expect(await (session as Blob).text()).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("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..a56237d9e6a
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
@@ -0,0 +1,138 @@
+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).trim();
+  if (!sdp || !sdp.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 sdp = await readSdpOffer(request);
+    if (sdp instanceof Response) {
+      return sdp;
+    }
+
+    const session = createOpenAITranscriptionSession();
+    const form = new FormData();
+    form.set("sdp", new Blob([sdp], { type: "application/sdp" }), "offer.sdp");
+    form.set(
+      "session",
+      new Blob([JSON.stringify(session)], { type: "application/json" }),
+      "session.json",
+    );
+
+    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 });
+
+    try {
+      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);
+      }
+      if (
+        upstreamResponse.headers
+          .get("content-type")
+          ?.split(";", 1)[0]
+          ?.trim()
+          .toLowerCase() !== "application/sdp"
+      ) {
+        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..f1016a37164
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
@@ -0,0 +1,96 @@
+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 semantic VAD", () => {
+    expect(OPENAI_TRANSCRIPTION_POLICY_VERSION).toBe("process-modeling-en-v1");
+    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"],
+          },
+          turn_detection: {
+            type: "semantic_vad",
+            eagerness: "low",
+          },
+        },
+      },
+    });
+  });
+
+  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..d2605f094d7
--- /dev/null
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
@@ -0,0 +1,58 @@
+export const OPENAI_REALTIME_CONNECTION_TIMEOUT_MS = 15_000;
+export const OPENAI_TRANSCRIPTION_POLICY_VERSION = "process-modeling-en-v1";
+
+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"],
+      },
+      turn_detection: {
+        type: "semantic_vad" as const,
+        eagerness: "low" as const,
+      },
+    },
+  },
+});
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,

From 177473cba5058a9e30a1edc8630f1d0c521625c5 Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Thu, 27 Aug 2026 11:34:58 +0200
Subject: [PATCH 2/8] Fix OpenAI Realtime voice startup

Keep the voice controller live across React Strict Mode effect replays. Send OpenAI's unified call fields as strings, preserve the SDP terminator, accept its text SDP response, and use provider-default VAD so the microphone reaches the listening state.
---
 apps/petrinaut-website/README.md              |  4 +-
 .../openai-realtime-session.test.ts           |  2 +-
 .../voice-interview-control.test.tsx          | 67 ++++++++++++++++++-
 .../voice-interview-control.tsx               |  2 +-
 .../voice-turn-controller.test.ts             |  2 +-
 .../voice-interview/voice-turn-controller.ts  | 11 +--
 .../server/voice/openai-realtime-call.test.ts | 16 ++---
 .../src/server/voice/openai-realtime-call.ts  | 25 ++++---
 .../server/voice/openai-voice-policy.test.ts  |  8 +--
 .../src/server/voice/openai-voice-policy.ts   |  6 +-
 .../adr/0009-openai-voice-ui-turn-shell.md    |  8 ++-
 11 files changed, 99 insertions(+), 52 deletions(-)

diff --git a/apps/petrinaut-website/README.md b/apps/petrinaut-website/README.md
index a9f53674254..583ccbe749c 100644
--- a/apps/petrinaut-website/README.md
+++ b/apps/petrinaut-website/README.md
@@ -81,7 +81,9 @@ Voice input is disabled by default and always unavailable when `VERCEL_ENV` is
 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, language, vocabulary, and VAD policy private.
+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
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
index 7f4c32eac86..ee833c38a5b 100644
--- 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
@@ -166,7 +166,7 @@ describe("OpenAIRealtimeSession", () => {
     expect(harness.tracks[0]!.enabled).toBe(false);
   });
 
-  test("closes the microphone when semantic VAD commits an input item", async () => {
+  test("closes the microphone when VAD commits an input item", async () => {
     const harness = createHarness();
     await harness.session.connect();
     harness.session.setMicrophoneEnabled(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
index 8f238ee3177..b9279a962ad 100644
--- 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
@@ -1,12 +1,22 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, StrictMode } from "react";
+import { createRoot } from "react-dom/client";
 import { renderToStaticMarkup } from "react-dom/server";
-import { describe, expect, test, vi } from "vitest";
+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 }),
@@ -107,4 +117,59 @@ describe("voice interview control", () => {
     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",
+              }))}
+            />
+          </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
index f75842ab863..69c1e891f45 100644
--- 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
@@ -335,7 +335,7 @@ const AvailableVoiceInterviewControl = ({
 
   useEffect(
     () => () => {
-      void store.controller.dispose();
+      void store.controller.end();
     },
     [store],
   );
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
index 0b6cf96239d..cc2639f6664 100644
--- 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
@@ -213,7 +213,7 @@ describe("VoiceTurnController", () => {
     );
   });
 
-  test("closes the listening window when semantic VAD commits an item", async () => {
+  test("closes the listening window when VAD commits an item", async () => {
     const harness = createHarness();
     await harness.controller.start();
 
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
index 5ab2e7c6b38..bff5526cf22 100644
--- 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
@@ -69,7 +69,6 @@ export class VoiceTurnController {
   readonly #listeners = new Set<SnapshotListener>();
   readonly #session: RealtimeSession;
   readonly #submitText: (input: SubmitTextInput) => Promise<unknown>;
-  readonly #unsubscribeFromSession: () => void;
   readonly #completedKeys = new Set<string>();
   #activeEpoch: number | null = null;
   #activeItemId: string | null = null;
@@ -88,9 +87,7 @@ export class VoiceTurnController {
     this.#conversationId = conversationId;
     this.#session = session;
     this.#submitText = submitText;
-    this.#unsubscribeFromSession = session.subscribe((event) =>
-      this.#handleSessionEvent(event),
-    );
+    session.subscribe((event) => this.#handleSessionEvent(event));
   }
 
   public getSnapshot(): VoiceTurnSnapshot {
@@ -232,12 +229,6 @@ export class VoiceTurnController {
     this.#reopenListeningIfReady();
   }
 
-  public async dispose(): Promise<void> {
-    await this.end();
-    this.#unsubscribeFromSession();
-    this.#listeners.clear();
-  }
-
   async #deliver(input: SubmitTextInput): Promise<void> {
     const generation = this.#generation;
     this.#awaitingChatCycle = true;
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
index 9375bb21e1d..d1556b3af95 100644
--- a/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
@@ -9,7 +9,7 @@ const enabledEnvironment = {
 };
 
 const createRequest = (
-  body = "v=0\r\no=- 0 0 IN IP4 127.0.0.1",
+  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", {
@@ -83,7 +83,7 @@ describe("OpenAI Realtime call handler", () => {
     const fetch = vi.fn<typeof globalThis.fetch>(
       async () =>
         new Response("v=0\r\no=OpenAI answer", {
-          headers: { "content-type": "application/sdp" },
+          headers: { "content-type": "text/plain; charset=utf-8" },
         }),
     );
     const handler = createOpenAIRealtimeCallHandler({
@@ -111,21 +111,17 @@ describe("OpenAI Realtime call handler", () => {
     expect(form).toBeInstanceOf(FormData);
     const sdp = form.get("sdp");
     const session = form.get("session");
-    expect(sdp).toBeInstanceOf(Blob);
-    expect(session).toBeInstanceOf(Blob);
-    expect((sdp as Blob).type).toBe("application/sdp");
-    expect(await (sdp as Blob).text()).toBe("v=0\r\no=- 0 0 IN IP4 127.0.0.1");
-    expect((session as Blob).type).toBe("application/json");
-    expect(JSON.parse(await (session as Blob).text())).toMatchObject({
+    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"] },
-          turn_detection: { type: "semantic_vad", eagerness: "low" },
         },
       },
     });
-    expect(await (session as Blob).text()).not.toContain("response.create");
+    expect(session as string).not.toContain("response.create");
   });
 
   test("sanitizes upstream failures", async () => {
diff --git a/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
index a56237d9e6a..f12cdd90497 100644
--- a/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
@@ -43,8 +43,9 @@ const readSdpOffer = async (request: Request): Promise<string | Response> => {
     return response("The SDP offer is too large.", 413);
   }
 
-  const sdp = new TextDecoder().decode(body).trim();
-  if (!sdp || !sdp.startsWith("v=0")) {
+  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;
@@ -82,12 +83,8 @@ export const createOpenAIRealtimeCallHandler =
 
     const session = createOpenAITranscriptionSession();
     const form = new FormData();
-    form.set("sdp", new Blob([sdp], { type: "application/sdp" }), "offer.sdp");
-    form.set(
-      "session",
-      new Blob([JSON.stringify(session)], { type: "application/json" }),
-      "session.json",
-    );
+    form.set("sdp", sdp);
+    form.set("session", JSON.stringify(session));
 
     const abortController = new AbortController();
     const abortForTimeout = () => abortController.abort(timeoutError);
@@ -110,12 +107,14 @@ export const createOpenAIRealtimeCallHandler =
       if (!upstreamResponse.ok) {
         return response(CONNECTION_ERROR_MESSAGE, 502);
       }
+      const upstreamContentType = upstreamResponse.headers
+        .get("content-type")
+        ?.split(";", 1)[0]
+        ?.trim()
+        .toLowerCase();
       if (
-        upstreamResponse.headers
-          .get("content-type")
-          ?.split(";", 1)[0]
-          ?.trim()
-          .toLowerCase() !== "application/sdp"
+        upstreamContentType !== "application/sdp" &&
+        upstreamContentType !== "text/plain"
       ) {
         return response(CONNECTION_ERROR_MESSAGE, 502);
       }
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
index f1016a37164..e773803338a 100644
--- a/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.test.ts
@@ -46,8 +46,8 @@ describe("OpenAI voice policy", () => {
     ).toEqual({ available: true, connectionTimeoutMs: 15_000 });
   });
 
-  test("owns a transcription-only session policy with semantic VAD", () => {
-    expect(OPENAI_TRANSCRIPTION_POLICY_VERSION).toBe("process-modeling-en-v1");
+  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: {
@@ -75,10 +75,6 @@ describe("OpenAI voice policy", () => {
             ],
             languages: ["en"],
           },
-          turn_detection: {
-            type: "semantic_vad",
-            eagerness: "low",
-          },
         },
       },
     });
diff --git a/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts b/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
index d2605f094d7..e6163e62c0d 100644
--- a/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-voice-policy.ts
@@ -1,5 +1,5 @@
 export const OPENAI_REALTIME_CONNECTION_TIMEOUT_MS = 15_000;
-export const OPENAI_TRANSCRIPTION_POLICY_VERSION = "process-modeling-en-v1";
+export const OPENAI_TRANSCRIPTION_POLICY_VERSION = "process-modeling-en-v2";
 
 interface VoiceEnvironment {
   readonly NODE_ENV?: string;
@@ -49,10 +49,6 @@ export const createOpenAITranscriptionSession = () => ({
         ],
         languages: ["en"],
       },
-      turn_detection: {
-        type: "semantic_vad" as const,
-        eagerness: "low" as const,
-      },
     },
   },
 });
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

From 0c7207580767c63543206094c56c0a57672f5e43 Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Thu, 27 Aug 2026 14:30:09 +0200
Subject: [PATCH 3/8] Fix Realtime voice failure recovery

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../openai-realtime-session.test.ts           | 79 +++++++++++++++++++
 .../openai-realtime-session.ts                | 21 +++++
 .../voice-turn-controller.test.ts             | 46 +++++++++++
 .../voice-interview/voice-turn-controller.ts  |  7 ++
 4 files changed, 153 insertions(+)

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
index ee833c38a5b..322d3beaccb 100644
--- 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
@@ -166,6 +166,54 @@ describe("OpenAIRealtimeSession", () => {
     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();
@@ -240,6 +288,37 @@ describe("OpenAIRealtimeSession", () => {
     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();
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
index c5f6911d21f..78dfd774469 100644
--- 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
@@ -286,6 +286,24 @@ export class OpenAIRealtimeSession {
       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"
@@ -361,6 +379,9 @@ export class OpenAIRealtimeSession {
     dataChannel: RTCDataChannel,
     signal: AbortSignal,
   ): Promise<void> {
+    if (signal.aborted) {
+      return Promise.reject(signal.reason);
+    }
     if (dataChannel.readyState === "open") {
       return Promise.resolve();
     }
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
index cc2639f6664..5b609337bf0 100644
--- 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
@@ -152,6 +152,22 @@ describe("VoiceTurnController", () => {
     expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
   });
 
+  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();
@@ -373,6 +389,36 @@ describe("VoiceTurnController", () => {
     );
   });
 
+  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();
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
index bff5526cf22..81890acbd24 100644
--- 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
@@ -267,6 +267,12 @@ export class VoiceTurnController {
 
   #handleSessionEvent(event: OpenAIRealtimeSessionEvent): void {
     if (event.type === "error") {
+      ++this.#generation;
+      this.#activeEpoch = null;
+      this.#activeItemId = null;
+      this.#activeKey = null;
+      this.#awaitingChatCycle = false;
+      this.#sawBusyChatStatus = false;
       this.#session.setMicrophoneEnabled(false);
       this.#update({ errorMessage: event.message, phase: "recoverable-error" });
       return;
@@ -308,6 +314,7 @@ export class VoiceTurnController {
     this.#activeKey = key;
 
     if (event.type === "partial") {
+      this.#session.setMicrophoneEnabled(false);
       this.#update({
         partialText: `${this.#snapshot.partialText}${event.text}`,
         phase: "transcribing",

From b4f1471c9c0f0de29500dbb9ddc5107ef47bfdde Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Mon, 31 Aug 2026 20:03:03 +0200
Subject: [PATCH 4/8] Restore browser-safe Brunch client tool contracts

---
 .../packages/transport-aisdk/package.json     |  5 ++++
 .../transport-aisdk/src/client-tools.ts       | 23 +++++++++++++++++++
 .../packages/transport-aisdk/vite.config.ts   |  5 +++-
 yarn.lock                                     |  1 +
 4 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 libs/@hashintel/brunch-agent/packages/transport-aisdk/src/client-tools.ts

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/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"

From 67d314495bb1cd1e07e2458f715f712dac5dc7c1 Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Mon, 31 Aug 2026 21:25:47 +0200
Subject: [PATCH 5/8] Format Petrinaut voice preview imports

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../src/main/app/local-storage-demo/local-storage-demo-app.tsx  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 7ff93705108..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
@@ -24,9 +24,9 @@ import {
 } from "@hashintel/petrinaut/ui";
 
 import { useSentryFeedbackAction } from "../sentry-feedback-button";
-import { getOrCreateBrunchConversationId } from "./brunch-conversation-id";
 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";

From 7f81262332ae8d10751eab95009e2fea836f9785 Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Mon, 31 Aug 2026 23:16:20 +0200
Subject: [PATCH 6/8] Preserve realtime input across busy and aborted requests

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../voice-turn-controller.test.ts             | 59 +++++++++++++++++++
 .../voice-interview/voice-turn-controller.ts  | 50 +++++++++++++---
 .../server/voice/openai-realtime-call.test.ts | 44 ++++++++++++++
 .../src/server/voice/openai-realtime-call.ts  | 26 ++++----
 4 files changed, 161 insertions(+), 18 deletions(-)

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
index 5b609337bf0..2c10d6c5850 100644
--- 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
@@ -152,6 +152,65 @@ describe("VoiceTurnController", () => {
     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("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();
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
index 81890acbd24..9c9774638c3 100644
--- 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
@@ -76,6 +76,7 @@ export class VoiceTurnController {
   #awaitingChatCycle = false;
   #chatStatus: ChatStatus = "ready";
   #generation = 0;
+  #pendingDelivery: SubmitTextInput | null = null;
   #sawBusyChatStatus = false;
   #snapshot = initialSnapshot;
 
@@ -150,6 +151,7 @@ export class VoiceTurnController {
     this.#activeItemId = null;
     this.#activeKey = null;
     this.#awaitingChatCycle = false;
+    this.#pendingDelivery = null;
     this.#sawBusyChatStatus = false;
     this.#session.setMicrophoneEnabled(false);
     await this.#session.disconnect();
@@ -187,9 +189,18 @@ export class VoiceTurnController {
   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 === "listening" ||
+          this.#snapshot.phase === "transcribing")
       ) {
         this.#session.setMicrophoneEnabled(false);
         this.#update({ phase: "waiting" });
@@ -230,6 +241,13 @@ export class VoiceTurnController {
   }
 
   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;
@@ -247,6 +265,13 @@ export class VoiceTurnController {
       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({
@@ -272,6 +297,7 @@ export class VoiceTurnController {
       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" });
@@ -282,7 +308,8 @@ export class VoiceTurnController {
         event.connectionEpoch !== this.#activeEpoch ||
         (this.#activeItemId !== null && this.#activeItemId !== event.itemId) ||
         (this.#snapshot.phase !== "listening" &&
-          this.#snapshot.phase !== "transcribing")
+          this.#snapshot.phase !== "transcribing" &&
+          this.#snapshot.phase !== "waiting")
       ) {
         return;
       }
@@ -295,7 +322,8 @@ export class VoiceTurnController {
     if (
       event.key.connectionEpoch !== this.#activeEpoch ||
       (this.#snapshot.phase !== "listening" &&
-        this.#snapshot.phase !== "transcribing")
+        this.#snapshot.phase !== "transcribing" &&
+        this.#snapshot.phase !== "waiting")
     ) {
       return;
     }
@@ -337,16 +365,22 @@ export class VoiceTurnController {
     }
 
     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: "delivering",
-    });
-    void this.#deliver({
-      id: createVoiceMessageId(this.#conversationId, event.key),
-      text: finalText,
+      phase: canDeliver ? "delivering" : "waiting",
     });
+    if (canDeliver) {
+      void this.#deliver(input);
+    } else {
+      this.#pendingDelivery = input;
+    }
   }
 
   #reopenListeningIfReady(): void {
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
index d1556b3af95..7c2a182ec96 100644
--- a/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.test.ts
@@ -162,6 +162,50 @@ describe("OpenAI Realtime call handler", () => {
     );
   });
 
+  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>(
diff --git a/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
index f12cdd90497..c2bb864e37b 100644
--- a/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
+++ b/apps/petrinaut-website/src/server/voice/openai-realtime-call.ts
@@ -76,16 +76,6 @@ export const createOpenAIRealtimeCallHandler =
       return response("Not found.", 404);
     }
 
-    const sdp = await readSdpOffer(request);
-    if (sdp instanceof Response) {
-      return sdp;
-    }
-
-    const session = createOpenAITranscriptionSession();
-    const form = new FormData();
-    form.set("sdp", sdp);
-    form.set("session", JSON.stringify(session));
-
     const abortController = new AbortController();
     const abortForTimeout = () => abortController.abort(timeoutError);
     const abortForRequest = () => abortController.abort();
@@ -94,8 +84,24 @@ export const createOpenAIRealtimeCallHandler =
       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: {

From 24df8d4b71c62ae2279c782990519ee4401522ce Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Tue, 1 Sep 2026 00:10:44 +0200
Subject: [PATCH 7/8] Queue voice turns at the composer boundary

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .changeset/stable-composer-controls.md        |  3 +-
 .../local-storage-demo-app.test.tsx           |  4 +
 .../voice-interview-control.test.tsx          |  4 +
 .../voice-interview-control.tsx               |  5 +-
 .../@hashintel/petrinaut/docs/ai-assistant.md |  2 +
 .../ui/types/ai-assistant-composer-control.ts | 19 +++--
 .../Editor/panels/ai-assistant-panel.test.tsx | 85 +++++++++++++++++++
 .../Editor/panels/ai-assistant-panel.tsx      | 56 ++++++++++++
 8 files changed, 169 insertions(+), 9 deletions(-)

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/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
index 72e031327fd..619709b1d04 100644
--- 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
@@ -30,6 +30,10 @@ describe("local storage demo Brunch voice integration", () => {
         kind: "message" as const,
         messageId: "message-1",
       })),
+      submitVoiceInput: vi.fn(async () => ({
+        kind: "message" as const,
+        messageId: "voice-message-1",
+      })),
     });
 
     expect(isValidElement(control)).toBe(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
index b9279a962ad..106d3ce7857 100644
--- 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
@@ -146,6 +146,10 @@ describe("voice interview control", () => {
                 kind: "message" as const,
                 messageId: "message-1",
               }))}
+              submitVoiceInput={vi.fn(async () => ({
+                kind: "message" as const,
+                messageId: "voice-message-1",
+              }))}
             />
           </StrictMode>,
         );
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
index 69c1e891f45..32afc58f1d0 100644
--- 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
@@ -1,6 +1,7 @@
 import {
   type FormEvent,
   useEffect,
+  useLayoutEffect,
   useState,
   useSyncExternalStore,
 } from "react";
@@ -313,7 +314,7 @@ const AvailableVoiceInterviewControl = ({
     const controller = new VoiceTurnController({
       conversationId: context.conversationId,
       session,
-      submitText: context.submitText,
+      submitText: context.submitVoiceInput,
     });
     return {
       controller,
@@ -329,7 +330,7 @@ const AvailableVoiceInterviewControl = ({
   );
   const [correction, setCorrection] = useState("");
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     store.controller.updateChatStatus(context.status);
   }, [context.status, store]);
 
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

From 5d3c3d4d5bbf9a49c93b0b99a3046d532882753e Mon Sep 17 00:00:00 2001
From: Kostandin Angjellari <kostandinangjellari@gmail.com>
Date: Tue, 1 Sep 2026 14:35:04 +0200
Subject: [PATCH 8/8] Preserve the first pending voice turn

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../voice-turn-controller.test.ts             | 37 +++++++++++++++++++
 .../voice-interview/voice-turn-controller.ts  |  3 ++
 2 files changed, 40 insertions(+)

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
index 2c10d6c5850..4f1384d530b 100644
--- 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
@@ -184,6 +184,43 @@ describe("VoiceTurnController", () => {
     );
   });
 
+  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 () => {
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
index 9c9774638c3..adffa720b0c 100644
--- 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
@@ -303,6 +303,9 @@ export class VoiceTurnController {
       this.#update({ errorMessage: event.message, phase: "recoverable-error" });
       return;
     }
+    if (this.#pendingDelivery !== null) {
+      return;
+    }
     if (event.type === "input-committed") {
       if (
         event.connectionEpoch !== this.#activeEpoch ||