@@ -1,10 +1,10 @@
 import { createMemoryHistory } from "@tanstack/react-router";
-import { scopeProjectRef } from "@t3tools/client-runtime/environment";
-import { ThreadId } from "@t3tools/contracts";
+import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment";
+import { RunId, ThreadId } from "@t3tools/contracts";
 import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
 import type * as Context from "effect/Context";
 import { expect, it, vi } from "vite-plus/test";
-import { page } from "vite-plus/test/browser";
+import { cdp, page } from "vite-plus/test/browser";
 
 import { AppRoot } from "~/AppRoot";
 // The route loads ChatView lazily, and its first transform (React Compiler over ~4k lines)
@@ -13,13 +13,18 @@ import "~/components/ChatView";
 import { DraftId, useComposerDraftStore } from "~/composerDraftStore";
 import { __setClientSettingsForTests } from "~/hooks/useSettings";
 import { getRouter } from "~/router";
+import { appAtomRegistry } from "~/rpc/atomRegistry";
+import { environmentThreadDetails } from "~/state/threads";
 import {
   ENVIRONMENT_ID,
   PROJECT_ID,
+  assistantItem,
+  emitThreadEvent,
   installFakeEnvironment,
+  threadWithHistory,
   type FakeDriver,
 } from "../../test/fakeEnvironment";
-import { render } from "../../test/render";
+import { act, render } from "../../test/render";
 
 // The socket is the only fake layer; see test/appScenarios.renders.tsx.
 vi.mock("../../../../packages/client-runtime/src/connection/driver.ts", async (importOriginal) => {
@@ -65,3 +70,55 @@ it("a new draft does not load its reserved thread before the server lists it", a
   // A 404 here marks the thread deleted, and the view never loads it once the send creates it.
   expect(threadRequests).toEqual([]);
 });
+
+it("a mounted thread view lets go of the thread structures it has replaced", async () => {
+  // Items are shared with the fixture, so a reopen's snapshot also carries the earlier updates.
+  const history = threadWithHistory("updated", 3);
+  const items = [...history.items];
+  const updated = { ...history, items };
+  const other = threadWithHistory("other", 3);
+  using _environment = installFakeEnvironment([updated, other]);
+  __setClientSettingsForTests({
+    ...DEFAULT_CLIENT_SETTINGS,
+    onboardingCompletedAt: "2026-01-01T00:00:00.000Z",
+  });
+  const router = getRouter(createMemoryHistory({ initialEntries: ["/"] }));
+  await router.load();
+  await using _app = await render(<AppRoot router={router} />, { router: false });
+  const open = async (threadId: ThreadId, text: string) => {
+    await act(() =>
+      router.navigate({
+        to: "/$environmentId/$threadId",
+        params: { environmentId: ENVIRONMENT_ID, threadId },
+      }),
+    );
+    await expect.element(page.getByText(text).first()).toBeVisible();
+  };
+  const structureAtom = environmentThreadDetails.quietThreadAtom(
+    scopeThreadRef(ENVIRONMENT_ID, updated.id),
+  );
+
+  // Each round, a new answer arrives while the thread is shown, then the user switches away.
+  const shown: Array<WeakRef<object>> = [];
+  await open(other.id, "Answer 2 for other.");
+  for (let round = 0; round < 6; round++) {
+    await open(updated.id, round === 0 ? "Answer 2 for updated." : `Update ${round - 1}.`);
+    const update = assistantItem(
+      updated.id,
+      RunId.make("updated-run-2"),
+      `updated-update-${round}`,
+      6 + round,
+      `Update ${round}.`,
+    );
+    items.push(update);
+    await act(() => emitThreadEvent(updated.id, { type: "turn-item.updated", payload: update }));
+    await expect.element(page.getByText(`Update ${round}.`)).toBeVisible();
+    shown.push(new WeakRef(appAtomRegistry.get(structureAtom)!.projection));
+    await open(other.id, "Answer 2 for other.");
+  }
+  await cdp().send("HeapProfiler.collectGarbage");
+
+  // The thread keeps its latest structure, and the timeline may remember the one before it.
+  const kept = shown.slice(0, -2).flatMap((structure, round) => (structure.deref() ? [round] : []));
+  expect(kept).toEqual([]);
+});
@@ -0,0 +1,65 @@
+import type { RefObject } from "react";
+import { expect, it, vi } from "vite-plus/test";
+
+import type { ChatComposerHandle } from "./ChatComposer";
+import { registerModelPickerContent } from "../../modelPickerVisibility";
+import { render } from "../../../test/render";
+import { useComposerFocus } from "./useComposerFocus";
+
+type Focus = ReturnType<typeof useComposerFocus>;
+
+function Probe(props: {
+  readonly composerRef: RefObject<ChatComposerHandle | null>;
+  readonly onRender: (focus: Focus) => void;
+}) {
+  props.onRender(useComposerFocus(props.composerRef));
+  return null;
+}
+
+const handle = (focusAtEnd: () => void) => ({ focusAtEnd }) as unknown as ChatComposerHandle;
+
+it("focuses the composer's current handle without changing identity", async () => {
+  const composerRef: RefObject<ChatComposerHandle | null> = { current: null };
+  const renders: Focus[] = [];
+  const onRender = (focus: Focus) => renders.push(focus);
+  await using screen = await render(<Probe composerRef={composerRef} onRender={onRender} />);
+
+  const replaced = vi.fn();
+  const current = vi.fn();
+  composerRef.current = handle(replaced);
+  // The composer replaces its handle as the thread changes, with no render here in between.
+  composerRef.current = handle(current);
+  renders.at(-1)!.focusComposer();
+  expect(current).toHaveBeenCalledTimes(1);
+
+  await screen.rerender(<Probe composerRef={composerRef} onRender={onRender} />);
+  expect(renders.at(-1)!.focusComposer).toBe(renders[0]!.focusComposer);
+  expect(renders.at(-1)!.scheduleComposerFocus).toBe(renders[0]!.scheduleComposerFocus);
+  expect(replaced).not.toHaveBeenCalled();
+});
+
+it("schedules focus for the next frame unless the model picker is open by then", async () => {
+  const focusAtEnd = vi.fn();
+  const composerRef: RefObject<ChatComposerHandle | null> = { current: handle(focusAtEnd) };
+  const renders: Focus[] = [];
+  await using _screen = await render(
+    <Probe composerRef={composerRef} onRender={(focus) => renders.push(focus)} />,
+  );
+  const { scheduleComposerFocus } = renders.at(-1)!;
+  const frames: FrameRequestCallback[] = [];
+  using _frames = vi.spyOn(window, "requestAnimationFrame").mockImplementation((frame) => {
+    frames.push(frame);
+    return frames.length;
+  });
+
+  scheduleComposerFocus();
+  expect(focusAtEnd).not.toHaveBeenCalled();
+  frames.shift()!(0);
+  expect(focusAtEnd).toHaveBeenCalledTimes(1);
+
+  scheduleComposerFocus();
+  const closeModelPicker = registerModelPickerContent();
+  frames.shift()!(0);
+  closeModelPicker();
+  expect(focusAtEnd).toHaveBeenCalledTimes(1);
+});