@runtypelabs/persona 4.30.0 → 4.31.0

package/src/ui.page-cache.test.ts

@@ -0,0 +1,268 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { createAgentExperience } from "./ui";
+import type { AgentWidgetConfig, SpeechEngine, VoiceProvider, VoiceResult, VoiceStatus } from "./types";
+
+const controllers: ReturnType<typeof createAgentExperience>[] = [];
+beforeEach(() => { window.scrollTo = vi.fn(); });
+afterEach(() => {
+  controllers.splice(0).forEach(controller => controller.destroy());
+  document.body.replaceChildren();
+  localStorage.clear();
+  sessionStorage.clear();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+function mount(config: AgentWidgetConfig = {}) {
+  const element = document.createElement("div");
+  document.body.append(element);
+  const controller = createAgentExperience(element, {
+    apiUrl: "/local-chat", launcher: { enabled: false }, persistState: false,
+    suggestionChips: [], ...config,
+  });
+  controllers.push(controller);
+  return { controller, element };
+}
+const transition = (name: "pagehide" | "pageshow", persisted = true) =>
+  window.dispatchEvent(new PageTransitionEvent(name, { persisted }));
+
+function voice() {
+  let active = false;
+  let status: (status: VoiceStatus) => void = () => {};
+  let result: (result: VoiceResult) => void = () => {};
+  const provider: VoiceProvider = {
+    type: "custom", connect: vi.fn(async () => {}),
+    disconnect: vi.fn(async () => { active = false; }),
+    startListening: vi.fn(async () => { active = true; status("listening"); }),
+    stopListening: vi.fn(async () => { active = false; status("idle"); }),
+    onStatusChange: callback => { status = callback; },
+    onResult: callback => { result = callback; }, onError: () => {},
+    isBargeInActive: () => active,
+  };
+  return { provider, result: (text: string) => result({ text, isFinal: true, provider: "custom" }) };
+}
+
+it("aborts an active reply while retaining the same transcript and draft through repeated Back restores", async () => {
+  const signals: AbortSignal[] = [];
+  const customFetch = vi.fn((_url, init) => {
+    const signal = init!.signal!;
+    signals.push(signal);
+    return new Promise<Response>((_resolve, reject) => {
+      signal.addEventListener("abort", () => reject(new DOMException("Stopped", "AbortError")), { once: true });
+    });
+  });
+  const { controller, element } = mount({ customFetch });
+  for (let cycle = 0; cycle < 3; cycle++) {
+    expect(controller.submitMessage(`Question ${cycle}`)).toBe(true);
+    await vi.waitFor(() => expect(signals).toHaveLength(cycle + 1));
+    const input = element.querySelector<HTMLTextAreaElement>("[data-persona-composer-input]")!;
+    input.value = "Keep this draft";
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    transition("pagehide");
+    expect(signals[cycle].aborted).toBe(true);
+    expect(controller.getState().streaming).toBe(false);
+    transition("pageshow");
+    expect(element.querySelector("[data-persona-composer-input]")).toBe(input);
+    expect(controller.getComposerState().text).toBe("Keep this draft");
+    expect(controller.getMessages().some(message => message.content === `Question ${cycle}`)).toBe(true);
+    await Promise.resolve();
+    expect(customFetch).toHaveBeenCalledTimes(cycle + 1);
+  }
+});
+
+it("disconnects session voice on cached hide and keeps the controls usable without restarting the call", async () => {
+  const { provider } = voice();
+  const { controller } = mount({ voiceRecognition: { enabled: true, provider: { type: "custom", custom: () => provider } } });
+  for (let cycle = 0; cycle < 2; cycle++) {
+    controller.startVoiceRecognition();
+    await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledTimes(cycle + 1));
+    transition("pagehide");
+    expect(provider.disconnect).toHaveBeenCalledTimes(cycle + 1);
+    expect(controller.isVoiceActive()).toBe(false);
+    transition("pageshow");
+    await Promise.resolve();
+    expect(provider.startListening).toHaveBeenCalledTimes(cycle + 1);
+  }
+});
+
+it("does not let a pending microphone start cross a cached navigation", async () => {
+  const { provider } = voice();
+  const { controller } = mount({ voiceRecognition: { enabled: true, provider: { type: "custom", custom: () => provider } } });
+  controller.startVoiceRecognition();
+  transition("pagehide");
+  transition("pageshow");
+  await new Promise(resolve => setTimeout(resolve, 50));
+  expect(provider.startListening).not.toHaveBeenCalled();
+  controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+});
+
+it("cancels dictation without submitting its final result or losing the previous draft", async () => {
+  const { provider, result } = voice();
+  const { controller } = mount({ voiceRecognition: { enabled: true, completionBehavior: "review",
+    dictation: { provider: { type: "custom", custom: () => provider } } } });
+  controller.setMessage("Original draft");
+  controller.startDictation();
+  await vi.waitFor(() => expect(controller.getDictationState().phase).toBe("recording"));
+  transition("pagehide");
+  result("Late transcript");
+  transition("pageshow");
+  await vi.waitFor(() => expect(provider.disconnect).toHaveBeenCalled());
+  expect(controller.getDictationState().phase).toBe("idle");
+  expect(controller.getComposerState().text).toBe("Original draft");
+  expect(controller.getMessages()).toHaveLength(0);
+});
+
+it("stops browser recognition without accepting a trailing result and can record again on Back", () => {
+  const recordings: Recognition[] = [];
+  class Recognition {
+    onresult: ((event: unknown) => void) | null = null;
+    onend: (() => void) | null = null;
+    onerror: ((event: unknown) => void) | null = null;
+    start = vi.fn();
+    stop = vi.fn();
+    constructor() { recordings.push(this); }
+  }
+  vi.stubGlobal("SpeechRecognition", Recognition);
+  const { controller } = mount({ voiceRecognition: { enabled: true } });
+  controller.setMessage("Keep my draft");
+  expect(controller.startVoiceRecognition()).toBe(true);
+  expect(recordings[0].start).toHaveBeenCalledOnce();
+  transition("pagehide");
+  expect(recordings[0].stop).toHaveBeenCalledOnce();
+  recordings[0].onresult?.({ results: [Object.assign([{ transcript: "Late result" }], { isFinal: true })] });
+  transition("pageshow");
+  expect(controller.getComposerState().text).toBe("Keep my draft");
+  expect(controller.startVoiceRecognition()).toBe(true);
+  expect(recordings[1].start).toHaveBeenCalledOnce();
+  expect(controller.getMessages()).toHaveLength(0);
+});
+
+it("stops read-aloud playback on cached hide and does not resume it on Back", async () => {
+  const engine: SpeechEngine = { id: "cache-test", supportsPause: false,
+    speak: vi.fn((_request, callbacks) => { callbacks.onStart?.(); }),
+    stop: vi.fn(), pause: vi.fn(), resume: vi.fn(),
+  };
+  const { controller } = mount({ textToSpeech: { enabled: true, createEngine: () => engine } });
+  const message = controller.injectAssistantMessage({ content: "Read this reply aloud." });
+  controller.toggleReadAloud(message.id);
+  await vi.waitFor(() => expect(controller.getReadAloudState(message.id)).toBe("playing"));
+  transition("pagehide");
+  expect(engine.stop).toHaveBeenCalled();
+  expect(controller.getReadAloudState(message.id)).toBe("idle");
+  transition("pageshow");
+  await Promise.resolve();
+  expect(engine.speak).toHaveBeenCalledOnce();
+});
+
+it("abandons an asynchronous before-send hook and leaves its draft sendable after Back", async () => {
+  let finishHook: () => void = () => {};
+  let signal: AbortSignal | undefined;
+  const hook = vi.fn((_snapshot, context) => {
+    signal = context.signal;
+    return new Promise<void>(resolve => { finishHook = resolve; });
+  });
+  const customFetch = vi.fn(async () => new Response("", { headers: { "content-type": "text/event-stream" } }));
+  const { controller, element } = mount({ composer: { onBeforeSend: hook }, customFetch });
+  controller.setMessage("Unsent draft");
+  element.querySelector<HTMLButtonElement>("[data-persona-composer-submit]")!.click();
+  await vi.waitFor(() => expect(hook).toHaveBeenCalledOnce());
+  transition("pagehide");
+  expect(signal?.aborted).toBe(true);
+  transition("pageshow");
+  expect(customFetch).not.toHaveBeenCalled();
+  expect(controller.getComposerState().text).toBe("Unsent draft");
+  let finishNext: () => void = () => {};
+  const nextHook = vi.fn(() => new Promise<void>(resolve => { finishNext = resolve; }));
+  controller.update({ composer: { onBeforeSend: nextHook } });
+  element.querySelector<HTMLButtonElement>("[data-persona-composer-submit]")!.click();
+  await vi.waitFor(() => expect(nextHook).toHaveBeenCalledOnce());
+  finishHook();
+  await Promise.resolve();
+  element.querySelector<HTMLButtonElement>("[data-persona-composer-submit]")!.click();
+  expect(nextHook).toHaveBeenCalledOnce();
+  expect(customFetch).not.toHaveBeenCalled();
+  finishNext();
+  await vi.waitFor(() => expect(customFetch).toHaveBeenCalledOnce());
+});
+
+it("retains the live-call metadata used to redial on a genuine document navigation", async () => {
+  const { provider } = voice();
+  const { controller } = mount({ voiceRecognition: { enabled: true, provider: { type: "custom", custom: () => provider } } });
+  controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  transition("pagehide", false);
+  expect(provider.disconnect).not.toHaveBeenCalled();
+  controller.destroy();
+  controllers.splice(controllers.indexOf(controller), 1);
+  expect(provider.disconnect).toHaveBeenCalledOnce();
+  expect(controller.getPersistentMetadata().voiceState).toMatchObject({ active: true });
+});
+
+it.each(["queued", "late", "injected"])("discards %s action resubmits across Back and accepts fresh actions", async mode => {
+  vi.useFakeTimers();
+  try {
+    let trigger = () => {};
+    const customFetch = vi.fn(async () => new Response("", { headers: { "content-type": "text/event-stream" } }));
+    const { controller } = mount({ customFetch, actionHandlers: [(_action, context) => {
+      trigger = context.triggerResubmit;
+      return { handled: true, displayText: "Action handled", resubmit: mode === "injected" };
+    }] });
+    controller.injectAssistantMessage({ content: '{"action":"search"}' });
+    await vi.advanceTimersByTimeAsync(0);
+    if (mode === "queued") trigger();
+    transition("pagehide");
+    transition("pageshow");
+    if (mode === "late") trigger();
+    if (mode === "injected") controller.injectAssistantMessage({ content: "Late result" });
+    await vi.advanceTimersByTimeAsync(200);
+    expect(customFetch).not.toHaveBeenCalled();
+    controller.injectAssistantMessage({ content: '{"action":"search"}' });
+    await vi.advanceTimersByTimeAsync(0);
+    if (mode !== "injected") trigger();
+    await vi.advanceTimersByTimeAsync(200);
+    expect(customFetch).toHaveBeenCalledOnce();
+  } finally { vi.useRealTimers(); }
+});
+
+it.each(["back", "destroy", "navigation"])("guards queued metadata voice restoration on %s", async lifecycle => {
+  vi.useFakeTimers();
+  try {
+    const { provider } = voice();
+    const { controller } = mount({
+      persistState: true, storageAdapter: { load: () => ({ messages: [], metadata: { voiceState: { active: true, timestamp: Date.now() } } }), save: () => {} },
+      voiceRecognition: { enabled: true, provider: { type: "custom", custom: () => provider } },
+    });
+    if (lifecycle === "back") { transition("pagehide"); transition("pageshow"); }
+    if (lifecycle === "destroy") controller.destroy();
+    await vi.advanceTimersByTimeAsync(1100);
+    expect(provider.startListening).toHaveBeenCalledTimes(lifecycle === "navigation" ? 1 : 0);
+    if (lifecycle === "back") {
+      controller.startVoiceRecognition();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(provider.startListening).toHaveBeenCalledOnce();
+    }
+  } finally { vi.useRealTimers(); }
+});
+
+it("discards the delayed browser voice restore before Back while allowing a fresh mic tap", async () => {
+  vi.useFakeTimers();
+  try {
+    const start = vi.fn();
+    class Recognition { start = start; stop = vi.fn(); }
+    vi.stubGlobal("SpeechRecognition", Recognition);
+    const { controller } = mount({
+      persistState: true,
+      storageAdapter: { load: () => ({ messages: [], metadata: { voiceState: { active: true, timestamp: Date.now() } } }), save: () => {} },
+      voiceRecognition: { enabled: true },
+    });
+    await vi.advanceTimersByTimeAsync(100);
+    expect(start).not.toHaveBeenCalled();
+    transition("pagehide");
+    transition("pageshow");
+    await vi.advanceTimersByTimeAsync(1100);
+    expect(start).not.toHaveBeenCalled();
+    expect(controller.startVoiceRecognition()).toBe(true);
+    expect(start).toHaveBeenCalledOnce();
+  } finally { vi.useRealTimers(); }
+});

package/src/ui.postprocess.test.ts

@@ -3,7 +3,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { buildPostprocessor } from "./ui";
-import { escapeHtml } from "./postprocessors";
+import { escapeHtml, markdownPostprocessor, preprocessStreamingMarkdown } from "./postprocessors";
 import * as parsersLoader from "./markdown-parsers-loader";
 import type { AgentWidgetConfig, AgentWidgetMessage } from "./types";
 
@@ -93,6 +93,62 @@ describe("buildPostprocessor degraded path (parsers not loaded)", () => {
 });
 
 describe("buildPostprocessor loaded path (parsers available)", () => {
+  it("lets custom callbacks transform text before opting into the shared streaming repairs", () => {
+    const text = "<answer>Read **unfinished";
+    const raw = JSON.stringify({ answer: text });
+    const message: AgentWidgetMessage = {
+      id: "custom-stream", role: "assistant", content: text, rawContent: raw, createdAt: "2026-10-20T00:00:00.000Z",
+    };
+    const custom = vi.fn(({ text, streaming }: { text: string; streaming: boolean }) =>
+      markdownPostprocessor(preprocessStreamingMarkdown(text.replace("<answer>", ""), streaming)));
+    const transform = buildPostprocessor({ postprocessMessage: custom, sanitize: true }, undefined, undefined);
+    const displayText = text.replace("<answer>", "");
+    const builtIn = buildPostprocessor({ markdown: {} }, undefined, undefined);
+    expect(transform({ text, raw, message, streaming: true })).toBe(
+      builtIn({ text: displayText, message, streaming: true }));
+    expect(transform({ text, raw, message, streaming: false })).toBe("<p>Read **unfinished</p>\n");
+    expect(message.content).toBe(text);
+    expect(message.rawContent).toBe(raw);
+    expect(custom.mock.calls[0][0]).toMatchObject({ text, raw, streaming: true });
+  });
+
+  it("repairs streaming display without mutating the stored or final Markdown", () => {
+    const text = "Read **unfinished";
+    const message: AgentWidgetMessage = {
+      id: "stream", role: "assistant", content: text, createdAt: "2026-10-20T00:00:00.000Z",
+    };
+    const transform = buildPostprocessor({ markdown: {} }, undefined, undefined);
+    expect(transform({ text, message, streaming: true })).toContain("<strong>unfinished</strong>");
+    expect(message.content).toBe(text);
+    expect(transform({ text, message, streaming: false })).toBe("<p>Read **unfinished</p>\n");
+  });
+
+  it("leaves custom postprocessors and plain-text rendering untouched during streaming", () => {
+    const text = "**unfinished";
+    const message: AgentWidgetMessage = {
+      id: "stream", role: "assistant", content: text, createdAt: "2026-10-20T00:00:00.000Z",
+    };
+    const custom = vi.fn(({ text }: { text: string }) => escapeHtml(text));
+    const transform = buildPostprocessor({ markdown: {}, postprocessMessage: custom }, undefined, undefined);
+    expect(transform({ text, message, streaming: true })).toBe(text);
+    expect(custom.mock.calls[0][0].text).toBe(text);
+    expect(buildPostprocessor(undefined, undefined, undefined)({ text, message, streaming: true })).toBe(text);
+  });
+
+  it("sanitizes completed links after streaming repair and retains legacy custom parser compatibility", () => {
+    const text = "[bad](javascript:alert(1)) **hello";
+    const message: AgentWidgetMessage = {
+      id: "stream", role: "assistant", content: text, createdAt: "2026-10-20T00:00:00.000Z",
+    };
+    const transform = buildPostprocessor({ markdown: {} }, undefined, undefined);
+    const out = transform({ text, message, streaming: true });
+    expect(out).toContain("<strong>hello</strong>");
+    expect(out).not.toContain("javascript:");
+    const parsers = parsersLoader.getMarkdownParsersSync()!;
+    vi.spyOn(parsersLoader, "getMarkdownParsersSync").mockReturnValue({ Marked: parsers.Marked, DOMPurify: parsers.DOMPurify });
+    expect(transform({ text, message, streaming: true })).toContain("**hello");
+  });
+
   it("renders markdown to real HTML, normalizes apostrophes, strips scripts", () => {
     // No spy: vitest.setup.ts eager-provides parsers, so this is the loaded path.
     const text = "**bold** I'll go\n\n<script>alert(1)</script>";
@@ -152,3 +208,26 @@ describe("buildPostprocessor failure containment", () => {
     expect(out).toBe(escapeHtml(SAMPLE));
   });
 });
+
+describe("preprocessStreamingMarkdown parser readiness", () => {
+  it("leaves final text unchanged even when a parser repair would modify it", () => {
+    const repair = vi.fn(() => "repaired");
+    const parsers = parsersLoader.getMarkdownParsersSync()!;
+    vi.spyOn(parsersLoader, "getMarkdownParsersSync").mockReturnValue({ ...parsers, stabilizeStreamingMarkdown: repair });
+    expect(preprocessStreamingMarkdown("**unfinished", false)).toBe("**unfinished");
+    expect(repair).not.toHaveBeenCalled();
+    expect(preprocessStreamingMarkdown("**unfinished", true)).toBe("repaired");
+  });
+
+  it("uses the same lightweight table fallback before parsers load and with legacy loaders", () => {
+    const parsers = parsersLoader.getMarkdownParsersSync()!;
+    const text = "| A | B |\n| ---";
+    vi.spyOn(parsersLoader, "getMarkdownParsersSync").mockReturnValue(null);
+    const beforeLoad = preprocessStreamingMarkdown(text, true);
+    expect(beforeLoad).not.toBe(text);
+    expect(preprocessStreamingMarkdown("**unfinished", true)).toBe("**unfinished");
+    vi.mocked(parsersLoader.getMarkdownParsersSync).mockReturnValue({ Marked: parsers.Marked, DOMPurify: parsers.DOMPurify });
+    expect(preprocessStreamingMarkdown(text, true)).toBe(beforeLoad);
+    expect(preprocessStreamingMarkdown(text, false)).toBe(text);
+  });
+});

package/src/ui.ts

@@ -11,9 +11,8 @@ import { isBrowserLocalApproval } from "./utils/restored-browser-state";
 import { applyStatusIndicatorState, placeStatusIndicator } from "./utils/status-indicator";
 import type { DictationSession } from "./dictation-session";
 import { usesSessionVoice, usesSessionVoiceForConfig } from "./utils/voice-support";
-import { escapeHtml, createMarkdownProcessorFromConfig } from "./postprocessors";
+import { escapeHtml, createMarkdownProcessorFromConfig, preprocessStreamingMarkdown } from "./postprocessors";
 import { resolveSanitizer } from "./utils/sanitize";
-import { stabilizeStreamingTables } from "./utils/streaming-table";
 import { wrapScrollableTables, refreshTableScrollFades } from "./utils/table-scroll-fade";
 import { getMarkdownParsersSync } from "./markdown-parsers-loader";
 import { loadClientStream } from "./client-stream-loader";
@@ -817,7 +816,8 @@ export const buildPostprocessor = (
     // displayed entities literally (I'll -> '). Only run the sanitizer when
     // it can actually parse HTML; escapeHtml output is already inert. Checked per
     // render (not once at setup): the chunk lands later and the self-heal re-renders.
-    const parsersReady = getMarkdownParsersSync() !== null;
+    const parsers = getMarkdownParsersSync();
+    const parsersReady = parsers !== null;
     let html: string;
     if (cfg?.postprocessMessage) {
       const out = cfg.postprocessMessage({
@@ -829,10 +829,9 @@ export const buildPostprocessor = (
       // sanitizer's degraded fallback. Honors `sanitize: false` (pass-through) as before.
       html = sanitize ? sanitize(out) : out;
     } else if (markdownProcessor) {
-      // While streaming, normalize tables-in-progress so they render as a real
-      // <table> from the first row with a stable column count (Telegram-style
-      // space reservation). The final, non-streaming render is left untouched.
-      const source = context.streaming ? stabilizeStreamingTables(nextText) : nextText;
+      // Stabilize incomplete Markdown only for display during streaming. The
+      // final render and the stored response always use the original text.
+      const source = preprocessStreamingMarkdown(nextText, context.streaming);
       // Already escapeHtml(text) (single, safe) while parsers are not loaded.
       const out = markdownProcessor(source);
       html = sanitize && parsersReady ? sanitize(out) : out;
@@ -1226,6 +1225,10 @@ export const createAgentExperience = (
     getSessionMetadata,
     updateSessionMetadata,
     emit: eventBus.emit,
+    captureResubmitGuard: () => {
+      const generation = restartGeneration;
+      return () => canRestart(generation);
+    },
     documentRef: typeof document !== "undefined" ? document : null
   });
   actionManager.syncFromMetadata();
@@ -1250,10 +1253,31 @@ export const createAgentExperience = (
   // Track pending resubmit state for injection-triggered resubmit
   // When a handler returns resubmit: true, we wait for injectAssistantMessage()
   // to be called before triggering the actual resubmit (to avoid race conditions)
+  // Cached restoration reuses this controller, so work queued by the old page
+  // lifecycle must remain stale even after pageshow makes the page active again.
+  let restartGeneration = 0;
+  let destroyed = false;
+  const canRestart = (generation: number) =>
+    !destroyed && !pageHiding && generation === restartGeneration;
+  const invalidatePendingRestarts = () => {
+    restartGeneration++;
+    pendingResubmit = false;
+    if (pendingResubmitTimeout !== null) clearTimeout(pendingResubmitTimeout);
+    pendingResubmitTimeout = null;
+  };
+  const scheduleResubmit = () => {
+    const generation = restartGeneration;
+    if (!canRestart(generation)) return;
+    setTimeout(() => {
+      if (canRestart(generation) && !session.isStreaming()) session.continueConversation();
+    }, 100);
+  };
+
   let pendingResubmit = false;
   let pendingResubmitTimeout: ReturnType<typeof setTimeout> | null = null;
 
   const handleResubmitRequested = () => {
+    if (!canRestart(restartGeneration)) return;
     pendingResubmit = true;
     // Clear any existing timeout
     if (pendingResubmitTimeout) {
@@ -5166,11 +5190,14 @@ export const createAgentExperience = (
     const timestamp = Number(rawVoiceState.timestamp ?? 0);
     voiceState.manuallyDeactivated = Boolean(rawVoiceState.manuallyDeactivated);
     if (wasActive && Date.now() - timestamp < VOICE_STATE_RESTORE_WINDOW) {
+      const generation = restartGeneration;
       setTimeout(() => {
+        if (!canRestart(generation)) return;
         if (!voiceState.active) {
           voiceState.manuallyDeactivated = false;
           if (usesSessionVoice(config.voiceRecognition?.provider)) {
             session.toggleVoice().then(() => {
+              if (!canRestart(generation)) return;
               voiceState.active = isSessionVoiceLive();
               emitVoiceState("restore");
               if (voiceState.active) {
@@ -5192,10 +5219,10 @@ export const createAgentExperience = (
     }
   };
   // Re-stamp a live call as the page unloads: the restore window counts from
-  // the navigation, not from when the (possibly long) call was started. A
-  // back/forward-cache hide (`persisted`) isn't an unload: the page lives on.
-  const handleVoicePageHide = (event: PageTransitionEvent) => {
-    pageHiding = !event.persisted;
+  // the navigation, not from when the (possibly long) call was started. Protect
+  // that record from the trailing disconnect statuses, including cached hides.
+  const handleVoicePageHide = () => {
+    pageHiding = true;
     if (voiceState.active) persistVoiceMetadata();
   };
   if (typeof window !== "undefined") {
@@ -9625,6 +9652,7 @@ export const createAgentExperience = (
   // otherwise dispatch the same text/command twice. It also covers an async
   // `onBeforeSend` (the `preparing` phase).
   let submitInFlight = false;
+  let submitEpoch = 0;
   /** Aborts the in-flight preparation on destroy or a superseding stop. */
   let submissionAbort: AbortController | null = null;
 
@@ -10035,10 +10063,11 @@ export const createAgentExperience = (
     }
     if (submitInFlight) return;
     submitInFlight = true;
+    const epoch = ++submitEpoch;
     try {
       await performSubmit({ resolveInlineCommand: true, ...submitOptions });
     } finally {
-      submitInFlight = false;
+      if (epoch === submitEpoch) submitInFlight = false;
     }
   };
 
@@ -10065,8 +10094,9 @@ export const createAgentExperience = (
   ): void => {
     if (submitInFlight) return;
     submitInFlight = true;
+    const epoch = ++submitEpoch;
     const finish = () => {
-      submitInFlight = false;
+      if (epoch === submitEpoch) submitInFlight = false;
     };
     try {
       const result = performSubmit({ ...options, overrideText: text });
@@ -10508,7 +10538,7 @@ export const createAgentExperience = (
 
     voiceState.active = false;
     emitVoiceState(source);
-    persistVoiceMetadata();
+    if (!pageHiding) persistVoiceMetadata();
     syncComposerCompact();
 
     if (micButton) {
@@ -10698,9 +10728,10 @@ export const createAgentExperience = (
   const pendingSubmissionUnsub = eventBus.on("assistant:complete", () => {
     const pending = composerStore.getState().pendingSubmission;
     const generation = composerConversationGeneration;
+    const restart = restartGeneration;
     if (!pending) return;
     setTimeout(() => {
-      if (session.isStreaming() || generation !== composerConversationGeneration || composerStore.getState().pendingSubmission !== pending) return;
+      if (!canRestart(restart) || session.isStreaming() || generation !== composerConversationGeneration || composerStore.getState().pendingSubmission !== pending) return;
       sendPendingSubmission();
     }, 0);
   });
@@ -10713,11 +10744,13 @@ export const createAgentExperience = (
       return;
     }
     const generation = composerConversationGeneration;
+    const restart = restartGeneration;
     setTimeout(() => {
-      if (generation !== composerConversationGeneration) return;
+      if (!canRestart(restart) || generation !== composerConversationGeneration) return;
       if (!voiceState.active && !voiceState.manuallyDeactivated) {
         if (usesSessionVoice(config.voiceRecognition?.provider)) {
           session.toggleVoice().then(() => {
+            if (!canRestart(restart) || generation !== composerConversationGeneration) return;
             voiceState.active = session.isVoiceActive();
             emitVoiceState("auto");
             if (session.isVoiceActive()) applyRuntypeMicRecordingStyles();
@@ -10730,17 +10763,50 @@ export const createAgentExperience = (
   });
   destroyCallbacks.push(autoResumeUnsub);
 
+  // A cached document retains its DOM and controller, but must release live
+  // transports and capture before it freezes. A fresh navigation still uses
+  // the existing teardown/voice-metadata path above.
+  let cachedPage = false;
+  const suspendCachedPage = (event: PageTransitionEvent) => {
+    if (!event.persisted || cachedPage) return;
+    cachedPage = true;
+    pageHiding = true;
+    invalidatePendingRestarts();
+    composerConversationGeneration++;
+    submitEpoch++;
+    submitInFlight = false;
+    submissionAbort?.abort();
+    submissionAbort = null;
+    composerStore.setPreparing(false);
+    dismissDictation();
+    stopVoiceRecognition("system");
+    session.cancel();
+    session.stopSpeaking();
+    session.cleanupVoice();
+    throughputTracker?.reset();
+    eventStreamView?.update();
+  };
+  const restoreCachedPage = (event: PageTransitionEvent) => {
+    if (!event.persisted || !cachedPage) return;
+    cachedPage = false;
+    pageHiding = false;
+    // Rebuild the provider lazily so the same controls can start a new call.
+    // Neither stopped replies nor calls restart automatically on Back.
+    if (config.voiceRecognition?.enabled === true && usesSessionVoiceForConfig(config)) session.setupVoice();
+  };
+  window.addEventListener("pagehide", suspendCachedPage);
+  window.addEventListener("pageshow", restoreCachedPage);
+  destroyCallbacks.push(() => {
+    window.removeEventListener("pagehide", suspendCachedPage);
+    window.removeEventListener("pageshow", restoreCachedPage);
+  });
+
   // Handle action:resubmit event - automatically trigger another model call
   // when an action handler needs the model to continue processing (e.g., analyzing search results)
   const resubmitUnsub = eventBus.on("action:resubmit", () => {
     // Short delay to allow UI to update with any injected messages
     // Handlers should call context.triggerResubmit() AFTER their async work completes
-    setTimeout(() => {
-      if (session && !session.isStreaming()) {
-        // Continue conversation without adding a visible user message
-        session.continueConversation();
-      }
-    }, 100);
+    scheduleResubmit();
   });
   destroyCallbacks.push(resubmitUnsub);
 
@@ -12234,6 +12300,10 @@ export const createAgentExperience = (
         getSessionMetadata,
         updateSessionMetadata,
         emit: eventBus.emit,
+        captureResubmitGuard: () => {
+          const generation = restartGeneration;
+          return () => canRestart(generation);
+        },
         documentRef: typeof document !== "undefined" ? document : null
       });
 
@@ -12883,11 +12953,7 @@ export const createAgentExperience = (
           pendingResubmitTimeout = null;
         }
         // Short delay to ensure message is in context
-        setTimeout(() => {
-          if (session && !session.isStreaming()) {
-            session.continueConversation();
-          }
-        }, 100);
+        scheduleResubmit();
       }
 
       return result;
@@ -13224,6 +13290,8 @@ export const createAgentExperience = (
       return session.submitNPSFeedback(rating, comment);
     },
     destroy() {
+      destroyed = true;
+      invalidatePendingRestarts();
       renderReadiness.destroy();
       slots.destroy();
       mount.removeEventListener("click", routeLinkClick);

package/src/utils/actions.ts

@@ -28,6 +28,7 @@ type ActionManagerOptions = {
     payload: AgentWidgetControllerEventMap[K]
   ) => void;
   documentRef: Document | null;
+  captureResubmitGuard?: () => () => boolean;
 };
 
 const stripCodeFence = (value: string) => {
@@ -195,7 +196,9 @@ export const createActionManager = (options: ActionManagerOptions) => {
       try {
         // Create triggerResubmit function that emits the resubmit event
         // Handlers should call this AFTER async work completes (not return resubmit: true)
+        const canResubmit = options.captureResubmitGuard?.();
         const triggerResubmit = () => {
+          if (canResubmit && !canResubmit()) return;
           options.emit("action:resubmit", eventPayload);
         };