@@ -26,9 +26,7 @@ import {
   isPaintOnlyThreadTimeline,
   peekHeldThreadTimeline,
   peekRememberedThreadTimeline,
-  rememberReadyThreadTimeline,
   resolveThreadSwitchTimeline,
-  timelineHasEphemeralPreviewUrls,
   recallCheckoutIsRepo,
   rememberCheckoutIsRepo,
 } from "./ChatView.logic";
@@ -235,11 +233,11 @@ import {
   resolveThreadDetailRef,
   useEnvironmentSupportsServerBrowser,
   useProject,
-  useThreadProjection,
+  useQuietThreadProjection,
+  useQuietThreadVisibleTurnItems,
   useThreadStatus,
   useThreadHistory,
   useQuietThreadShell,
-  useThreadVisibleTurnItems,
   useThreadCheckpointSummaries,
 } from "../state/entities";
 import { useEnvironmentShellHasSnapshot } from "../state/shell";
@@ -254,7 +252,8 @@ import {
   RevertConfirmHost,
 } from "./chat/ChatOverlayHosts";
 import type { AssistantCitationRequest } from "./chat/AssistantCitationSource";
-import { MessagesTimeline, type MessagesTimelineHistoryControls } from "./chat/MessagesTimeline";
+import type { MessagesTimelineHistoryControls } from "./chat/MessagesTimeline";
+import { ThreadTimeline } from "./chat/ThreadTimeline";
 import { ProviderSubagentBar } from "./chat/ProviderSubagentBar";
 import { getTriggerDisplayModelName } from "./chat/providerIconUtils";
 import {
@@ -461,7 +460,7 @@ export default function ChatView(props: ChatViewProps) {
     shellExists: serverThreadShell !== null,
     waitForShell: draftThread !== null,
   });
-  const serverThreadProjection = useThreadProjection(routeThreadDetailRef);
+  const serverThreadProjection = useQuietThreadProjection(routeThreadDetailRef);
   const serverProjection = serverThreadProjection?.projection ?? null;
   const serverThread =
     serverThreadShell !== null || serverProjection === null
@@ -498,7 +497,7 @@ export default function ChatView(props: ChatViewProps) {
     serverProjection,
     activeProviderThread,
   );
-  const serverVisibleTurnItems = useThreadVisibleTurnItems(routeThreadDetailRef);
+  const serverVisibleTurnItems = useQuietThreadVisibleTurnItems(routeThreadDetailRef);
   const serverThreadHistory = useThreadHistory(routeThreadDetailRef);
   const threadHistoryControls = (() => {
     if (routeThreadDetailRef === null || !shouldShowLoadEarlierControl(serverThreadHistory)) {
@@ -784,7 +783,7 @@ export default function ChatView(props: ChatViewProps) {
           thread: serverProjection.thread,
           messages: serverProjection.messages,
         });
-  const workflowOpeningParentProjection = useThreadProjection(
+  const workflowOpeningParentProjection = useQuietThreadProjection(
     workflowOpeningParentId === null || parentSubagentEnvironmentId === null
       ? null
       : scopeThreadRef(parentSubagentEnvironmentId, workflowOpeningParentId),
@@ -1455,8 +1454,7 @@ export default function ChatView(props: ChatViewProps) {
           { ...codexFeedbackMessage(submission, "assistant"), runId: null },
         ],
   );
-  const serverTimelineEntries = useIncrementalTimelineEntries(activeThreadKey, {
-    visibleTurnItems: serverVisibleTurnItems,
+  const timelineEntriesInput = {
     optimisticMessages: optimisticUserMessages,
     anchoredMessages: anchoredTimelineMessages,
     attachmentUrlById: timelineAttachmentUrlById,
@@ -1467,6 +1465,12 @@ export default function ChatView(props: ChatViewProps) {
           nodes: serverProjection.nodes,
           plans: serverProjection.plans,
         }),
+  };
+  // Held through streamed text, like serverVisibleTurnItems; ThreadTimeline
+  // derives the rows it renders from the live turn items.
+  const serverTimelineEntries = useIncrementalTimelineEntries(activeThreadKey, {
+    ...timelineEntriesInput,
+    visibleTurnItems: serverVisibleTurnItems,
   });
   const draftTimelineEntries = optimisticUserMessages.map(
     (message) =>
@@ -1636,21 +1640,6 @@ export default function ChatView(props: ChatViewProps) {
   const activeProjectCwd = activeProject?.workspaceRoot ?? null;
   const activeThreadWorktreePath = activeThread?.worktreePath ?? null;
   const activeWorkspaceRoot = activeThreadWorktreePath ?? activeProjectCwd ?? undefined;
-  useLayoutEffect(() => {
-    if (
-      threadDetailLoading ||
-      timelineEntries.length === 0 ||
-      timelineHasEphemeralPreviewUrls(timelineEntries)
-    ) {
-      return;
-    }
-    rememberReadyThreadTimeline({
-      threadKey: activeThreadKey,
-      entries: timelineEntries,
-      markdownCwd: gitCwd,
-      workspaceRoot: activeWorkspaceRoot ?? null,
-    });
-  }, [activeThreadKey, activeWorkspaceRoot, gitCwd, threadDetailLoading, timelineEntries]);
   const heldPaintContext = paintOnlyDisplayedTimeline
     ? peekHeldThreadTimeline<typeof timelineEntries>()
     : null;
@@ -3213,7 +3202,6 @@ export default function ChatView(props: ChatViewProps) {
               thread: activeThreadRef,
               enabled:
                 isServerThread && serverConfig?.threadFind === true && !paintOnlyDisplayedTimeline,
-              content: serverProjection ?? undefined,
             }}
             controlsRef={threadFindControlsRef}
             onOpenChange={setIsThreadFindActive}
@@ -3244,7 +3232,15 @@ export default function ChatView(props: ChatViewProps) {
               setThreadErrorBannerDismissTick={setThreadErrorBannerDismissTick}
             />
             <div className="relative flex min-h-0 flex-1 flex-col bg-background">
-              <MessagesTimeline
+              <ThreadTimeline
+                threadDetailRef={routeThreadDetailRef}
+                entriesInput={timelineEntriesInput}
+                draftEntries={isServerThread ? null : draftTimelineEntries}
+                activeThreadKey={activeThreadKey}
+                syncing={threadSyncPhase !== null}
+                detailLoading={threadDetailLoading}
+                readyMarkdownCwd={gitCwd}
+                readyWorkspaceRoot={activeWorkspaceRoot ?? null}
                 citationRequest={paintOnlyDisplayedTimeline ? null : citationRequest}
                 citationHistoryLoading={threadDetailLoading}
                 {...(!paintOnlyDisplayedTimeline
@@ -3298,7 +3294,6 @@ export default function ChatView(props: ChatViewProps) {
                   )
                 }
                 listRef={legendListRef}
-                timelineEntries={displayedTimeline.entries}
                 runs={paintOnlyDisplayedTimeline ? [] : (serverProjection?.runs ?? [])}
                 latestRun={paintOnlyDisplayedTimeline ? null : activeActivityRun}
                 runningRunId={paintOnlyDisplayedTimeline ? null : activeRunningTurnId}
 
@@ -0,0 +1,65 @@
+import type { ScopedThreadRef } from "@t3tools/contracts";
+import { type ComponentProps, useLayoutEffect } from "react";
+import { useIncrementalTimelineEntries } from "../../hooks/useIncrementalTimelineEntries";
+import type { TimelineEntriesInput, TimelineEntry } from "../../session-logic";
+import { useThreadVisibleTurnItems } from "../../state/entities";
+import {
+  peekRememberedThreadTimeline,
+  rememberReadyThreadTimeline,
+  resolveThreadSwitchTimeline,
+  timelineHasEphemeralPreviewUrls,
+} from "../ChatView.logic";
+import { MessagesTimeline } from "./MessagesTimeline";
+
+/**
+ * The timeline with the streamed text. ChatView reads the thread through its quiet
+ * atoms, which hold through text deltas; this reads the live turn items, so a
+ * delta re-renders the timeline without re-rendering ChatView.
+ */
+export function ThreadTimeline({
+  threadDetailRef,
+  entriesInput,
+  draftEntries,
+  activeThreadKey,
+  syncing,
+  detailLoading,
+  readyMarkdownCwd,
+  readyWorkspaceRoot,
+  ...timelineProps
+}: Omit<ComponentProps<typeof MessagesTimeline>, "timelineEntries"> & {
+  /** Null until the thread's detail may load; see resolveThreadDetailRef. */
+  threadDetailRef: ScopedThreadRef | null;
+  entriesInput: Omit<TimelineEntriesInput, "visibleTurnItems">;
+  /** A local draft's optimistic rows; null for a server thread. */
+  draftEntries: ReadonlyArray<TimelineEntry> | null;
+  activeThreadKey: string | null;
+  syncing: boolean;
+  detailLoading: boolean;
+  readyMarkdownCwd: string | null;
+  readyWorkspaceRoot: string | null;
+}) {
+  const visibleTurnItems = useThreadVisibleTurnItems(threadDetailRef);
+  const serverEntries = useIncrementalTimelineEntries(activeThreadKey, {
+    ...entriesInput,
+    visibleTurnItems,
+  });
+  const entries = draftEntries ?? serverEntries;
+  const displayed = resolveThreadSwitchTimeline({
+    loading: entries.length === 0 && syncing,
+    activeThreadKey,
+    nextEntries: entries,
+    rememberedForActive: peekRememberedThreadTimeline<typeof entries>(activeThreadKey),
+  });
+  useLayoutEffect(() => {
+    if (detailLoading || entries.length === 0 || timelineHasEphemeralPreviewUrls(entries)) {
+      return;
+    }
+    rememberReadyThreadTimeline({
+      threadKey: activeThreadKey,
+      entries,
+      markdownCwd: readyMarkdownCwd,
+      workspaceRoot: readyWorkspaceRoot,
+    });
+  }, [activeThreadKey, detailLoading, entries, readyMarkdownCwd, readyWorkspaceRoot]);
+  return <MessagesTimeline {...timelineProps} timelineEntries={displayed.entries} />;
+}
@@ -1,13 +1,10 @@
 import type { InlineSkill } from "@t3tools/shared/inlineSkills";
-import type {
-  OrchestrationV2ThreadProjection,
-  OrchestrationV2SearchThreadResult,
-  ScopedThreadRef,
-} from "@t3tools/contracts";
+import type { OrchestrationV2SearchThreadResult, ScopedThreadRef } from "@t3tools/contracts";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
 import { useEffect, useLayoutEffect, useRef, useState, type RefObject } from "react";
 import { useStableCallback } from "~/hooks/useStableCallback";
 import { orchestrationEnvironment } from "~/state/orchestration";
+import { useThreadProjection } from "~/state/entities";
 import { useEnvironmentQuery } from "~/state/query";
 import { useDebouncedValue } from "~/state/queries";
 import {
@@ -42,14 +39,15 @@ export function useThreadFind({
   enabled,
   progressive = false,
   skills = EMPTY_SKILLS,
-  content,
 }: {
   thread: ScopedThreadRef | null;
   enabled: boolean;
   progressive?: boolean;
   skills?: readonly InlineSkill[];
-  content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined;
 }) {
+  // Read here rather than passed in: a streamed delta re-renders only the find
+  // provider, which refreshes open results from it.
+  const content = useThreadProjection(enabled ? thread : null)?.projection;
   // Held in state so the timeline props that carry it can be stored in state too.
   const [positionReader] = useState<RefObject<ThreadFindPositionReader | null>>(() => ({
     current: null,
 
@@ -156,6 +156,13 @@ export function useThreadProjection(ref: ScopedThreadRef | null): EnvironmentThr
   );
 }
 
+/** The thread's projection, held through streamed assistant and reasoning text; see quietThreadAtom. */
+export function useQuietThreadProjection(ref: ScopedThreadRef | null): EnvironmentThread | null {
+  return useAtomValue(
+    ref === null ? EMPTY_THREAD_PROJECTION_ATOM : environmentThreadDetails.quietThreadAtom(ref),
+  );
+}
+
 export function useThreadStatus(ref: ScopedThreadRef | null): EnvironmentThreadStatus {
   return useAtomValue(
     ref === null ? EMPTY_THREAD_STATUS_ATOM : environmentThreadDetails.statusAtom(ref),
@@ -188,6 +195,17 @@ export function useThreadVisibleTurnItems(
   );
 }
 
+/** Visible turn items, held through streamed text; see quietThreadAtom. */
+export function useQuietThreadVisibleTurnItems(
+  ref: ScopedThreadRef | null,
+): ReadonlyArray<OrchestrationV2ProjectedTurnItem> {
+  return useAtomValue(
+    ref === null
+      ? EMPTY_VISIBLE_TURN_ITEMS_ATOM
+      : environmentThreadDetails.quietVisibleTurnItemsAtom(ref),
+  );
+}
+
 export function useThreadCheckpointSummaries(
   ref: ScopedThreadRef | null,
 ): ReadonlyArray<ThreadCheckpointSummary> {
 
@@ -0,0 +1,74 @@
+import { MessageId, RunId, TurnItemId, type OrchestrationV2TurnItem } from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+import * as DateTime from "effect/DateTime";
+
+import { v2Now, v2Projection, v2ThreadId } from "./orchestrationV2TestFixtures.ts";
+import { onlyStreamedTextChanged } from "./threadDetail.ts";
+
+const later = DateTime.makeUnsafe("2026-06-20T00:00:01.000Z");
+
+const assistant: OrchestrationV2TurnItem = {
+  id: TurnItemId.make("item-assistant"),
+  threadId: v2ThreadId,
+  runId: RunId.make("run-1"),
+  nodeId: null,
+  providerThreadId: null,
+  providerTurnId: null,
+  nativeItemRef: null,
+  parentItemId: null,
+  ordinal: 1,
+  status: "running",
+  title: null,
+  startedAt: v2Now,
+  completedAt: null,
+  updatedAt: v2Now,
+  type: "assistant_message",
+  messageId: MessageId.make("message-assistant"),
+  text: "Hel",
+  streaming: true,
+};
+
+function withItem(item: OrchestrationV2TurnItem, updatedAt = v2Now) {
+  return {
+    ...v2Projection,
+    turnItems: [item],
+    visibleTurnItems: [
+      {
+        position: 0,
+        visibility: "local" as const,
+        sourceThreadId: v2ThreadId,
+        sourceItemId: item.id,
+        item,
+      },
+    ],
+    updatedAt,
+  };
+}
+
+describe("onlyStreamedTextChanged", () => {
+  const before = withItem(assistant);
+
+  it("holds through streamed text", () => {
+    const next = withItem({ ...assistant, text: "Hello", updatedAt: later }, later);
+    expect(onlyStreamedTextChanged(before, next)).toBe(true);
+  });
+
+  it("sees the item finish streaming", () => {
+    const next = withItem({ ...assistant, text: "Hello", streaming: false, status: "completed" });
+    expect(onlyStreamedTextChanged(before, next)).toBe(false);
+  });
+
+  it("sees a new item", () => {
+    const next = { ...before, turnItems: [assistant, { ...assistant, id: TurnItemId.make("b") }] };
+    expect(onlyStreamedTextChanged(before, next)).toBe(false);
+  });
+
+  it("sees other fields change on a streaming item", () => {
+    const next = withItem({ ...assistant, text: "Hello", title: "Answer" });
+    expect(onlyStreamedTextChanged(before, next)).toBe(false);
+  });
+
+  it("sees changes outside the turn items", () => {
+    expect(onlyStreamedTextChanged(before, { ...before, runs: [] })).toBe(false);
+  });
+});