diff --git a/.changeset/stable-composer-controls.md b/.changeset/stable-composer-controls.md
index a648d9c4a80..423e83029fb 100644
--- a/.changeset/stable-composer-controls.md
+++ b/.changeset/stable-composer-controls.md
@@ -30,10 +30,14 @@ per-session Show transcription in chat action write those turns into the convers
 instead. Keep every session control -- transcription, the microphone toggle, Resume, Reconnect, and
 End -- in the dock, leaving the canvas toolbar untouched. Add `setMicrophoneMuted` to the Voice mode
 controls and a `muted` session phase, so muting stops capture without interrupting what the assistant
-is saying, unlike pausing. Surface voice recovery failures as toasts with privacy-safe diagnostic
-references, and request one-time consent before the host starts the microphone. Mark persisted spoken
-messages and the exact interactive-tool answer completed by Voice with an inline Voice chip ahead of
-the words themselves.
+is saying, unlike pausing. Add an accessible manual Your turn control that cancels pending Voice
+speech and hands the live microphone turn back to the user without disconnecting the session. Surface
+voice recovery failures as toasts with privacy-safe diagnostic references, and request one-time
+consent before the host starts the microphone. Mark persisted spoken messages and every
+interactive-tool answer completed by Voice with visible provenance. Persisted spoken messages and
+Brunch answer bubbles use the same compact, icon-only waveform indicator. Add a backwards-compatible
+submitted-output provenance slot to interactive-tool widgets: opted-in widgets can position Voice
+provenance beside their submitted value, while existing widgets retain the trailing fallback.
 
 End Voice mode before submitting typed text exactly once through the shared composer, preserving the
 draft if handoff fails. Pause active media before the AI panel closes and reopen the mounted session
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
deleted file mode 100644
index c7db816a6b9..00000000000
--- a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-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.test.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.tsx
new file mode 100644
index 00000000000..4ec3cadb006
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-interactive-tool.test.tsx
@@ -0,0 +1,57 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { cleanup, render, screen, within } from "@testing-library/react";
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+vi.mock("@hashintel/petrinaut/ui", () => ({
+  definePetrinautAiInteractiveTool: (definition: unknown) => definition,
+}));
+
+import * as brunchAskInteractiveToolModule from "./brunch-ask-interactive-tool";
+import { brunchAskFromComposerText } from "./brunch-ask-mapping";
+import { BrunchAskWidget } from "./brunch-ask-widget";
+
+afterEach(cleanup);
+
+describe("Brunch ask Fast Refresh boundary", () => {
+  test("keeps the interactive-tool module free of component exports", () => {
+    expect(Object.keys(brunchAskInteractiveToolModule)).toEqual([
+      "brunchAskInteractiveTool",
+    ]);
+  });
+});
+
+describe("Brunch ask widget", () => {
+  test("renders voice provenance inside the submitted answer bubble", () => {
+    render(
+      <BrunchAskWidget
+        input={{ question: "What can customers do at the ATM?" }}
+        state="submitted"
+        submit={() => {}}
+        submittedOutput={{ answer: "ATM withdrawal." }}
+        submittedOutputProvenance={<span data-testid="answer-provenance" />}
+        toolCallId="brunch-ask-1"
+      />,
+    );
+
+    const answerText = screen.getByText("ATM withdrawal.");
+    const answerBubble = answerText.closest(
+      '[data-role="user-answer"]',
+    ) as HTMLElement;
+    const provenance = within(answerBubble).getByTestId("answer-provenance");
+
+    expect(provenance.nextElementSibling).toBe(answerText);
+  });
+});
+
+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
index 7c4d01b4442..01119606a48 100644
--- 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
@@ -1,151 +1,18 @@
-import { type FormEvent, useId, useState } from "react";
-
 import {
   ASK_TOOL_NAME,
-  type BrunchAskInput,
-  type BrunchAskOutput,
   parseBrunchAskInput,
   parseBrunchAskOutput,
 } from "@hashintel/brunch-agent/client-tools";
-import { css } from "@hashintel/ds-helpers/css";
-import {
-  definePetrinautAiInteractiveTool,
-  type PetrinautAiInteractiveToolWidgetProps,
-} from "@hashintel/petrinaut/ui";
+import { definePetrinautAiInteractiveTool } 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>
-  );
-};
+import { BrunchAskWidget } from "./brunch-ask-widget";
 
 export const brunchAskInteractiveTool = definePetrinautAiInteractiveTool({
   toolName: ASK_TOOL_NAME,
   inputSchema: { parse: parseBrunchAskInput },
   outputSchema: { parse: parseBrunchAskOutput },
   fromComposerText: brunchAskFromComposerText,
+  supportsSubmittedOutputProvenance: true,
   component: BrunchAskWidget,
 });
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-widget.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-widget.tsx
new file mode 100644
index 00000000000..f5e37e9b63d
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-ask-widget.tsx
@@ -0,0 +1,158 @@
+import { type FormEvent, useId, useState } from "react";
+
+import {
+  type BrunchAskInput,
+  type BrunchAskOutput,
+} from "@hashintel/brunch-agent/client-tools";
+import { css } from "@hashintel/ds-helpers/css";
+
+import type { PetrinautAiInteractiveToolWidgetProps } from "@hashintel/petrinaut/ui";
+
+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 answerTurnStyle = css({
+  display: "flex",
+  justifyContent: "flex-end",
+});
+
+const answerStyle = css({
+  maxWidth: "[92%]",
+  minWidth: "0",
+  paddingX: "2",
+  paddingY: "[6px]",
+  borderWidth: "thin",
+  borderStyle: "solid",
+  borderColor: "neutral.a20",
+  borderRadius: "xl",
+  borderBottomRightRadius: "sm",
+  backgroundColor: "neutral.s20",
+  color: "neutral.s100",
+  fontSize: "sm",
+  fontWeight: "medium",
+  textAlign: "right",
+  whiteSpace: "pre-wrap",
+  wordBreak: "break-word",
+});
+
+export const BrunchAskWidget = ({
+  input,
+  state,
+  submit,
+  submittedOutput,
+  submittedOutputProvenance,
+}: 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" ? (
+        <div className={answerTurnStyle}>
+          <p className={answerStyle} data-role="user-answer">
+            {submittedOutputProvenance}
+            <span>{submittedOutput.answer}</span>
+          </p>
+        </div>
+      ) : (
+        <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>
+  );
+};
diff --git a/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-voice-mode.tsx b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-voice-mode.tsx
new file mode 100644
index 00000000000..de0bcbe4cf0
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/local-storage-demo/brunch-voice-mode.tsx
@@ -0,0 +1,16 @@
+import {
+  type PetrinautAiVoiceMode,
+  type PetrinautAiVoiceModeContext,
+} from "@hashintel/petrinaut/ui";
+
+import { type OpenAIVoiceConfig } from "../voice-interview/load-openai-voice-config";
+import { VoiceInterviewControl } from "../voice-interview/voice-interview-control";
+
+export const getBrunchVoiceMode = (
+  config: OpenAIVoiceConfig | null | undefined,
+): PetrinautAiVoiceMode | undefined =>
+  config
+    ? (context: PetrinautAiVoiceModeContext) => (
+        <VoiceInterviewControl {...context} config={config} />
+      )
+    : undefined;
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 6fe948c18a2..23fe91972cd 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
@@ -5,7 +5,8 @@ import { isValidElement, type ReactNode } from "react";
 import { describe, expect, test, vi } from "vitest";
 
 import { VoiceInterviewControl } from "../voice-interview/voice-interview-control";
-import { getBrunchVoiceMode } from "./local-storage-demo-app";
+import { getBrunchVoiceMode } from "./brunch-voice-mode";
+import * as localStorageDemoAppModule from "./local-storage-demo-app";
 
 const defaultTransportOptions = vi.hoisted(() => ({
   current: null as unknown,
@@ -26,6 +27,14 @@ vi.mock("@hashintel/petrinaut/ui", () => ({
   definePetrinautAiInteractiveTool: (definition: unknown) => definition,
 }));
 
+describe("local storage demo Fast Refresh boundary", () => {
+  test("keeps the app module free of non-component exports", () => {
+    expect(Object.keys(localStorageDemoAppModule)).toEqual([
+      "LocalStorageDemoApp",
+    ]);
+  });
+});
+
 describe("local storage demo Brunch voice integration", () => {
   test("does not install voice on the generic local chat fallback", () => {
     expect(getBrunchVoiceMode(null)).toBeUndefined();
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 34286fb3c69..0201782a81e 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
@@ -18,8 +18,6 @@ import {
   DefaultChatTransport,
   Petrinaut,
   type PetrinautAiMessage,
-  type PetrinautAiVoiceMode,
-  type PetrinautAiVoiceModeContext,
   WalkthroughProvider,
 } from "@hashintel/petrinaut/ui";
 
@@ -28,13 +26,13 @@ import { useSentryFeedbackAction } from "../sentry-feedback-button";
 import {
   loadOpenAIVoiceConfig,
   type OpenAIVoiceConfig,
-  VoiceInterviewControl,
-} from "../voice-interview/voice-interview-control";
+} from "../voice-interview/load-openai-voice-config";
 import { brunchAskInteractiveTool } from "./brunch-ask-interactive-tool";
 import { getOrCreateBrunchConversationId } from "./brunch-conversation-id";
 import { createBrunchPanelTransport } from "./brunch-panel-transport";
 import { resolveBrunchPreviewConfig } from "./brunch-preview-config";
 import { getOrCreateBrunchPrincipal } from "./brunch-principal";
+import { getBrunchVoiceMode } from "./brunch-voice-mode";
 import { useFlueChatHistory } from "./use-flue-chat-history";
 import { useLocalStorageAiMessages } from "./use-local-storage-ai-messages";
 import {
@@ -101,15 +99,6 @@ const brunchHistoryEndpoint = brunchPreviewConfig.isBrunchConfigured
   ? brunchPreviewConfig.chatEndpoint
   : null;
 
-export const getBrunchVoiceMode = (
-  config: OpenAIVoiceConfig | null | undefined,
-): PetrinautAiVoiceMode | undefined =>
-  config
-    ? (context: PetrinautAiVoiceModeContext) => (
-        <VoiceInterviewControl {...context} config={config} />
-      )
-    : undefined;
-
 const createHandle = (net: SDCPNInLocalStorage): PetrinautDocHandle =>
   createJsonDocHandle({
     id: net.id,
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/load-openai-voice-config.ts b/apps/petrinaut-website/src/main/app/voice-interview/load-openai-voice-config.ts
new file mode 100644
index 00000000000..a6483ac9e2c
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/load-openai-voice-config.ts
@@ -0,0 +1,39 @@
+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;
+  }
+};
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 9f260841a96..5f42eda2f9b 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
@@ -376,6 +376,89 @@ describe("OpenAIRealtimeSession", () => {
     expect(harness.localTracks[0]!.enabled).toBe(false);
   });
 
+  test("cancels buffered speech before accepting a fresh post-handoff utterance", async () => {
+    const harness = createHarness();
+    await harness.session.connect();
+    harness.session.setMicrophoneEnabled(true);
+    const channel = harness.channels[0]!;
+    channel.receive({
+      audio_start_ms: 40,
+      item_id: "item-before-handoff",
+      type: "input_audio_buffer.speech_started",
+    });
+    harness.session.speakCanonical([
+      canonicalSegment("ask-handoff", "What happens next?"),
+    ]);
+    authorizeLatestSpeechResponse(channel, "response-handoff");
+    channel.receive({
+      response_id: "response-handoff",
+      type: "output_audio_buffer.started",
+    });
+
+    const cancellation = harness.session.cancelOutput();
+
+    expect(harness.localTracks[0]!.enabled).toBe(false);
+    expect(sentEvents(channel).slice(-3)).toEqual([
+      { type: "input_audio_buffer.clear" },
+      expect.objectContaining({
+        response_id: "response-handoff",
+        type: "response.cancel",
+      }),
+      { type: "output_audio_buffer.clear" },
+    ]);
+    channel.receive({
+      content_index: 0,
+      item_id: "item-before-handoff",
+      transcript: "This began too early.",
+      type: "conversation.item.input_audio_transcription.completed",
+    });
+    channel.receive({ type: "input_audio_buffer.cleared" });
+    channel.receive({
+      response_id: "response-handoff",
+      type: "output_audio_buffer.cleared",
+    });
+    channel.receive({
+      response: {
+        id: "response-handoff",
+        output: [],
+        status: "cancelled",
+      },
+      type: "response.done",
+    });
+    await cancellation;
+
+    expect(harness.localTracks[0]!.enabled).toBe(true);
+    expect(
+      harness.events.some(
+        (event) =>
+          event.type === "completed" &&
+          event.key.itemId === "item-before-handoff",
+      ),
+    ).toBe(false);
+    channel.receive({
+      audio_start_ms: 120,
+      item_id: "item-after-handoff",
+      type: "input_audio_buffer.speech_started",
+    });
+    channel.receive({
+      content_index: 0,
+      item_id: "item-after-handoff",
+      transcript: "This began after the handoff.",
+      type: "conversation.item.input_audio_transcription.completed",
+    });
+
+    expect(harness.events).toContainEqual({
+      key: {
+        connectionEpoch: 1,
+        contentIndex: 0,
+        itemId: "item-after-handoff",
+      },
+      text: "This began after the handoff.",
+      type: "completed",
+    });
+    expect(harness.localTracks[0]!.stop).not.toHaveBeenCalled();
+  });
+
   test("never surfaces model-generated function-call arguments as user speech", async () => {
     const harness = createHarness();
     await harness.session.connect();
@@ -670,17 +753,20 @@ describe("OpenAIRealtimeSession", () => {
       type: "response.created",
     });
 
-    harness.session.cancelOutput();
+    void harness.session.cancelOutput();
 
     await expect(preparation).resolves.toEqual({
       kind: "fallback",
       reason: "interrupted",
       sourceSegmentIds: request.sourceSegmentIds,
     });
-    expect(sentEvents(channel).slice(-1)[0]).toMatchObject({
-      response_id: "response-preparation",
-      type: "response.cancel",
-    });
+    expect(sentEvents(channel).slice(-2)).toEqual([
+      expect.objectContaining({
+        response_id: "response-preparation",
+        type: "response.cancel",
+      }),
+      { type: "output_audio_buffer.clear" },
+    ]);
     channel.receive({
       delta: "Late output must be ignored.",
       response_id: "response-preparation",
@@ -860,7 +946,7 @@ describe("OpenAIRealtimeSession", () => {
     ]);
     const responseCreate = sentEvents(channel)[0]!;
 
-    harness.session.cancelOutput();
+    void harness.session.cancelOutput();
 
     expect(
       sentEvents(channel).filter(({ type }) => type === "response.cancel"),
@@ -990,6 +1076,7 @@ describe("OpenAIRealtimeSession", () => {
   test("ignores a correlated cancel for an already-finished response", async () => {
     const harness = createHarness();
     await harness.session.connect();
+    harness.session.setMicrophoneEnabled(true);
     const channel = harness.channels[0]!;
     harness.session.speakCanonical([
       canonicalSegment("question", "Canonical question"),
@@ -1007,7 +1094,7 @@ describe("OpenAIRealtimeSession", () => {
       type: "output_audio_buffer.started",
     });
 
-    harness.session.cancelOutput();
+    const cancellation = harness.session.cancelOutput();
     const cancelEvent = sentEvents(channel).findLast(
       ({ type }) => type === "response.cancel",
     )!;
@@ -1024,10 +1111,17 @@ describe("OpenAIRealtimeSession", () => {
       },
       type: "error",
     });
+    channel.receive({ type: "input_audio_buffer.cleared" });
+    channel.receive({
+      response_id: "response-canonical",
+      type: "output_audio_buffer.cleared",
+    });
+    await cancellation;
 
     expect(harness.events).not.toContainEqual(
       expect.objectContaining({ type: "error" }),
     );
+    expect(harness.localTracks[0]!.enabled).toBe(true);
     expect(harness.localTracks[0]!.stop).not.toHaveBeenCalled();
   });
 
@@ -1051,7 +1145,7 @@ describe("OpenAIRealtimeSession", () => {
       type: "output_audio_buffer.started",
     });
 
-    harness.session.cancelOutput();
+    void harness.session.cancelOutput();
     const cancelEvent = sentEvents(channel).findLast(
       ({ type }) => type === "response.cancel",
     )!;
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 6bbd9e36be6..0312d2d7013 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
@@ -243,6 +243,7 @@ const waitForAbort = <Value>(
 };
 
 export class OpenAIRealtimeSession {
+  readonly #acceptedInputItemIds = new Set<string>();
   readonly #dependencies: OpenAIRealtimeSessionDependencies;
   readonly #activeResponseIds = new Set<string>();
   readonly #listeners = new Set<SessionListener>();
@@ -250,6 +251,8 @@ export class OpenAIRealtimeSession {
   readonly #cancelledCanonicalResponseIds = new Set<string>();
   readonly #cancelledPreparationRequestIds = new Set<string>();
   readonly #cancelledSpeechRequestIds = new Set<string>();
+  readonly #cancelOutputAwaitingRequestIds = new Set<string>();
+  readonly #cancelOutputAwaitingResponseIds = new Set<string>();
   readonly #canonicalResponseIds = new Set<string>();
   readonly #completedResponseCancelEventIds = new Set<string>();
   readonly #pendingClientEvents = new Map<string, PendingClientEvent>();
@@ -271,6 +274,10 @@ export class OpenAIRealtimeSession {
   #connected = false;
   #connectedAt: number | null = null;
   #clientEventSequence = 0;
+  #cancelOutputAwaitingInputBufferClear = false;
+  #cancelOutputAwaitingOutputBufferResponseId: string | null = null;
+  #cancelOutputPromise: Promise<void> | null = null;
+  #cancelOutputResolve: (() => void) | null = null;
   #connectionRequestId: string | null = null;
   #dataChannel: RTCDataChannel | null = null;
   #epoch = 0;
@@ -284,6 +291,7 @@ export class OpenAIRealtimeSession {
   #microphoneTrack: MediaStreamTrack | null = null;
   #peerConnection: RTCPeerConnection | null = null;
   #remoteAudio: RemoteAudio | null = null;
+  #requireInputSpeechStart = false;
   #responseCreateEventId: string | null = null;
   #responseTerminalSequence = 0;
   #speakingResponseId: string | null = null;
@@ -557,59 +565,95 @@ export class OpenAIRealtimeSession {
     });
   }
 
-  public cancelOutput(): void {
+  public cancelOutput(): Promise<void> {
     if (!this.#connected || this.#dataChannel?.readyState !== "open") {
-      return;
+      return Promise.resolve();
     }
-
-    for (const request of this.#responseQueue.splice(0)) {
-      if (request.kind === "canonical-speech") {
-        this.#cancelPendingSpeechRequest(request.speechRequestId);
-      } else {
-        this.#settlePreparation(request.preparationRequestId, "interrupted");
-      }
+    if (this.#cancelOutputPromise) {
+      return this.#cancelOutputPromise;
     }
 
-    if (this.#responseCreateEventId !== null) {
-      const pendingEvent = this.#pendingClientEvents.get(
-        this.#responseCreateEventId,
-      );
-      if (pendingEvent?.kind === "response-create") {
-        if (pendingEvent.request.kind === "canonical-speech") {
-          this.#cancelledSpeechRequestIds.add(
-            pendingEvent.request.speechRequestId,
-          );
+    const cancelOutputPromise = new Promise<void>((resolve) => {
+      this.#cancelOutputResolve = resolve;
+    });
+    this.#cancelOutputPromise = cancelOutputPromise;
+    this.#cancelOutputAwaitingInputBufferClear = true;
+    this.#cancelOutputAwaitingOutputBufferResponseId = this.#speakingResponseId;
+    this.#requireInputSpeechStart = true;
+    for (const itemId of this.#acceptedInputItemIds) {
+      this.#playbackOverlappingInputItemIds.add(itemId);
+    }
+    this.#acceptedInputItemIds.clear();
+    this.#syncMicrophoneTrack();
+
+    try {
+      this.#send({ type: "input_audio_buffer.clear" });
+
+      for (const request of this.#responseQueue.splice(0)) {
+        if (request.kind === "canonical-speech") {
+          this.#cancelPendingSpeechRequest(request.speechRequestId);
         } else {
-          this.#cancelledPreparationRequestIds.add(
-            pendingEvent.request.preparationRequestId,
-          );
-          this.#settlePreparation(
-            pendingEvent.request.preparationRequestId,
-            "interrupted",
-          );
+          this.#settlePreparation(request.preparationRequestId, "interrupted");
         }
       }
-    }
 
-    for (const [
-      responseId,
-      preparationRequestId,
-    ] of this.#preparationResponseIds) {
-      if (this.#activeResponseIds.has(responseId)) {
-        this.#settlePreparation(preparationRequestId, "interrupted");
-        this.#cancelResponse(responseId);
+      if (this.#responseCreateEventId !== null) {
+        const pendingEvent = this.#pendingClientEvents.get(
+          this.#responseCreateEventId,
+        );
+        if (pendingEvent?.kind === "response-create") {
+          if (pendingEvent.request.kind === "canonical-speech") {
+            this.#cancelledSpeechRequestIds.add(
+              pendingEvent.request.speechRequestId,
+            );
+            this.#cancelOutputAwaitingRequestIds.add(
+              pendingEvent.request.speechRequestId,
+            );
+          } else {
+            this.#cancelledPreparationRequestIds.add(
+              pendingEvent.request.preparationRequestId,
+            );
+            this.#cancelOutputAwaitingRequestIds.add(
+              pendingEvent.request.preparationRequestId,
+            );
+            this.#settlePreparation(
+              pendingEvent.request.preparationRequestId,
+              "interrupted",
+            );
+          }
+        }
       }
-    }
 
-    for (const responseId of this.#canonicalResponseIds) {
-      if (
-        this.#activeResponseIds.has(responseId) &&
-        !this.#cancelledCanonicalResponseIds.has(responseId)
-      ) {
-        this.#cancelledCanonicalResponseIds.add(responseId);
-        this.#cancelOutputResponse(responseId);
+      for (const [
+        responseId,
+        preparationRequestId,
+      ] of this.#preparationResponseIds) {
+        if (this.#activeResponseIds.has(responseId)) {
+          this.#cancelOutputAwaitingResponseIds.add(responseId);
+          this.#settlePreparation(preparationRequestId, "interrupted");
+          this.#cancelResponse(responseId);
+        }
       }
+
+      for (const responseId of this.#canonicalResponseIds) {
+        if (
+          this.#activeResponseIds.has(responseId) &&
+          !this.#cancelledCanonicalResponseIds.has(responseId)
+        ) {
+          this.#cancelOutputAwaitingResponseIds.add(responseId);
+          this.#cancelledCanonicalResponseIds.add(responseId);
+          this.#cancelResponse(responseId);
+        }
+      }
+
+      this.#send({ type: "output_audio_buffer.clear" });
+    } catch {
+      this.#finishOutputCancellation(true);
+      this.#handleConnectionFailure("network", "speech");
     }
+
+    this.#finishOutputCancellation();
+    return cancelOutputPromise;
   }
 
   #cancelOutputResponse(responseId: string): void {
@@ -776,6 +820,12 @@ export class OpenAIRealtimeSession {
       this.#handlePreparationDelta(parsed);
       return;
     }
+    if (parsed.type === "input_audio_buffer.cleared") {
+      this.#acceptedInputItemIds.clear();
+      this.#cancelOutputAwaitingInputBufferClear = false;
+      this.#finishOutputCancellation();
+      return;
+    }
     if (parsed.type === "input_audio_buffer.committed") {
       const itemId = nonEmptyString(parsed.item_id);
       if (itemId) this.#startTranscription(itemId);
@@ -784,10 +834,11 @@ export class OpenAIRealtimeSession {
     if (parsed.type === "input_audio_buffer.speech_started") {
       const itemId = nonEmptyString(parsed.item_id);
       if (!itemId || nonNegativeInteger(parsed.audio_start_ms) === null) return;
-      if (this.#speakingResponseId) {
+      if (this.#speakingResponseId || !this.#microphoneTrack?.enabled) {
         this.#playbackOverlappingInputItemIds.add(itemId);
         return;
       }
+      this.#acceptedInputItemIds.add(itemId);
       this.#emit({
         connectionEpoch,
         itemId,
@@ -808,7 +859,8 @@ export class OpenAIRealtimeSession {
     }
     if (
       parsed.type === "output_audio_buffer.started" ||
-      parsed.type === "output_audio_buffer.stopped"
+      parsed.type === "output_audio_buffer.stopped" ||
+      parsed.type === "output_audio_buffer.cleared"
     ) {
       this.#handleOutputBufferEvent(parsed, connectionEpoch);
       return;
@@ -834,6 +886,9 @@ export class OpenAIRealtimeSession {
     if (!correlatedRequestId) {
       return;
     }
+    if (this.#cancelOutputAwaitingRequestIds.delete(correlatedRequestId)) {
+      this.#cancelOutputAwaitingResponseIds.add(responseId);
+    }
 
     if (metadata?.petrinaut_kind === "speech-preparation") {
       const correlated = this.#completeResponseCreateEvent(
@@ -945,6 +1000,10 @@ export class OpenAIRealtimeSession {
     ) {
       this.#pendingClientEvents.delete(sourceEventId);
       this.#completedResponseCancelEventIds.delete(sourceEventId);
+      if (pendingEvent?.kind === "response-cancel") {
+        this.#cancelOutputAwaitingResponseIds.delete(pendingEvent.responseId);
+        this.#finishOutputCancellation();
+      }
       return;
     }
 
@@ -964,7 +1023,11 @@ export class OpenAIRealtimeSession {
           pendingEvent.request.speechRequestId,
         )
       ) {
+        this.#cancelOutputAwaitingRequestIds.delete(
+          pendingEvent.request.speechRequestId,
+        );
         this.#cancelPendingSpeechRequest(pendingEvent.request.speechRequestId);
+        this.#finishOutputCancellation();
         return;
       }
       if (
@@ -973,10 +1036,14 @@ export class OpenAIRealtimeSession {
           pendingEvent.request.preparationRequestId,
         )
       ) {
+        this.#cancelOutputAwaitingRequestIds.delete(
+          pendingEvent.request.preparationRequestId,
+        );
         this.#settlePreparation(
           pendingEvent.request.preparationRequestId,
           "interrupted",
         );
+        this.#finishOutputCancellation();
         return;
       }
       this.#responseQueue.unshift(pendingEvent.request);
@@ -1000,6 +1067,10 @@ export class OpenAIRealtimeSession {
         pendingEvent.request.preparationRequestId,
         "provider-error",
       );
+      this.#cancelOutputAwaitingRequestIds.delete(
+        pendingEvent.request.preparationRequestId,
+      );
+      this.#finishOutputCancellation();
       this.#resumeSerializedResponseQueue();
       return;
     }
@@ -1028,6 +1099,8 @@ export class OpenAIRealtimeSession {
     }
     this.#responseTerminalSequence += 1;
     this.#activeResponseIds.delete(responseId);
+    this.#cancelOutputAwaitingResponseIds.delete(responseId);
+    this.#finishOutputCancellation();
     this.#clearResponseCancelEvents(responseId);
     this.#waitingForResponseTerminal = false;
 
@@ -1247,6 +1320,9 @@ export class OpenAIRealtimeSession {
     if (!responseId) return;
     if (event.type === "output_audio_buffer.started") {
       if (this.#cancelledCanonicalResponseIds.has(responseId)) {
+        if (this.#cancelOutputPromise) {
+          this.#cancelOutputAwaitingOutputBufferResponseId = responseId;
+        }
         this.#send({ type: "output_audio_buffer.clear" });
         return;
       }
@@ -1261,14 +1337,23 @@ export class OpenAIRealtimeSession {
       return;
     }
     const wasSpeaking = this.#speakingResponseId === responseId;
+    const wasCleared = event.type === "output_audio_buffer.cleared";
     this.#finishSpeech(
       responseId,
-      this.#cancelledCanonicalResponseIds.has(responseId)
+      wasCleared || this.#cancelledCanonicalResponseIds.has(responseId)
         ? "request-aborted"
         : undefined,
     );
     if (wasSpeaking) {
-      this.#emit({ connectionEpoch, responseId, type: "output-stopped" });
+      this.#emit({
+        connectionEpoch,
+        responseId,
+        type: wasCleared ? "output-interrupted" : "output-stopped",
+      });
+    }
+    if (this.#cancelOutputAwaitingOutputBufferResponseId === responseId) {
+      this.#cancelOutputAwaitingOutputBufferResponseId = null;
+      this.#finishOutputCancellation();
     }
   }
 
@@ -1280,7 +1365,10 @@ export class OpenAIRealtimeSession {
     const contentIndex = nonNegativeInteger(event.content_index);
     if (!itemId || contentIndex === null) return;
     const key = { connectionEpoch, contentIndex, itemId };
-    const overlapsPlayback = this.#playbackOverlappingInputItemIds.has(itemId);
+    const overlapsPlayback =
+      this.#playbackOverlappingInputItemIds.has(itemId) ||
+      (this.#requireInputSpeechStart &&
+        !this.#acceptedInputItemIds.has(itemId));
     if (overlapsPlayback) {
       if (
         event.type ===
@@ -1293,12 +1381,14 @@ export class OpenAIRealtimeSession {
             ? "invalid-response"
             : undefined,
         );
+        this.#acceptedInputItemIds.delete(itemId);
       }
       return;
     }
     this.#startTranscription(itemId);
     if (event.type === "conversation.item.input_audio_transcription.failed") {
       this.#finishTranscription(itemId, "invalid-response");
+      this.#acceptedInputItemIds.delete(itemId);
       this.#emit({ key, type: "transcription-failed" });
       return;
     }
@@ -1311,6 +1401,7 @@ export class OpenAIRealtimeSession {
       event.type === "conversation.item.input_audio_transcription.completed"
     ) {
       this.#finishTranscription(itemId);
+      this.#acceptedInputItemIds.delete(itemId);
     }
     this.#emit({
       key,
@@ -1354,6 +1445,29 @@ export class OpenAIRealtimeSession {
     }
   }
 
+  #finishOutputCancellation(force = false): void {
+    if (
+      !this.#cancelOutputPromise ||
+      (!force &&
+        (this.#cancelOutputAwaitingInputBufferClear ||
+          this.#cancelOutputAwaitingOutputBufferResponseId !== null ||
+          this.#cancelOutputAwaitingRequestIds.size > 0 ||
+          this.#cancelOutputAwaitingResponseIds.size > 0))
+    ) {
+      return;
+    }
+
+    const resolve = this.#cancelOutputResolve;
+    this.#cancelOutputPromise = null;
+    this.#cancelOutputResolve = null;
+    this.#cancelOutputAwaitingInputBufferClear = false;
+    this.#cancelOutputAwaitingOutputBufferResponseId = null;
+    this.#cancelOutputAwaitingRequestIds.clear();
+    this.#cancelOutputAwaitingResponseIds.clear();
+    this.#syncMicrophoneTrack();
+    resolve?.();
+  }
+
   #emit(event: OpenAIRealtimeSessionEvent): void {
     for (const listener of this.#listeners) listener(event);
   }
@@ -1539,6 +1653,7 @@ export class OpenAIRealtimeSession {
     const enabled =
       this.#microphoneRequested &&
       this.#connected &&
+      this.#cancelOutputPromise === null &&
       this.#speakingResponseId === null;
     this.#microphoneTrack.enabled = enabled;
     if (enabled) {
@@ -1640,6 +1755,8 @@ export class OpenAIRealtimeSession {
       );
     }
     this.#transcriptionTimings.clear();
+    this.#acceptedInputItemIds.clear();
+    this.#requireInputSpeechStart = false;
     this.#activeResponseIds.clear();
     this.#cancelledCanonicalResponseIds.clear();
     this.#cancelledPreparationRequestIds.clear();
@@ -1660,6 +1777,7 @@ export class OpenAIRealtimeSession {
     this.#waitingForResponseTerminal = false;
     this.#activeEpoch = null;
     this.#connected = false;
+    this.#finishOutputCancellation(true);
     this.#microphoneRequested = false;
     this.#connectedAt = null;
     this.#connectionRequestId = null;
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 4be3b7bcce4..2cb260db69f 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
@@ -12,14 +12,15 @@ import {
 import { StrictMode, useState } from "react";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 
+import { loadOpenAIVoiceConfig } from "./load-openai-voice-config";
 import { OpenAIRealtimeSession } from "./openai-realtime-session";
+import * as voiceInterviewControlModule from "./voice-interview-control";
+import { VoiceInterviewControl } from "./voice-interview-control";
 import {
   acknowledgeVoiceInterviewDisclosure,
   isVoiceInterviewDisclosureAcknowledged,
-  loadOpenAIVoiceConfig,
   VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY,
-  VoiceInterviewControl,
-} from "./voice-interview-control";
+} from "./voice-interview-disclosure";
 import { VoiceTurnController } from "./voice-turn-controller";
 
 import type {
@@ -179,6 +180,14 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
+describe("voice interview Fast Refresh boundary", () => {
+  test("keeps the control module free of non-component exports", () => {
+    expect(Object.keys(voiceInterviewControlModule)).toEqual([
+      "VoiceInterviewControl",
+    ]);
+  });
+});
+
 describe("voice interview control", () => {
   test("stores and reads the versioned disclosure acknowledgement", () => {
     const values = new Map<string, string>();
@@ -213,7 +222,7 @@ describe("voice interview control", () => {
     ).not.toThrow();
   });
 
-  test("registers canonical replay controls with the host", () => {
+  test("registers canonical replay and manual handoff controls with the host", () => {
     const repeatQuestion = vi.spyOn(
       VoiceTurnController.prototype,
       "repeatQuestion",
@@ -222,13 +231,16 @@ describe("voice interview control", () => {
       VoiceTurnController.prototype,
       "readFullResponse",
     );
+    const takeTurn = vi.spyOn(VoiceTurnController.prototype, "takeTurn");
     render(<VoiceInterviewHarness />);
 
     registeredVoiceModeControls?.repeatQuestion?.();
     registeredVoiceModeControls?.readFullResponse?.();
+    void registeredVoiceModeControls?.takeTurn?.();
 
     expect(repeatQuestion).toHaveBeenCalledOnce();
     expect(readFullResponse).toHaveBeenCalledOnce();
+    expect(takeTurn).toHaveBeenCalledOnce();
   });
 
   test("loads only a schema-valid available server configuration", async () => {
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 8e030fb725a..a16156923ba 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
@@ -13,6 +13,10 @@ import { reportVoiceDiagnostic } from "../../../voice-diagnostics";
 import { selectInterviewSpeech } from "./canonical-speech";
 import { OpenAIRealtimeSession } from "./openai-realtime-session";
 import { RealtimeBrunchBridge } from "./realtime-brunch-bridge";
+import {
+  acknowledgeVoiceInterviewDisclosure,
+  isVoiceInterviewDisclosureAcknowledged,
+} from "./voice-interview-disclosure";
 import { toVoiceSessionState } from "./voice-session-state";
 import {
   VoiceTurnController,
@@ -20,95 +24,9 @@ import {
   type VoiceTurnSnapshot,
 } from "./voice-turn-controller";
 
+import type { OpenAIVoiceConfig } from "./load-openai-voice-config";
 import type { PetrinautAiVoiceModeContext } from "@hashintel/petrinaut/ui";
 
-export interface OpenAIVoiceConfig {
-  readonly available: true;
-  readonly connectionTimeoutMs: number;
-}
-
-export const VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY =
-  "petrinaut:voice-interview-disclosure:v1";
-const VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED = "acknowledged";
-
-const getVoiceInterviewDisclosureStorage = (): Storage | null => {
-  if (typeof window === "undefined") {
-    return null;
-  }
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-};
-
-export const isVoiceInterviewDisclosureAcknowledged = (
-  storage: Pick<
-    Storage,
-    "getItem"
-  > | null = getVoiceInterviewDisclosureStorage(),
-): boolean => {
-  try {
-    return (
-      storage?.getItem(VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY) ===
-      VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED
-    );
-  } catch {
-    return false;
-  }
-};
-
-export const acknowledgeVoiceInterviewDisclosure = (
-  storage: Pick<
-    Storage,
-    "setItem"
-  > | null = getVoiceInterviewDisclosureStorage(),
-): void => {
-  try {
-    storage?.setItem(
-      VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY,
-      VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED,
-    );
-  } catch {
-    // Storage is optional; the disclosure will appear again next time.
-  }
-};
-
-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 disclosureStyle = css({
   display: "flex",
   width: "full",
@@ -317,9 +235,12 @@ const AvailableVoiceInterviewControl = ({
           void store.controller.reconnect();
         },
         repeatQuestion: () => store.controller.repeatQuestion(),
-        resume: () => store.controller.resume(),
+        resume: () => {
+          void store.controller.resume();
+        },
         setMicrophoneMuted: (muted) =>
           store.controller.setMicrophoneMuted(muted),
+        takeTurn: () => store.controller.takeTurn(),
       }),
     [registerVoiceModeControls, store],
   );
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-disclosure.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-disclosure.ts
new file mode 100644
index 00000000000..befc33d5acb
--- /dev/null
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-interview-disclosure.ts
@@ -0,0 +1,47 @@
+export const VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY =
+  "petrinaut:voice-interview-disclosure:v1";
+
+const VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED = "acknowledged";
+
+const getVoiceInterviewDisclosureStorage = (): Storage | null => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+
+export const isVoiceInterviewDisclosureAcknowledged = (
+  storage: Pick<
+    Storage,
+    "getItem"
+  > | null = getVoiceInterviewDisclosureStorage(),
+): boolean => {
+  try {
+    return (
+      storage?.getItem(VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY) ===
+      VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const acknowledgeVoiceInterviewDisclosure = (
+  storage: Pick<
+    Storage,
+    "setItem"
+  > | null = getVoiceInterviewDisclosureStorage(),
+): void => {
+  try {
+    storage?.setItem(
+      VOICE_INTERVIEW_DISCLOSURE_STORAGE_KEY,
+      VOICE_INTERVIEW_DISCLOSURE_ACKNOWLEDGED,
+    );
+  } catch {
+    // Storage is optional; the disclosure will appear again next time.
+  }
+};
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-preview.integration.test.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-preview.integration.test.ts
index 7b857490f34..9892e2bbcaf 100644
--- a/apps/petrinaut-website/src/main/app/voice-interview/voice-preview.integration.test.ts
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-preview.integration.test.ts
@@ -271,30 +271,76 @@ describe("controlled voice preview", () => {
 
     await controller.start();
     authorizeLatestSpeechResponse(dataChannel, "response-initial-question");
+    dataChannel.receive({
+      audio_start_ms: 100,
+      item_id: "item-before-handoff",
+      type: "input_audio_buffer.speech_started",
+    });
     dataChannel.receive({
       response_id: "response-initial-question",
       type: "output_audio_buffer.started",
     });
+
+    expect(controller.getSnapshot()).toMatchObject({
+      canTakeTurn: true,
+      currentQuestion: "What happens after approval?",
+      output: "speaking",
+    });
+    const handoff = controller.takeTurn();
+    const repeatedHandoff = controller.takeTurn();
+    expect(repeatedHandoff).toBe(handoff);
+    expect(sentEvents(dataChannel).slice(-3)).toEqual([
+      { type: "input_audio_buffer.clear" },
+      expect.objectContaining({
+        response_id: "response-initial-question",
+        type: "response.cancel",
+      }),
+      { type: "output_audio_buffer.clear" },
+    ]);
+    expect(track.enabled).toBe(false);
+    expect(peer.close).not.toHaveBeenCalled();
+
+    dataChannel.receive({
+      content_index: 0,
+      item_id: "item-before-handoff",
+      transcript: "This began before the handoff.",
+      type: "conversation.item.input_audio_transcription.completed",
+    });
+    dataChannel.receive({ type: "input_audio_buffer.cleared" });
     dataChannel.receive({
       response_id: "response-initial-question",
-      type: "output_audio_buffer.stopped",
+      type: "output_audio_buffer.cleared",
     });
     dataChannel.receive({
       response: {
         id: "response-initial-question",
         output: [],
-        status: "completed",
+        status: "cancelled",
       },
       type: "response.done",
     });
+    await handoff;
+    await repeatedHandoff;
+
+    expect(submitInterviewAnswer).not.toHaveBeenCalled();
+    expect(track.enabled).toBe(true);
     expect(controller.getSnapshot()).toMatchObject({
+      canRepeatQuestion: true,
+      canTakeTurn: false,
+      connection: "connected",
+      currentQuestion: "What happens after approval?",
       input: "listening",
       microphoneEnabled: true,
-      output: "idle",
+      output: "interrupted",
     });
 
     // Silence or noise: Realtime completes an empty transcript. Nothing is
     // submitted and the session keeps listening with a recoverable notice.
+    dataChannel.receive({
+      audio_start_ms: 200,
+      item_id: "noise-item",
+      type: "input_audio_buffer.speech_started",
+    });
     dataChannel.receive({
       content_index: 0,
       item_id: "noise-item",
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.test.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.test.ts
index a0f878c29d5..afb2013e8d8 100644
--- a/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.test.ts
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.test.ts
@@ -7,6 +7,7 @@ import type { VoiceTurnSnapshot } from "./voice-turn-controller";
 const listeningSnapshot = {
   canReadFullResponse: true,
   canRepeatQuestion: true,
+  canTakeTurn: false,
   canReviseLastAnswer: false,
   connection: "connected",
   currentQuestion: "What happens after approval?",
@@ -35,6 +36,7 @@ describe("toVoiceSessionState", () => {
     expect(mapSnapshot()).toEqual({
       canReadFullResponse: true,
       canRepeatQuestion: true,
+      canTakeTurn: false,
       errorMessage: null,
       microphoneLevel: 0.24,
       microphoneMuted: false,
@@ -43,15 +45,19 @@ describe("toVoiceSessionState", () => {
   });
 
   test("hands the turn to the assistant while it speaks", () => {
-    expect(mapSnapshot({ output: "speaking", partialText: "" })).toMatchObject({
-      phase: "speaking",
-    });
+    expect(
+      mapSnapshot({ canTakeTurn: true, output: "speaking", partialText: "" }),
+    ).toMatchObject({ canTakeTurn: true, phase: "speaking" });
   });
 
   test("treats a pending tool and a submitting turn as thinking", () => {
     expect(
       mapSnapshot({ output: "waiting-for-tool", partialText: "" }),
     ).toMatchObject({ phase: "thinking" });
+    expect(mapSnapshot({ output: "cancelling" })).toMatchObject({
+      canTakeTurn: false,
+      phase: "thinking",
+    });
     expect(mapSnapshot({ input: "submitting", partialText: "" })).toMatchObject(
       { phase: "thinking" },
     );
diff --git a/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.ts b/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.ts
index 07d6fede838..03e8d341ded 100644
--- a/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.ts
+++ b/apps/petrinaut-website/src/main/app/voice-interview/voice-session-state.ts
@@ -65,6 +65,7 @@ const phaseOf = (
     return "speaking";
   }
   if (
+    snapshot.output === "cancelling" ||
     snapshot.output === "waiting-for-tool" ||
     snapshot.input === "submitting"
   ) {
@@ -95,6 +96,7 @@ export const toVoiceSessionState = ({
   return {
     canReadFullResponse: snapshot.canReadFullResponse,
     canRepeatQuestion: snapshot.canRepeatQuestion,
+    canTakeTurn: snapshot.canTakeTurn,
     errorMessage:
       snapshot.connection === "error" ? errorMessageOf(snapshot) : null,
     microphoneMuted:
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 513a768a77a..3cf4b6bc933 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
@@ -17,7 +17,7 @@ const createHarness = () => {
     | undefined;
   let bridgeListener: ((event: RealtimeBrunchBridgeEvent) => void) | undefined;
   const session = {
-    cancelOutput: vi.fn(),
+    cancelOutput: vi.fn<() => Promise<void>>(async () => undefined),
     connect: vi.fn(async () => ++epoch),
     disconnect: vi.fn(async () => undefined),
     setMicrophoneEnabled: vi.fn(),
@@ -126,6 +126,168 @@ describe("VoiceTurnController", () => {
     });
   });
 
+  test("hands over an active question once and reopens capture after cancellation", async () => {
+    const harness = createHarness();
+    const source = speechSource();
+    let finishCancellation: (() => void) | undefined;
+    harness.session.cancelOutput.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          finishCancellation = resolve;
+        }),
+    );
+    harness.controller.updateChat({
+      automaticSource: source,
+      canAcceptInterviewAnswer: true,
+      canonicalSegments: [...source.fullResponseSegments],
+      status: "ready",
+    });
+    await harness.controller.start();
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-question",
+      type: "output-started",
+    });
+    harness.bridge.cancelPendingSpeech.mockClear();
+    harness.session.cancelOutput.mockClear();
+
+    expect(harness.controller.getSnapshot().canTakeTurn).toBe(true);
+    const firstHandoff = harness.controller.takeTurn();
+    const repeatedHandoff = harness.controller.takeTurn();
+
+    expect(repeatedHandoff).toBe(firstHandoff);
+    expect(harness.bridge.cancelPendingSpeech).toHaveBeenCalledOnce();
+    expect(harness.session.cancelOutput).toHaveBeenCalledOnce();
+    expect(harness.session.disconnect).not.toHaveBeenCalled();
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      canTakeTurn: false,
+      connection: "connected",
+      currentQuestion: "Who approves release?",
+      output: "cancelling",
+    });
+
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-question",
+      type: "output-interrupted",
+    });
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-question",
+      status: "cancelled",
+      type: "response-terminal",
+    });
+    expect(harness.controller.getSnapshot().output).toBe("cancelling");
+    finishCancellation?.();
+    await firstHandoff;
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      canRepeatQuestion: true,
+      canTakeTurn: false,
+      connection: "connected",
+      currentQuestion: "Who approves release?",
+      microphoneEnabled: true,
+      output: "interrupted",
+    });
+  });
+
+  test("uses the latest mute preference after turn cancellation", async () => {
+    const harness = createHarness();
+    const source = speechSource();
+    let finishCancellation: (() => void) | undefined;
+    harness.session.cancelOutput.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          finishCancellation = resolve;
+        }),
+    );
+    harness.controller.updateChat({
+      automaticSource: source,
+      canAcceptInterviewAnswer: true,
+      canonicalSegments: [...source.fullResponseSegments],
+      status: "ready",
+    });
+    await harness.controller.start();
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-question",
+      type: "output-started",
+    });
+
+    const handoff = harness.controller.takeTurn();
+    harness.controller.setMicrophoneMuted(true);
+    finishCancellation?.();
+    await handoff;
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      microphoneEnabled: false,
+      output: "interrupted",
+    });
+  });
+
+  test("keeps capture closed when unmuted during turn cancellation", async () => {
+    const harness = createHarness();
+    const source = speechSource();
+    let finishCancellation: (() => void) | undefined;
+    harness.session.cancelOutput.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          finishCancellation = resolve;
+        }),
+    );
+    harness.controller.updateChat({
+      automaticSource: source,
+      canAcceptInterviewAnswer: true,
+      canonicalSegments: [...source.fullResponseSegments],
+      status: "ready",
+    });
+    await harness.controller.start();
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-question",
+      type: "output-started",
+    });
+    harness.controller.setMicrophoneMuted(true);
+
+    const handoff = harness.controller.takeTurn();
+    harness.session.setMicrophoneEnabled.mockClear();
+    harness.controller.setMicrophoneMuted(false);
+
+    expect(harness.session.setMicrophoneEnabled).not.toHaveBeenCalled();
+    expect(harness.controller.getSnapshot().microphoneEnabled).toBe(true);
+
+    finishCancellation?.();
+    await handoff;
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenCalledOnce();
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenCalledWith(true);
+  });
+
+  test("offers handoff while speech is being prepared for an unanswered question", async () => {
+    const harness = createHarness();
+    harness.controller.updateChat({
+      canAcceptInterviewAnswer: true,
+      canonicalSegments: [question("ask-preparing")],
+      status: "ready",
+    });
+    await harness.controller.start();
+
+    harness.emitBridge({ type: "speech-delivery-pending" });
+
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      canTakeTurn: true,
+      currentQuestion: "What happens after approval?",
+      output: "waiting-for-tool",
+    });
+  });
+
   test("invalidates pending preparation before pausing or cancelling paused output", async () => {
     const harness = createHarness();
     const order: string[] = [];
@@ -135,9 +297,9 @@ describe("VoiceTurnController", () => {
     harness.bridge.updateChat.mockImplementation(() =>
       order.push("chat-update"),
     );
-    harness.session.cancelOutput.mockImplementation(() =>
-      order.push("session-cancel"),
-    );
+    harness.session.cancelOutput.mockImplementation(async () => {
+      order.push("session-cancel");
+    });
     await harness.controller.start();
 
     harness.controller.pause();
@@ -504,7 +666,7 @@ describe("VoiceTurnController", () => {
     });
 
     harness.controller.pause();
-    harness.controller.resume();
+    await harness.controller.resume();
 
     expect(harness.controller.getSnapshot()).toMatchObject({
       input: "submitting",
@@ -587,7 +749,7 @@ describe("VoiceTurnController", () => {
     });
     expect(harness.session.cancelOutput).toHaveBeenCalledTimes(2);
 
-    harness.controller.resume();
+    await harness.controller.resume();
     expect(harness.controller.getSnapshot()).toMatchObject({
       input: "listening",
       microphoneEnabled: true,
@@ -862,7 +1024,44 @@ describe("VoiceTurnController", () => {
       output: "interrupted",
     });
 
-    harness.controller.resume();
+    await harness.controller.resume();
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      input: "listening",
+      microphoneEnabled: true,
+    });
+  });
+
+  test("keeps capture paused until output cancellation completes", async () => {
+    const harness = createHarness();
+    let finishCancellation: (() => void) | undefined;
+    harness.session.cancelOutput.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          finishCancellation = resolve;
+        }),
+    );
+    await harness.controller.start();
+    harness.emitSession({
+      connectionEpoch: 1,
+      responseId: "response-1",
+      type: "output-started",
+    });
+
+    harness.controller.pause();
+    const resumption = harness.controller.resume();
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(
+      false,
+    );
+    expect(harness.controller.getSnapshot()).toMatchObject({
+      input: "paused",
+      microphoneEnabled: false,
+    });
+
+    finishCancellation?.();
+    await resumption;
+
+    expect(harness.session.setMicrophoneEnabled).toHaveBeenLastCalledWith(true);
     expect(harness.controller.getSnapshot()).toMatchObject({
       input: "listening",
       microphoneEnabled: true,
@@ -939,7 +1138,7 @@ describe("VoiceTurnController", () => {
       output: "idle",
     });
 
-    harness.controller.resume();
+    await harness.controller.resume();
     expect(harness.bridge.start).toHaveBeenCalledWith(1);
     expect(harness.controller.getSnapshot()).toMatchObject({
       input: "listening",
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 171d86fa120..598fae79ae3 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
@@ -17,6 +17,7 @@ export type VoiceConnectionState =
   | "error";
 export type VoiceInputState = "listening" | "paused" | "submitting";
 export type VoiceOutputState =
+  | "cancelling"
   | "idle"
   | "waiting-for-tool"
   | "speaking"
@@ -33,6 +34,7 @@ export type VoiceInputNotice = "none" | "not-heard";
 export interface VoiceTurnSnapshot {
   readonly canReadFullResponse: boolean;
   readonly canRepeatQuestion: boolean;
+  readonly canTakeTurn: boolean;
   readonly canReviseLastAnswer: boolean;
   readonly connection: VoiceConnectionState;
   readonly currentQuestion: string;
@@ -62,7 +64,7 @@ export interface VoiceLatencyEvent {
 type ChatStatus = "ready" | "submitted" | "streaming" | "error";
 
 interface RealtimeSession {
-  cancelOutput(): void;
+  cancelOutput(): Promise<void>;
   connect(): Promise<number>;
   disconnect(): Promise<void>;
   setMicrophoneEnabled(enabled: boolean): void;
@@ -104,6 +106,7 @@ type SnapshotListener = (snapshot: VoiceTurnSnapshot) => void;
 const initialSnapshot: VoiceTurnSnapshot = {
   canReadFullResponse: false,
   canRepeatQuestion: false,
+  canTakeTurn: false,
   canReviseLastAnswer: false,
   connection: "idle",
   currentQuestion: "",
@@ -143,10 +146,12 @@ export class VoiceTurnController {
   #generation = 0;
   #inputStateOnResume: Exclude<VoiceInputState, "paused"> | null = null;
   #inputTurnPending = false;
+  #outputCancellationPromise: Promise<void> | null = null;
   #pauseRequested = false;
   #snapshot = initialSnapshot;
   #speechSource: InterviewSpeechSource | null = null;
   #submittingQuestionId: string | null = null;
+  #takingTurnPromise: Promise<void> | null = null;
   #teardownPromise: Promise<void> | null = null;
   #transcriptItemId: string | null = null;
   #transcriptKey: string | null = null;
@@ -206,6 +211,7 @@ export class VoiceTurnController {
 
     this.#inputStateOnResume = null;
     this.#inputTurnPending = false;
+    this.#outputCancellationPromise = null;
     this.#pauseRequested = false;
     this.#bridgeStarted = false;
     this.#activeSpeechOutputEnded = false;
@@ -257,7 +263,9 @@ export class VoiceTurnController {
     this.#currentQuestionId = null;
     this.#inputStateOnResume = null;
     this.#inputTurnPending = false;
+    this.#outputCancellationPromise = null;
     this.#submittingQuestionId = null;
+    this.#takingTurnPromise = null;
     this.#pauseRequested = false;
     this.#transcriptItemId = null;
     this.#transcriptKey = null;
@@ -307,7 +315,7 @@ export class VoiceTurnController {
     this.#inputStateOnResume = this.#snapshot.input;
     this.#pauseRequested = true;
     const output = this.#snapshot.output === "idle" ? "idle" : "interrupted";
-    this.#cancelOutput();
+    void this.#cancelOutput();
     this.#session.setMicrophoneEnabled(false);
     this.#update({
       input: "paused",
@@ -330,17 +338,42 @@ export class VoiceTurnController {
     ) {
       return;
     }
-    this.#session.setMicrophoneEnabled(!muted);
+    if (!this.#takingTurnPromise) {
+      this.#session.setMicrophoneEnabled(!muted);
+    }
     this.#update({ microphoneEnabled: !muted, microphoneLevel: 0 });
   }
 
-  public resume(): void {
+  public async resume(): Promise<void> {
     if (
       this.#snapshot.connection !== "connected" ||
       this.#snapshot.input !== "paused"
     ) {
       return;
     }
+    const generation = this.#generation;
+    while (this.#outputCancellationPromise) {
+      try {
+        await this.#outputCancellationPromise;
+      } catch (error) {
+        if (generation !== this.#generation) {
+          return;
+        }
+        const voiceError =
+          error instanceof VoiceError
+            ? error
+            : new VoiceError("speech", "network", "");
+        this.#setError(
+          voiceError.message,
+          voiceError.code,
+          voiceError.requestId,
+        );
+        return;
+      }
+      if (!this.#canResume(generation)) {
+        return;
+      }
+    }
     const input = this.#inputStateOnResume ?? "listening";
     this.#inputStateOnResume = null;
     this.#pauseRequested = false;
@@ -415,6 +448,67 @@ export class VoiceTurnController {
     this.#session.speakCanonical([question]);
   }
 
+  /**
+   * Ends the assistant's pending or active speech without ending Realtime.
+   * Capture stays closed until the session confirms its input and output
+   * buffers are clear, so the next accepted utterance begins after the click.
+   */
+  public takeTurn(): Promise<void> {
+    if (this.#takingTurnPromise) {
+      return this.#takingTurnPromise;
+    }
+    if (!this.#snapshot.canTakeTurn) {
+      return Promise.resolve();
+    }
+
+    const generation = this.#generation;
+    this.#bridge.cancelPendingSpeech();
+    this.#session.setMicrophoneEnabled(false);
+    this.#inputTurnPending = false;
+    this.#transcriptItemId = null;
+    this.#transcriptKey = null;
+    this.#update({ output: "cancelling", partialText: "" });
+
+    const takingTurnPromise = this.#session
+      .cancelOutput()
+      .then(() => {
+        if (
+          generation !== this.#generation ||
+          this.#snapshot.connection !== "connected" ||
+          this.#snapshot.input === "paused"
+        ) {
+          return;
+        }
+        this.#activeSpeechOutputEnded = false;
+        this.#activeSpeechResponseId = null;
+        this.#activeSpeechResponseTerminal = false;
+        this.#session.setMicrophoneEnabled(this.#snapshot.microphoneEnabled);
+        this.#update({ output: "interrupted" });
+      })
+      .catch((error: unknown) => {
+        if (generation !== this.#generation) {
+          return;
+        }
+        const voiceError =
+          error instanceof VoiceError
+            ? error
+            : new VoiceError("speech", "network", "");
+        this.#setError(
+          voiceError.message,
+          voiceError.code,
+          voiceError.requestId,
+        );
+      })
+      .finally(() => {
+        if (this.#takingTurnPromise === takingTurnPromise) {
+          this.#takingTurnPromise = null;
+        }
+      });
+    this.#takingTurnPromise = takingTurnPromise;
+    this.#update({});
+    return takingTurnPromise;
+  }
+
   public updateChat(update: ChatUpdate): void {
     this.#speechSource = update.automaticSource ?? null;
     const canReplay = this.#canReplay(this.#snapshot);
@@ -434,7 +528,7 @@ export class VoiceTurnController {
     }
     this.#bridge.updateChat(update);
     if (this.#snapshot.input === "paused") {
-      this.#cancelOutput();
+      void this.#cancelOutput();
     }
   }
 
@@ -503,7 +597,7 @@ export class VoiceTurnController {
     const paused = this.#snapshot.input === "paused";
     if (paused) {
       this.#inputStateOnResume = "listening";
-      this.#cancelOutput();
+      void this.#cancelOutput();
     }
     this.#update({
       input: paused ? "paused" : "listening",
@@ -537,7 +631,7 @@ export class VoiceTurnController {
       this.#activeSpeechResponseId = event.responseId;
       this.#activeSpeechResponseTerminal = false;
       if (this.#snapshot.input === "paused") {
-        this.#cancelOutput();
+        void this.#cancelOutput();
         this.#update({ output: "interrupted" });
         return;
       }
@@ -555,7 +649,9 @@ export class VoiceTurnController {
         this.#activeSpeechResponseId = null;
         this.#activeSpeechResponseTerminal = false;
       }
-      this.#update({ output: "idle" });
+      this.#update({
+        output: this.#takingTurnPromise ? "cancelling" : "idle",
+      });
       if (this.#currentQuestionId) {
         this.#recordLatency("question-spoken", this.#currentQuestionId);
       }
@@ -569,10 +665,13 @@ export class VoiceTurnController {
         this.#activeSpeechResponseId = null;
         this.#activeSpeechResponseTerminal = false;
       }
-      this.#update({ output: "interrupted" });
+      this.#update({
+        output: this.#takingTurnPromise ? "cancelling" : "interrupted",
+      });
       return;
     }
     if (event.type === "input-speech-started") {
+      if (this.#takingTurnPromise) return;
       this.#inputTurnPending = true;
       this.#bridge.cancelPendingSpeech();
       this.#transcriptItemId = event.itemId;
@@ -643,6 +742,8 @@ export class VoiceTurnController {
     this.#activeSpeechResponseTerminal = false;
     this.#inputStateOnResume = null;
     this.#inputTurnPending = false;
+    this.#outputCancellationPromise = null;
+    this.#takingTurnPromise = null;
     this.#bridgeStarted = false;
     this.#transcriptItemId = null;
     this.#transcriptKey = null;
@@ -666,9 +767,23 @@ export class VoiceTurnController {
     });
   }
 
-  #cancelOutput(): void {
+  #cancelOutput(): Promise<void> {
     this.#bridge.cancelPendingSpeech();
-    this.#session.cancelOutput();
+    const cancellationPromise = this.#session.cancelOutput();
+    this.#outputCancellationPromise = cancellationPromise;
+    void cancellationPromise.then(
+      () => {
+        if (this.#outputCancellationPromise === cancellationPromise) {
+          this.#outputCancellationPromise = null;
+        }
+      },
+      () => {
+        if (this.#outputCancellationPromise === cancellationPromise) {
+          this.#outputCancellationPromise = null;
+        }
+      },
+    );
+    return cancellationPromise;
   }
 
   #recordLatency(name: VoiceLatencyEvent["name"], questionId: string): void {
@@ -700,6 +815,28 @@ export class VoiceTurnController {
     );
   }
 
+  #canTakeTurn(snapshot: VoiceTurnSnapshot): boolean {
+    return (
+      snapshot.connection === "connected" &&
+      snapshot.input !== "paused" &&
+      (snapshot.output === "waiting-for-tool" ||
+        snapshot.output === "speaking") &&
+      this.#currentQuestionId !== null &&
+      this.#currentQuestionId !== this.#answeredQuestionId &&
+      this.#currentQuestionId !== this.#submittingQuestionId &&
+      Boolean(snapshot.currentQuestion) &&
+      this.#takingTurnPromise === null
+    );
+  }
+
+  #canResume(generation: number): boolean {
+    return (
+      generation === this.#generation &&
+      this.#snapshot.connection === "connected" &&
+      this.#snapshot.input === "paused"
+    );
+  }
+
   #isPauseRequested(): boolean {
     return this.#pauseRequested;
   }
@@ -714,6 +851,7 @@ export class VoiceTurnController {
       canRepeatQuestion:
         this.#canReplay(snapshot) &&
         Boolean(this.#speechSource?.questionSegment),
+      canTakeTurn: this.#canTakeTurn(snapshot),
       canReviseLastAnswer: this.#canReviseLastAnswer(snapshot),
     };
     for (const listener of this.#listeners) listener(this.#snapshot);
diff --git a/libs/@hashintel/brunch-agent/docs/specs/petrinaut-integration.md b/libs/@hashintel/brunch-agent/docs/specs/petrinaut-integration.md
index 15aaa55b7ff..c717e4b25ca 100644
--- a/libs/@hashintel/brunch-agent/docs/specs/petrinaut-integration.md
+++ b/libs/@hashintel/brunch-agent/docs/specs/petrinaut-integration.md
@@ -75,7 +75,7 @@ The panel and the voice edge attach to Brunch through one stable surface:
 5. **Voice mode publication**: Petrinaut accepts an optional `renderVoiceMode` callback and publishes
    provider-neutral input mode, panel visibility, messages, readiness, stable lifecycle controls,
    and `submitVoiceInput`. Finalized Voice input enters the same correlated submission path and
-   carries persisted Voice provenance on either the ordinary user message or the exact
+   carries persisted Voice provenance on either the ordinary user message or each corresponding
    `brunch_ask` tool output, never both.
 
 These five parts change only with notice to the panel and voice-edge owners. A provider-specific
diff --git a/libs/@hashintel/petrinaut/README.md b/libs/@hashintel/petrinaut/README.md
index 64c6d639d39..3aaec5d24e8 100644
--- a/libs/@hashintel/petrinaut/README.md
+++ b/libs/@hashintel/petrinaut/README.md
@@ -56,7 +56,15 @@ const confirmationTool = definePetrinautAiInteractiveTool({
   toolName: "confirmOperation",
   inputSchema: z.object({ question: z.string() }),
   outputSchema: z.object({ approved: z.boolean() }),
-  component: ({ input, state, submit, submittedOutput, toolCallId }) =>
+  supportsSubmittedOutputProvenance: true,
+  component: ({
+    input,
+    state,
+    submit,
+    submittedOutput,
+    submittedOutputProvenance,
+    toolCallId,
+  }) =>
     state === "awaiting" ? (
       <section data-tool-call-id={toolCallId}>
         <p>{input.question}</p>
@@ -64,7 +72,10 @@ const confirmationTool = definePetrinautAiInteractiveTool({
         <button onClick={() => submit({ approved: false })}>Decline</button>
       </section>
     ) : (
-      <p>{submittedOutput.approved ? "Approved" : "Declined"}</p>
+      <div>
+        <p>{submittedOutput.approved ? "Approved" : "Declined"}</p>
+        {submittedOutputProvenance}
+      </div>
     ),
 });
 
@@ -84,9 +95,13 @@ checked before Petrinaut calls the AI SDK's `addToolOutput`.
 
 The component receives a stable `toolCallId` plus a discriminated lifecycle:
 `state: "awaiting"` has no submitted output, while `state: "submitted"`
-includes the validated `submittedOutput`. While a submission is in flight,
-duplicate `submit` calls are ignored. An accepted submission stays one-shot;
-if the AI SDK rejects it, the awaiting component can submit again. Once every
+includes the validated `submittedOutput`. A tool can set
+`supportsSubmittedOutputProvenance: true` and position
+`submittedOutputProvenance` next to its submitted value; Petrinaut uses that
+slot for context-appropriate provenance when available. Widgets that omit the
+opt-in keep the trailing provenance fallback. While a submission is in flight,
+duplicate `submit` calls are ignored. An accepted submission stays one-shot; if
+the AI SDK rejects it, the awaiting component can submit again. Once every
 pending tool call has output, the existing AI SDK automatic follow-up runs as
 usual.
 
diff --git a/libs/@hashintel/petrinaut/docs/ai-assistant.md b/libs/@hashintel/petrinaut/docs/ai-assistant.md
index 53939f99f3a..911daf94ab4 100644
--- a/libs/@hashintel/petrinaut/docs/ai-assistant.md
+++ b/libs/@hashintel/petrinaut/docs/ai-assistant.md
@@ -58,22 +58,28 @@ instead; turning it off holds them back again, and it starts off with each sessi
 never held back either way: anything you typed, and any inline question waiting for your answer. When
 the session ends, the held turns appear together under a **Voice session · N turns** divider. Only
 finalized answers and canonical Brunch text become chat history; provisional transcription and
-Realtime audio are ephemeral. Finalized spoken user messages carry a small **Voice** chip in front of
-the words themselves, and the exact inline answer completed by speech carries the same chip, so Voice
-provenance remains visible without duplicating an answer.
+Realtime audio are ephemeral. Finalized spoken user messages carry a small waveform icon in front of
+the words themselves. Every inline-question answer completed by speech carries the same icon inside
+its compact user-turn bubble, so Voice provenance remains visible without duplicating the answer as a
+separate user message.
 
 Microphone capture pauses while the interviewer speaks so speaker echo cannot be submitted as your
-answer. Wait for playback to finish; Voice resumes listening automatically in your previous mute
-state. Semantic voice detection finishes each answer after a natural pause and is tuned to allow
-longer thinking pauses. There is no required done-speaking action.
+answer. Wait for playback to finish, or select **Your turn** while the interviewer is preparing or
+speaking. **Your turn** cancels pending speech, stops playback, and clears audio already buffered for
+the turn without disconnecting Voice. The microphone reopens only after that cancellation finishes,
+and only speech that begins after you selected **Your turn** is accepted as your answer. The
+interrupted question remains visible and available from **Repeat question** if you want to hear it
+again. Voice otherwise resumes listening automatically in your previous mute state. Semantic voice
+detection finishes each answer after a natural pause and is tuned to allow longer thinking pauses.
+There is no required done-speaking action.
 
 Every session control lives in the dock: **Show transcription in chat** on the left, and on the right
-**Mute microphone** (**Unmute microphone** once muted) beside **End voice mode**. Muting stops
-sending audio without ending the turn, so the assistant plays out whatever it is saying and unmuting
-drops you straight back into the conversation. **Resume voice mode** replaces the microphone action
-while a session is paused, and **Reconnect voice mode** replaces it after a failure. Nothing is added
-to the canvas toolbar. To send a typed message, first select **End voice mode** to restore the
-composer.
+**Your turn** while the interviewer is preparing or speaking, **Mute microphone** (**Unmute
+microphone** once muted), and **End voice mode**. Muting stops sending audio without ending the turn,
+so the assistant plays out whatever it is saying and unmuting drops you straight back into the
+conversation. **Resume voice mode** replaces the microphone action while a session is paused, and
+**Reconnect voice mode** replaces it after a failure. Nothing is added to the canvas toolbar. To send
+a typed message, first select **End voice mode** to restore the composer.
 
 The interviewer uses a warm, calm, curious, and professionally neutral voice and treats you as the
 authority on your system. Brunch still chooses every question and interview decision. Its exact
diff --git a/libs/@hashintel/petrinaut/src/react/voice-session/store.ts b/libs/@hashintel/petrinaut/src/react/voice-session/store.ts
index 345e080b176..73e502c20bb 100644
--- a/libs/@hashintel/petrinaut/src/react/voice-session/store.ts
+++ b/libs/@hashintel/petrinaut/src/react/voice-session/store.ts
@@ -12,6 +12,7 @@ export type VoiceSessionActions = {
   repeatQuestion?: () => void;
   resume: () => void;
   setMicrophoneMuted: (muted: boolean) => void;
+  takeTurn?: () => Promise<void> | void;
 };
 
 export type VoiceSessionSnapshot = {
diff --git a/libs/@hashintel/petrinaut/src/react/voice-session/types.ts b/libs/@hashintel/petrinaut/src/react/voice-session/types.ts
index 1ee8e679bd2..004e57b7a28 100644
--- a/libs/@hashintel/petrinaut/src/react/voice-session/types.ts
+++ b/libs/@hashintel/petrinaut/src/react/voice-session/types.ts
@@ -20,6 +20,8 @@ export type PetrinautAiVoiceSessionState = {
   canReadFullResponse?: boolean;
   /** Whether the current canonical interview question is safe to repeat. */
   canRepeatQuestion?: boolean;
+  /** Whether the user can manually cancel Voice output and start their turn. */
+  canTakeTurn?: boolean;
   errorMessage: string | null;
   /** Whether microphone capture is muted independently of whose turn it is. */
   microphoneMuted: boolean;
diff --git a/libs/@hashintel/petrinaut/src/react/voice-session/use-voice-session.ts b/libs/@hashintel/petrinaut/src/react/voice-session/use-voice-session.ts
index 916c5a39d17..91ee7b73ac1 100644
--- a/libs/@hashintel/petrinaut/src/react/voice-session/use-voice-session.ts
+++ b/libs/@hashintel/petrinaut/src/react/voice-session/use-voice-session.ts
@@ -82,3 +82,13 @@ export const useVoiceSessionCanRepeatQuestion = (): boolean => {
     () => false,
   );
 };
+
+export const useVoiceSessionCanTakeTurn = (): boolean => {
+  const store = use(VoiceSessionContext);
+
+  return useSyncExternalStore(
+    store.subscribe,
+    () => store.getSnapshot().state?.canTakeTurn ?? false,
+    () => false,
+  );
+};
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 c2778346770..b536f7e11bb 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
@@ -71,6 +71,8 @@ export type PetrinautAiVoiceModeControls = {
    * whole session when Petrinaut closes the panel.
    */
   setMicrophoneMuted: (muted: boolean) => void;
+  /** Cancels Voice output and hands the live microphone turn to the user. */
+  takeTurn?: () => Promise<void> | void;
 };
 
 /** Stable controls and conversation state supplied to a host-owned Voice mode. */
diff --git a/libs/@hashintel/petrinaut/src/ui/types/ai-interactive-tool.ts b/libs/@hashintel/petrinaut/src/ui/types/ai-interactive-tool.ts
index ccd5aa95fff..f3bc400741a 100644
--- a/libs/@hashintel/petrinaut/src/ui/types/ai-interactive-tool.ts
+++ b/libs/@hashintel/petrinaut/src/ui/types/ai-interactive-tool.ts
@@ -1,4 +1,4 @@
-import type { ComponentType } from "react";
+import type { ComponentType, ReactNode } from "react";
 
 /** A runtime parser such as a Zod schema. */
 export type PetrinautAiInteractiveToolSchema<Value> = {
@@ -21,10 +21,13 @@ export type PetrinautAiInteractiveToolWidgetProps<Input, Output> =
       | {
           state: "awaiting";
           submittedOutput?: never;
+          submittedOutputProvenance?: never;
         }
       | {
           state: "submitted";
           submittedOutput: Output;
+          /** Optional host-positioned provenance for the submitted value. */
+          submittedOutputProvenance?: ReactNode;
         }
     );
 
@@ -45,6 +48,10 @@ export type PetrinautAiInteractiveToolDefinition<Input, Output> = {
    * output before completing the tool call.
    */
   fromComposerText?: (params: { input: Input; text: string }) => Output;
+  /**
+   * Opt in to positioning Petrinaut-provided provenance inside the widget.
+   */
+  supportsSubmittedOutputProvenance?: true;
   /** Inline component shown while awaiting input and after submission. */
   component: ComponentType<
     PetrinautAiInteractiveToolWidgetProps<Input, Output>
@@ -56,6 +63,7 @@ type ErasedInteractiveToolDefinition = {
   parseInput: (value: unknown) => unknown;
   parseOutput: (value: unknown) => unknown;
   fromComposerText?: (params: { input: unknown; text: string }) => unknown;
+  supportsSubmittedOutputProvenance?: true;
   component: ComponentType<
     PetrinautAiInteractiveToolWidgetProps<unknown, unknown>
   >;
@@ -93,6 +101,8 @@ export const definePetrinautAiInteractiveTool = <Input, Output>(
               }),
             )
         : undefined,
+      supportsSubmittedOutputProvenance:
+        definition.supportsSubmittedOutputProvenance,
       component: definition.component as ComponentType<
         PetrinautAiInteractiveToolWidgetProps<unknown, unknown>
       >,
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-indicator.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-indicator.tsx
index 1994e3e7784..86392b9d5f2 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-indicator.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-indicator.tsx
@@ -210,7 +210,9 @@ export const VoiceSessionIndicator = ({
     context.setTransform(scale, 0, 0, scale, 0, 0);
 
     const targetColor = parseColor(window.getComputedStyle(canvas).color);
-    colorRef.current ??= targetColor;
+    if (colorRef.current === null) {
+      colorRef.current = targetColor;
+    }
 
     const levelOf = phaseLevel[phase];
     const travelSpeed =
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-labels.ts b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-labels.ts
index f4ea8f4fa3e..a6b6fb3f0c2 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-labels.ts
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/components/voice-session-labels.ts
@@ -34,5 +34,6 @@ export const voiceSessionActionLabels = {
   reconnect: "Reconnect voice mode",
   repeatQuestion: "Repeat question",
   resume: "Resume voice mode",
+  takeTurn: "Your turn",
   unmute: "Unmute microphone",
 } as const;
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 eab9bafbff7..d6119583945 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
@@ -1055,9 +1055,10 @@ describe("AiAssistantPanel composer submissions", () => {
     expect(submitVoiceInputReferences.size).toBe(1);
   });
 
-  test("forwards registered canonical replay controls to the Voice dock", async () => {
+  test("forwards registered replay and handoff controls to the Voice dock", async () => {
     const readFullResponse = vi.fn();
     const repeatQuestion = vi.fn();
+    const takeTurn = vi.fn();
     const VoiceMode = (context: PetrinautAiVoiceModeContext) => {
       const {
         inputMode,
@@ -1078,10 +1079,12 @@ describe("AiAssistantPanel composer submissions", () => {
           repeatQuestion,
           resume: vi.fn(),
           setMicrophoneMuted: vi.fn(),
+          takeTurn,
         });
         reportVoiceSessionState({
           canReadFullResponse: true,
           canRepeatQuestion: true,
+          canTakeTurn: true,
           errorMessage: null,
           microphoneLevel: 0,
           microphoneMuted: false,
@@ -1111,6 +1114,11 @@ describe("AiAssistantPanel composer submissions", () => {
     });
 
     fireEvent.click(screen.getByRole("button", { name: "Start voice mode" }));
+    const takeTurnButton = screen.getByRole("button", { name: "Your turn" });
+    expect(takeTurnButton.getAttribute("data-variant")).toBe("ghost");
+    expect(takeTurnButton.querySelector("svg")).not.toBeNull();
+    fireEvent.click(takeTurnButton);
+    expect(takeTurn).toHaveBeenCalledOnce();
     fireEvent.click(
       screen.getByRole("button", { name: "Voice playback options" }),
     );
@@ -1385,7 +1393,10 @@ describe("AiAssistantPanel composer submissions", () => {
     expect(latestVoiceContext?.status).toBe("streaming");
     expect(latestVoiceContext?.canAcceptVoiceInput).toBe(true);
     expect(requests[1]?.at(-1)).toMatchObject({
-      metadata: { source: "voice", toolCallId: "queued-question" },
+      metadata: {
+        source: "voice",
+        voiceToolCallIds: ["queued-question"],
+      },
       role: "assistant",
     });
     expect(
@@ -2020,7 +2031,10 @@ describe("AiAssistantPanel composer submissions", () => {
       ),
     );
     expect(containingMessage).toMatchObject({
-      metadata: { source: "voice", toolCallId: "question-voice" },
+      metadata: {
+        source: "voice",
+        voiceToolCallIds: ["question-voice"],
+      },
     });
     expect(
       containingMessage?.parts.find(
@@ -2044,12 +2058,139 @@ describe("AiAssistantPanel composer submissions", () => {
     expect(onMessages.mock.lastCall?.[0]).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          metadata: { source: "voice", toolCallId: "question-voice" },
+          metadata: {
+            source: "voice",
+            voiceToolCallIds: ["question-voice"],
+          },
         }),
       ]),
     );
   });
 
+  test("retains every voice tool origin on one assistant message", async () => {
+    let latestMessages = [
+      {
+        id: "assistant-voice-questions",
+        parts: [
+          {
+            input: { question: "Who approves it?" },
+            state: "input-available",
+            toolCallId: "voice-question-1",
+            toolName: "answerQuestion",
+            type: "dynamic-tool",
+          },
+          {
+            input: { question: "Who acts next?" },
+            state: "input-available",
+            toolCallId: "voice-question-2",
+            toolName: "answerQuestion",
+            type: "dynamic-tool",
+          },
+        ],
+        role: "assistant",
+      },
+    ] as unknown as PetrinautAiMessage[];
+    const updateMessages = (
+      updater: (messages: PetrinautAiMessage[]) => PetrinautAiMessage[],
+    ) => {
+      latestMessages = updater(latestMessages);
+    };
+    const addToolOutput = vi.fn().mockResolvedValue(undefined);
+
+    for (const toolCallId of ["voice-question-1", "voice-question-2"]) {
+      await addMappedToolOutput({
+        addToolOutput,
+        currentMessages: latestMessages,
+        params: {
+          output: { answer: toolCallId },
+          tool: "answerQuestion",
+          toolCallId,
+        },
+        source: "voice",
+        updateMessages,
+      });
+    }
+
+    expect(latestMessages[0]?.metadata).toEqual({
+      source: "voice",
+      voiceToolCallIds: ["voice-question-1", "voice-question-2"],
+    });
+  });
+
+  test("preserves sibling voice provenance when another tool output rejects", async () => {
+    let latestMessages = [
+      {
+        id: "assistant-voice-questions",
+        parts: [
+          {
+            input: { question: "Who approves it?" },
+            state: "input-available",
+            toolCallId: "voice-question-1",
+            toolName: "answerQuestion",
+            type: "dynamic-tool",
+          },
+          {
+            input: { question: "Who acts next?" },
+            state: "input-available",
+            toolCallId: "voice-question-2",
+            toolName: "answerQuestion",
+            type: "dynamic-tool",
+          },
+        ],
+        role: "assistant",
+      },
+    ] as unknown as PetrinautAiMessage[];
+    const updateMessages = (
+      updater: (messages: PetrinautAiMessage[]) => PetrinautAiMessage[],
+    ) => {
+      latestMessages = updater(latestMessages);
+    };
+    let rejectFirstSubmission: ((reason?: unknown) => void) | undefined;
+    const addToolOutput = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((_resolve, reject) => {
+            rejectFirstSubmission = reject;
+          }),
+      )
+      .mockResolvedValueOnce(undefined);
+
+    const firstSubmission = addMappedToolOutput({
+      addToolOutput,
+      currentMessages: latestMessages,
+      params: {
+        output: { answer: "The shift lead" },
+        tool: "answerQuestion",
+        toolCallId: "voice-question-1",
+      },
+      source: "voice",
+      updateMessages,
+    });
+    const firstSubmissionRejection = expect(firstSubmission).rejects.toThrow(
+      "First voice tool output rejected.",
+    );
+
+    await addMappedToolOutput({
+      addToolOutput,
+      currentMessages: latestMessages,
+      params: {
+        output: { answer: "The release manager" },
+        tool: "answerQuestion",
+        toolCallId: "voice-question-2",
+      },
+      source: "voice",
+      updateMessages,
+    });
+    rejectFirstSubmission?.(new Error("First voice tool output rejected."));
+    await firstSubmissionRejection;
+
+    expect(latestMessages[0]?.metadata).toEqual({
+      source: "voice",
+      voiceToolCallIds: ["voice-question-2"],
+    });
+  });
+
   test("rolls back failed tool provenance before a typed retry", async () => {
     let latestMessages = [
       {
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 cc4f11010db..e11e72a52bb 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
@@ -1,6 +1,6 @@
 import { useChat } from "@ai-sdk/react";
 import { generateId, lastAssistantMessageIsCompleteWithToolCalls } from "ai";
-import { use, useCallback, useEffect, useRef, useState } from "react";
+import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import {
   aiCommandActionInputSchemas,
@@ -39,8 +39,13 @@ import {
 } from "./ai-assistant-panel/ai-assistant-contents/prompt-chips";
 import { createDiagnosticsAwareAiTransport } from "./ai-assistant-panel/create-diagnostics-aware-ai-transport";
 import { createReasoningTimingAwareAiTransport } from "./ai-assistant-panel/create-reasoning-timing-aware-ai-transport";
+import { DiagnosticsTransportState } from "./ai-assistant-panel/diagnostics-transport-state";
 import { finalizeStreamingMessageParts } from "./ai-assistant-panel/finalize-streaming-message-parts";
 import { formatDiagnosticsForAi } from "./ai-assistant-panel/format-diagnostics-for-ai";
+import {
+  AiAssistantComposerControl,
+  AiAssistantVoiceMode,
+} from "./ai-assistant-panel/host-controls";
 import {
   getInteractiveTool,
   resolveDynamicInteractiveTool,
@@ -110,10 +115,30 @@ const markVoiceToolOrigin = (
 ): PetrinautAiMessage[] =>
   messages.map((message) =>
     message.id === messageId
-      ? {
-          ...message,
-          metadata: { ...message.metadata, source: "voice", toolCallId },
-        }
+      ? (() => {
+          const previousToolCallIds =
+            message.metadata?.source === "voice"
+              ? [
+                  ...(message.metadata.voiceToolCallIds ?? []),
+                  ...(message.metadata.toolCallId
+                    ? [message.metadata.toolCallId]
+                    : []),
+                ]
+              : [];
+          const { toolCallId: _legacyToolCallId, ...previousMetadata } =
+            message.metadata ?? {};
+
+          return {
+            ...message,
+            metadata: {
+              ...previousMetadata,
+              source: "voice",
+              voiceToolCallIds: [
+                ...new Set([...previousToolCallIds, toolCallId]),
+              ],
+            },
+          };
+        })()
       : message,
   );
 
@@ -202,8 +227,41 @@ export const addMappedToolOutput = async ({
         latestMessages.map((message) =>
           message.id === containingMessage.id &&
           message.metadata?.source === "voice" &&
-          message.metadata.toolCallId === params.toolCallId
-            ? { ...message, metadata: previousMetadata }
+          (message.metadata.voiceToolCallIds?.includes(params.toolCallId) ===
+            true ||
+            message.metadata.toolCallId === params.toolCallId)
+            ? (() => {
+                const attributionAlreadyPresent =
+                  previousMetadata?.source === "voice" &&
+                  (previousMetadata.voiceToolCallIds?.includes(
+                    params.toolCallId,
+                  ) === true ||
+                    previousMetadata.toolCallId === params.toolCallId);
+                const voiceToolCallIds = [
+                  ...(message.metadata.voiceToolCallIds ?? []),
+                  ...(message.metadata.toolCallId
+                    ? [message.metadata.toolCallId]
+                    : []),
+                ];
+                const remainingVoiceToolCallIds = attributionAlreadyPresent
+                  ? voiceToolCallIds
+                  : voiceToolCallIds.filter(
+                      (toolCallId) => toolCallId !== params.toolCallId,
+                    );
+                if (remainingVoiceToolCallIds.length === 0) {
+                  return { ...message, metadata: previousMetadata };
+                }
+                const { toolCallId: _legacyToolCallId, ...metadata } =
+                  message.metadata;
+
+                return {
+                  ...message,
+                  metadata: {
+                    ...metadata,
+                    voiceToolCallIds: [...new Set(remainingVoiceToolCallIds)],
+                  },
+                };
+              })()
             : message,
         ),
       );
@@ -214,17 +272,14 @@ export const addMappedToolOutput = async ({
 
 const waitForDiagnosticsRefresh = async ({
   consumePendingMutationDiagnosticsVersion,
-  diagnosticsVersionRef,
+  getDiagnosticsVersion,
 }: {
   consumePendingMutationDiagnosticsVersion: () => number | null;
-  diagnosticsVersionRef: { current: number };
+  getDiagnosticsVersion: () => number;
 }) => {
   const pendingVersion = consumePendingMutationDiagnosticsVersion();
 
-  if (
-    pendingVersion === null ||
-    diagnosticsVersionRef.current > pendingVersion
-  ) {
+  if (pendingVersion === null || getDiagnosticsVersion() > pendingVersion) {
     return;
   }
 
@@ -232,10 +287,7 @@ const waitForDiagnosticsRefresh = async ({
     const timeoutAt = Date.now() + 1_000;
 
     const check = () => {
-      if (
-        diagnosticsVersionRef.current > pendingVersion ||
-        Date.now() >= timeoutAt
-      ) {
+      if (getDiagnosticsVersion() > pendingVersion || Date.now() >= timeoutAt) {
         resolve();
         return;
       }
@@ -297,10 +349,8 @@ export const AiAssistantPanel = ({
   onInitialInteractionModeConsumed?: () => void;
   onInitialMessageConsumed?: () => void;
 }) => {
-  // The wrapped AI transport closes over several refs (diagnostics version,
-  // pending mutation version, diagnostics context) so the transport's
-  // `sendMessages` can read the latest values when it eventually runs. React
-  // Compiler can't prove those reads happen off-render, so we opt out here.
+  // This component coordinates imperative Voice and transport lifecycles in
+  // effects, so it intentionally remains outside compiler memoization.
   "use no memo";
 
   const instance = use(PetrinautInstanceContext);
@@ -364,66 +414,50 @@ export const AiAssistantPanel = ({
     titleRef.current = title;
   }, [title]);
 
-  const diagnosticsContextRef = useRef("No current TypeScript diagnostics.");
-  const diagnosticsVersionRef = useRef(0);
-  const pendingMutationDiagnosticsVersionRef = useRef<number | null>(null);
+  const [diagnosticsTransport] = useState(
+    () => new DiagnosticsTransportState(),
+  );
 
   useEffect(() => {
-    diagnosticsVersionRef.current += 1;
-  }, [diagnosticsByUri]);
+    diagnosticsTransport.incrementDiagnosticsVersion();
+  }, [diagnosticsByUri, diagnosticsTransport]);
 
   useEffect(() => {
-    diagnosticsContextRef.current = formatDiagnosticsForAi({
-      definition: petriNetDefinition,
-      diagnosticsByUri,
-    });
-  }, [diagnosticsByUri, petriNetDefinition]);
-
-  /* eslint-disable react-hooks-js/refs -- See the `"use no memo"` directive
-     above: the refs are only read when the wrapped transport runs, never during
-     render. The lint rule can't see that. */
-  const buildWrappedTransport = (transport: typeof aiAssistant.transport) =>
-    // The timing wrapper sits on the outside so reasoning-chunk receipt is
-    // tagged with `Date.now()` even when the inner diagnostics wrapper has
-    // added the post-tool diagnostics context message to the request. Order
-    // matters here only insofar as the timing wrapper consumes the *response*
-    // stream from whatever inner transport produced it — it does not touch
-    // the request side.
-    createReasoningTimingAwareAiTransport(
-      createDiagnosticsAwareAiTransport({
-        getDiagnosticsContext: () => diagnosticsContextRef.current,
-        transport,
-        waitForDiagnosticsRefresh: () =>
-          waitForDiagnosticsRefresh({
-            consumePendingMutationDiagnosticsVersion: () => {
-              const pendingVersion =
-                pendingMutationDiagnosticsVersionRef.current;
-              pendingMutationDiagnosticsVersionRef.current = null;
-              return pendingVersion;
-            },
-            diagnosticsVersionRef,
-          }),
+    diagnosticsTransport.setDiagnosticsContext(
+      formatDiagnosticsForAi({
+        definition: petriNetDefinition,
+        diagnosticsByUri,
       }),
     );
-
-  const [diagnosticsTransportState, setDiagnosticsTransportState] = useState(
-    () => ({
-      source: aiAssistant.transport,
-      transport: buildWrappedTransport(aiAssistant.transport),
-    }),
+  }, [diagnosticsByUri, diagnosticsTransport, petriNetDefinition]);
+
+  const buildWrappedTransport = useCallback(
+    (transport: typeof aiAssistant.transport) =>
+      // The timing wrapper sits on the outside so reasoning-chunk receipt is
+      // tagged with `Date.now()` even when the inner diagnostics wrapper has
+      // added the post-tool diagnostics context message to the request. Order
+      // matters here only insofar as the timing wrapper consumes the *response*
+      // stream from whatever inner transport produced it — it does not touch
+      // the request side.
+      createReasoningTimingAwareAiTransport(
+        createDiagnosticsAwareAiTransport({
+          getDiagnosticsContext: diagnosticsTransport.getDiagnosticsContext,
+          transport,
+          waitForDiagnosticsRefresh: () =>
+            waitForDiagnosticsRefresh({
+              consumePendingMutationDiagnosticsVersion:
+                diagnosticsTransport.consumePendingMutationDiagnosticsVersion,
+              getDiagnosticsVersion: diagnosticsTransport.getDiagnosticsVersion,
+            }),
+        }),
+      ),
+    [diagnosticsTransport],
   );
 
-  useEffect(() => {
-    if (diagnosticsTransportState.source === aiAssistant.transport) {
-      return;
-    }
-
-    setDiagnosticsTransportState({
-      source: aiAssistant.transport,
-      transport: buildWrappedTransport(aiAssistant.transport),
-    });
-  }, [aiAssistant.transport, diagnosticsTransportState.source]);
-  /* eslint-enable react-hooks-js/refs */
+  const wrappedDiagnosticsTransport = useMemo(
+    () => buildWrappedTransport(aiAssistant.transport),
+    [aiAssistant.transport, buildWrappedTransport],
+  );
 
   // Stream errors (server returned an error chunk, function timed out, etc.)
   // are otherwise opaque to the user — `useChat` resets `status` to `"ready"`
@@ -495,6 +529,7 @@ export const AiAssistantPanel = ({
           : {}),
         resume: () => controls.resume(),
         setMicrophoneMuted: (muted) => controls.setMicrophoneMuted(muted),
+        ...(controls.takeTurn ? { takeTurn: controls.takeTurn } : {}),
       });
 
       return () => {
@@ -525,7 +560,7 @@ export const AiAssistantPanel = ({
       ? {}
       : { id: aiAssistant.conversationId }),
     messages: aiAssistant.messages,
-    transport: diagnosticsTransportState.transport,
+    transport: wrappedDiagnosticsTransport,
     sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
     // Without throttling, every reasoning-delta / text-delta chunk triggers a
     // full re-render of `AiAssistantContents`, and the SDK `structuredClone`s
@@ -605,17 +640,14 @@ export const AiAssistantPanel = ({
 
       if (toolCall.toolName === getNetCompilationErrorsToolName) {
         await waitForDiagnosticsRefresh({
-          consumePendingMutationDiagnosticsVersion: () => {
-            const pendingVersion = pendingMutationDiagnosticsVersionRef.current;
-            pendingMutationDiagnosticsVersionRef.current = null;
-            return pendingVersion;
-          },
-          diagnosticsVersionRef,
+          consumePendingMutationDiagnosticsVersion:
+            diagnosticsTransport.consumePendingMutationDiagnosticsVersion,
+          getDiagnosticsVersion: diagnosticsTransport.getDiagnosticsVersion,
         });
         safelyAddToolOutput(addToolOutput, {
           tool: toolCall.toolName,
           toolCallId: toolCall.toolCallId,
-          output: diagnosticsContextRef.current,
+          output: diagnosticsTransport.getDiagnosticsContext(),
         });
         return;
       }
@@ -718,8 +750,7 @@ export const AiAssistantPanel = ({
           return;
         }
 
-        pendingMutationDiagnosticsVersionRef.current =
-          diagnosticsVersionRef.current;
+        diagnosticsTransport.markMutationPending();
 
         const aiToolCall = {
           toolName,
@@ -742,8 +773,7 @@ export const AiAssistantPanel = ({
         toolCall.input,
       );
 
-      pendingMutationDiagnosticsVersionRef.current =
-        diagnosticsVersionRef.current;
+      diagnosticsTransport.markMutationPending();
 
       const aiToolCall = {
         toolName,
@@ -985,6 +1015,7 @@ export const AiAssistantPanel = ({
     }
     if (status === "error") {
       queuedVoiceInputRef.current = null;
+      // eslint-disable-next-line react-hooks-js/set-state-in-effect -- Settle the queued input when the external chat state rejects it.
       setVoiceInputQueued(false);
       queued.reject(new Error("Voice mode could not accept that input."));
       return;
@@ -1121,6 +1152,7 @@ export const AiAssistantPanel = ({
       return;
     }
 
+    // eslint-disable-next-line react-hooks-js/set-state-in-effect -- Consume the host's one-shot initial mode after the panel opens.
     selectInteractionMode(
       initialInteractionMode === "voice" &&
         aiAssistant.renderVoiceMode === undefined
@@ -1142,6 +1174,7 @@ export const AiAssistantPanel = ({
       interactionMode === "voice" &&
       aiAssistant.renderVoiceMode === undefined
     ) {
+      // eslint-disable-next-line react-hooks-js/set-state-in-effect -- Fall back when the host removes Voice support.
       selectInteractionMode("text");
     }
   }, [aiAssistant.renderVoiceMode, interactionMode, selectInteractionMode]);
@@ -1163,9 +1196,11 @@ export const AiAssistantPanel = ({
 
     submittedInitialMessageRef.current = trimmedInitialMessage;
     onInitialMessageConsumed?.();
+    /* eslint-disable react-hooks-js/set-state-in-effect -- Consume the host's one-shot initial message into composer state. */
     setInput("");
     setStreamError(null);
     setStopped(false);
+    /* eslint-enable react-hooks-js/set-state-in-effect */
     stopRequestedRef.current = false;
 
     submitUserText(trimmedInitialMessage);
@@ -1202,13 +1237,14 @@ export const AiAssistantPanel = ({
     stop: stopComposer,
     submitText,
   };
-  /* eslint-disable react-hooks-js/refs -- The public render prop receives
-     stable event callbacks that read their refs only when the host invokes
-     them from an event handler or effect. */
-  const composerControl = aiAssistant.renderComposerControl?.(
-    composerControlContext,
-  );
-  const voiceMode = aiAssistant.renderVoiceMode?.({
+  const composerControl =
+    aiAssistant.renderComposerControl === undefined ? undefined : (
+      <AiAssistantComposerControl
+        context={composerControlContext}
+        renderControl={aiAssistant.renderComposerControl}
+      />
+    );
+  const voiceModeContext: PetrinautAiVoiceModeContext = {
     ...composerControlContext,
     canAcceptVoiceInput: !voiceInputQueued,
     inputMode: interactionMode,
@@ -1218,8 +1254,14 @@ export const AiAssistantPanel = ({
     setInputMode: requestInputMode,
     setVoiceActive,
     submitVoiceInput,
-  });
-  /* eslint-enable react-hooks-js/refs */
+  };
+  const voiceMode =
+    aiAssistant.renderVoiceMode === undefined ? undefined : (
+      <AiAssistantVoiceMode
+        context={voiceModeContext}
+        renderVoiceMode={aiAssistant.renderVoiceMode}
+      />
+    );
 
   return (
     <AiAssistantContents
@@ -1300,8 +1342,7 @@ export const AiAssistantPanel = ({
           return;
         }
 
-        pendingMutationDiagnosticsVersionRef.current =
-          diagnosticsVersionRef.current;
+        diagnosticsTransport.markMutationPending();
 
         void instance.commands.applyAutoLayout().then((result) => {
           safelyAddToolOutput(addToolOutput, {
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents.test.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents.test.tsx
index 84af4b577f0..561aecb8987 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents.test.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents.test.tsx
@@ -649,11 +649,16 @@ describe("AiAssistantContents", () => {
       />,
     );
 
-    expect(
-      within(
-        screen.getByText("Spoken workflow").closest("[data-role]")!,
-      ).getByTestId("voice-input-provenance"),
-    ).not.toBeNull();
+    const spokenText = screen.getByText("Spoken workflow");
+    const spokenProvenance = within(
+      spokenText.closest("[data-role]")!,
+    ).getByTestId("voice-input-provenance");
+    expect(spokenProvenance.nextElementSibling).toBe(spokenText);
+    expect(spokenProvenance.textContent).toBe("");
+    expect(spokenProvenance.getAttribute("aria-label")).toBe(
+      "Submitted by voice",
+    );
+    expect(spokenProvenance.querySelector("svg")).not.toBeNull();
     expect(
       within(
         screen.getByText("Typed follow-up").closest("[data-role]")!,
@@ -661,7 +666,7 @@ describe("AiAssistantContents", () => {
     ).toBeNull();
   });
 
-  test("marks only the exact submitted interactive-tool answer named by voice metadata", () => {
+  test("marks every submitted interactive-tool answer named by voice metadata", () => {
     const hostTool = definePetrinautAiInteractiveTool({
       toolName: "answerQuestion",
       inputSchema: {
@@ -670,14 +675,26 @@ describe("AiAssistantContents", () => {
       outputSchema: {
         parse: (raw: unknown) => raw as { answer: string },
       },
-      component: ({ submittedOutput, toolCallId }) => (
-        <span>{`${toolCallId}: ${submittedOutput?.answer}`}</span>
+      supportsSubmittedOutputProvenance: true,
+      component: ({
+        state,
+        submittedOutput,
+        submittedOutputProvenance,
+        toolCallId,
+      }) => (
+        <span data-testid={`answer-${toolCallId}`}>
+          {state === "submitted" ? submittedOutputProvenance : null}
+          <span>{`${toolCallId}: ${submittedOutput?.answer}`}</span>
+        </span>
       ),
     });
     const messages = [
       {
         id: "assistant-questions",
-        metadata: { source: "voice", toolCallId: "question-voice" },
+        metadata: {
+          source: "voice",
+          voiceToolCallIds: ["question-voice-1", "question-voice-2"],
+        },
         role: "assistant",
         parts: [
           {
@@ -692,10 +709,18 @@ describe("AiAssistantContents", () => {
             type: "dynamic-tool",
             toolName: "answerQuestion",
             state: "output-available",
-            toolCallId: "question-voice",
+            toolCallId: "question-voice-1",
             input: { question: "Who approves it?" },
             output: { answer: "The shift lead" },
           },
+          {
+            type: "dynamic-tool",
+            toolName: "answerQuestion",
+            state: "output-available",
+            toolCallId: "question-voice-2",
+            input: { question: "Who acts next?" },
+            output: { answer: "The operator" },
+          },
         ],
       },
     ] as unknown as PetrinautAiMessage[];
@@ -713,25 +738,87 @@ describe("AiAssistantContents", () => {
       />,
     );
 
+    for (const [toolCallId, answer] of [
+      ["question-voice-1", "The shift lead"],
+      ["question-voice-2", "The operator"],
+    ]) {
+      const voiceAnswer = screen.getByTestId(`answer-${toolCallId}`);
+      const voiceProvenance = within(voiceAnswer).getByTestId(
+        "voice-input-provenance",
+      );
+      const voiceText = screen.getByText(`${toolCallId}: ${answer}`);
+
+      expect(voiceProvenance.nextElementSibling).toBe(voiceText);
+      expect(voiceProvenance.textContent).toBe("");
+      expect(voiceProvenance.getAttribute("aria-label")).toBe(
+        "Submitted by voice",
+      );
+      expect(voiceProvenance.querySelector("svg")).not.toBeNull();
+    }
     expect(
-      within(
-        screen
-          .getByText("question-voice: The shift lead")
-          .closest("[data-tool-call-id]")!,
-      ).getByTestId("voice-input-provenance"),
-    ).not.toBeNull();
-    expect(
-      within(
-        screen
-          .getByText("question-typed: The operator")
-          .closest("[data-tool-call-id]")!,
-      ).queryByTestId("voice-input-provenance"),
+      within(screen.getByTestId("answer-question-typed")).queryByTestId(
+        "voice-input-provenance",
+      ),
     ).toBeNull();
-    expect(screen.getAllByTestId("voice-input-provenance")).toHaveLength(1);
+    expect(screen.getAllByTestId("voice-input-provenance")).toHaveLength(2);
     expect(screen.queryByText("The shift lead", { exact: true })).toBeNull();
     expect(container.querySelectorAll('[data-role="user"]')).toHaveLength(0);
   });
 
+  test("keeps trailing voice provenance for interactive tools without a submitted-output prefix", () => {
+    const hostTool = definePetrinautAiInteractiveTool({
+      toolName: "legacyAnswerQuestion",
+      inputSchema: {
+        parse: (raw: unknown) => raw as { question: string },
+      },
+      outputSchema: {
+        parse: (raw: unknown) => raw as { answer: string },
+      },
+      component: ({ submittedOutput }) => (
+        <span data-testid="legacy-answer">{submittedOutput?.answer}</span>
+      ),
+    });
+    const messages = [
+      {
+        id: "assistant-legacy-question",
+        metadata: { source: "voice", toolCallId: "legacy-question" },
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: "legacyAnswerQuestion",
+            state: "output-available",
+            toolCallId: "legacy-question",
+            input: { question: "Who approves it?" },
+            output: { answer: "The shift lead" },
+          },
+        ],
+      },
+    ] as unknown as PetrinautAiMessage[];
+
+    render(
+      <AiAssistantContents
+        input=""
+        interactiveTools={[hostTool]}
+        messages={messages}
+        onClose={noop}
+        onInputChange={noop}
+        onStop={noop}
+        onSubmit={noop}
+        status="ready"
+      />,
+    );
+
+    const legacyAnswer = screen.getByTestId("legacy-answer");
+    const toolContainer = legacyAnswer.closest(
+      "[data-tool-call-id]",
+    ) as HTMLElement;
+    const voiceProvenance = within(toolContainer).getByTestId(
+      "voice-input-provenance",
+    );
+    expect(legacyAnswer.nextElementSibling).toBe(voiceProvenance);
+  });
+
   test("keeps completed messages memoized when interactive tools are omitted", () => {
     const messages: PetrinautAiMessage[] = [
       {
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/tool-list.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/tool-list.tsx
index f566adab421..07c477ecb03 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/tool-list.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/tool-list.tsx
@@ -497,7 +497,8 @@ export const toToolRenderItem = (
       state === "output-available" &&
       typeof part.toolCallId === "string" &&
       message.metadata?.source === "voice" &&
-      message.metadata.toolCallId === part.toolCallId,
+      (message.metadata.voiceToolCallIds?.includes(part.toolCallId) === true ||
+        message.metadata.toolCallId === part.toolCallId),
     errorText:
       state === "output-error" && typeof part.errorText === "string"
         ? part.errorText
@@ -525,6 +526,9 @@ const InteractiveToolItem = ({
   const typedInput = definition.parseInput(input);
 
   if (submitted) {
+    const positionsVoiceProvenance =
+      tool.voiceOrigin && definition.supportsSubmittedOutputProvenance === true;
+
     return (
       <div className={interactiveToolStyle} data-tool-call-id={tool.id}>
         <Widget
@@ -532,9 +536,14 @@ const InteractiveToolItem = ({
           state="submitted"
           submit={() => {}}
           submittedOutput={definition.parseOutput(submittedOutput)}
+          submittedOutputProvenance={
+            positionsVoiceProvenance ? <VoiceInputProvenance /> : undefined
+          }
           toolCallId={tool.id}
         />
-        {tool.voiceOrigin && <VoiceInputProvenance />}
+        {tool.voiceOrigin && !positionsVoiceProvenance && (
+          <VoiceInputProvenance />
+        )}
       </div>
     );
   }
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-dock.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-dock.tsx
index 823bbed7fac..d2ad1219ec7 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-dock.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-dock.tsx
@@ -5,6 +5,7 @@ import {
   useVoiceSessionActions,
   useVoiceSessionCanReadFullResponse,
   useVoiceSessionCanRepeatQuestion,
+  useVoiceSessionCanTakeTurn,
   useVoiceSessionMicrophoneMuted,
   useVoiceSessionPhase,
 } from "../../../../../../react/voice-session/use-voice-session";
@@ -105,6 +106,7 @@ export type VoiceDockProps = {
   actions: VoiceSessionActions | null;
   canReadFullResponse: boolean;
   canRepeatQuestion: boolean;
+  canTakeTurn: boolean;
   /** Rendered instead of the live indicator when the caller supplies one. */
   indicator?: ReactNode;
   microphoneMuted: boolean;
@@ -124,6 +126,7 @@ export const VoiceDock = ({
   actions,
   canReadFullResponse,
   canRepeatQuestion,
+  canTakeTurn,
   indicator,
   microphoneMuted,
   onTranscriptionToggle,
@@ -176,6 +179,17 @@ export const VoiceDock = ({
       <span className={`${sideStyle} ${actionsStyle}`}>
         {actions !== null && (
           <>
+            {canTakeTurn && actions.takeTurn && (
+              <Button
+                aria-label={voiceSessionActionLabels.takeTurn}
+                iconName="arrowsLeftRight"
+                onClick={() => void actions.takeTurn?.()}
+                size="sm"
+                tooltip={voiceSessionActionLabels.takeTurn}
+                type="button"
+                variant="ghost"
+              />
+            )}
             {phase === "error" ? (
               <Button
                 aria-label={voiceSessionActionLabels.reconnect}
@@ -247,6 +261,7 @@ export const LiveVoiceDock = ({
   const actions = useVoiceSessionActions();
   const canReadFullResponse = useVoiceSessionCanReadFullResponse();
   const canRepeatQuestion = useVoiceSessionCanRepeatQuestion();
+  const canTakeTurn = useVoiceSessionCanTakeTurn();
   const microphoneMuted = useVoiceSessionMicrophoneMuted();
   const phase = useVoiceSessionPhase();
 
@@ -259,6 +274,7 @@ export const LiveVoiceDock = ({
       actions={actions}
       canReadFullResponse={canReadFullResponse}
       canRepeatQuestion={canRepeatQuestion}
+      canTakeTurn={canTakeTurn}
       microphoneMuted={microphoneMuted}
       onTranscriptionToggle={onTranscriptionToggle}
       phase={phase}
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-input-provenance.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-input-provenance.tsx
index 2cc4c114fcd..7a66e28cc36 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-input-provenance.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/ai-assistant-contents/voice-input-provenance.tsx
@@ -2,25 +2,27 @@ import { css } from "@hashintel/ds-helpers/css";
 
 // Sits in the text flow ahead of the words it belongs to, so a spoken turn is
 // marked where reading starts rather than by something trailing the bubble.
-const chipStyle = css({
+const iconStyle = css({
   display: "inline-flex",
   alignItems: "center",
-  gap: "[3px]",
+  justifyContent: "center",
+  width: "4",
+  height: "4",
+  flexShrink: "0",
   marginRight: "[6px]",
-  padding: "[1px 6px 1px 4px]",
   borderRadius: "full",
   backgroundColor: "blue.a30",
   color: "blue.s110",
-  fontSize: "[10px]",
-  fontWeight: "semibold",
-  letterSpacing: "[0.03em]",
-  textTransform: "uppercase",
-  verticalAlign: "[1px]",
-  whiteSpace: "nowrap",
+  verticalAlign: "middle",
 });
 
 export const VoiceInputProvenance = () => (
-  <span className={chipStyle} data-testid="voice-input-provenance">
+  <span
+    aria-label="Submitted by voice"
+    className={iconStyle}
+    data-testid="voice-input-provenance"
+    role="img"
+  >
     <svg
       aria-hidden="true"
       fill="none"
@@ -36,6 +38,5 @@ export const VoiceInputProvenance = () => (
         strokeWidth="2.4"
       />
     </svg>
-    Voice
   </span>
 );
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/diagnostics-transport-state.ts b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/diagnostics-transport-state.ts
new file mode 100644
index 00000000000..8105a8d1a23
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/diagnostics-transport-state.ts
@@ -0,0 +1,26 @@
+export class DiagnosticsTransportState {
+  readonly getDiagnosticsContext = () => this.diagnosticsContext;
+  readonly getDiagnosticsVersion = () => this.diagnosticsVersion;
+
+  private diagnosticsContext = "No current TypeScript diagnostics.";
+  private diagnosticsVersion = 0;
+  private pendingMutationDiagnosticsVersion: number | null = null;
+
+  consumePendingMutationDiagnosticsVersion = () => {
+    const pendingVersion = this.pendingMutationDiagnosticsVersion;
+    this.pendingMutationDiagnosticsVersion = null;
+    return pendingVersion;
+  };
+
+  incrementDiagnosticsVersion = () => {
+    this.diagnosticsVersion += 1;
+  };
+
+  markMutationPending = () => {
+    this.pendingMutationDiagnosticsVersion = this.diagnosticsVersion;
+  };
+
+  setDiagnosticsContext = (diagnosticsContext: string) => {
+    this.diagnosticsContext = diagnosticsContext;
+  };
+}
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/host-controls.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/host-controls.tsx
new file mode 100644
index 00000000000..c877bd021b0
--- /dev/null
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/host-controls.tsx
@@ -0,0 +1,22 @@
+import type {
+  PetrinautAiComposerControl,
+  PetrinautAiComposerControlContext,
+  PetrinautAiVoiceMode,
+  PetrinautAiVoiceModeContext,
+} from "../../../../types/ai-assistant-composer-control";
+
+export const AiAssistantComposerControl = ({
+  context,
+  renderControl,
+}: {
+  context: PetrinautAiComposerControlContext;
+  renderControl: PetrinautAiComposerControl;
+}) => renderControl(context);
+
+export const AiAssistantVoiceMode = ({
+  context,
+  renderVoiceMode,
+}: {
+  context: PetrinautAiVoiceModeContext;
+  renderVoiceMode: PetrinautAiVoiceMode;
+}) => renderVoiceMode(context);
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.test.tsx b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.test.tsx
index 4204e6a3a34..fc5a03b89e4 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.test.tsx
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.test.tsx
@@ -20,6 +20,7 @@ const hostTool = definePetrinautAiInteractiveTool({
   outputSchema: {
     parse: (raw: unknown) => raw as { approved: boolean },
   },
+  supportsSubmittedOutputProvenance: true,
   component: () => null,
 });
 
@@ -35,6 +36,7 @@ describe("interactive tool registry", () => {
     expect(definition.parseInput({ question: "Ship this change?" })).toEqual({
       question: "Ship this change?",
     });
+    expect(definition.supportsSubmittedOutputProvenance).toBe(true);
     expect(() => definition.parseInput({ question: 42 })).toThrow(
       "Expected a question",
     );
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.ts b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.ts
index 6f75651ceca..59727ecb93c 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.ts
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/registry.ts
@@ -63,6 +63,8 @@ export const getInteractiveTool = (
             parseInput: hostDefinition.parseInput,
             parseOutput: hostDefinition.parseOutput,
             fromComposerText: hostDefinition.fromComposerText,
+            supportsSubmittedOutputProvenance:
+              hostDefinition.supportsSubmittedOutputProvenance,
             Widget: hostDefinition.component,
           }
         : undefined;
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/types.ts b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/types.ts
index 5de09166f9a..cca54ea2436 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/types.ts
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/interactive-tools/types.ts
@@ -31,5 +31,7 @@ export type InteractiveToolDefinition<Input = unknown, Output = unknown> = {
   parseOutput: (raw: unknown) => Output;
   /** Map composer text to a validated tool output when the host opts in. */
   fromComposerText?: (params: { input: Input; text: string }) => Output;
+  /** Whether the widget positions submitted-output provenance supplied by Petrinaut. */
+  supportsSubmittedOutputProvenance?: true;
   Widget: ComponentType<InteractiveToolWidgetProps<Input, Output>>;
 };
diff --git a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/types.ts b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/types.ts
index b85993db7f8..2139ceb4ee5 100644
--- a/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/types.ts
+++ b/libs/@hashintel/petrinaut/src/ui/views/Editor/panels/ai-assistant-panel/types.ts
@@ -50,7 +50,9 @@ type PetrinautAiUiTools = {
 /** Persisted provenance for finalized input submitted through Voice mode. */
 export type PetrinautAiMessageMetadata = {
   source: "voice";
-  /** Identifies the interactive tool output carrying the spoken answer. */
+  /** Identifies every interactive tool output carrying a spoken answer. */
+  voiceToolCallIds?: string[];
+  /** Legacy single-answer provenance retained for persisted preview messages. */
   toolCallId?: string;
 };