diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml
index 01b6e377a..30f08431a 100644
--- a/.github/workflows/pr-build.yml
+++ b/.github/workflows/pr-build.yml
@@ -236,7 +236,7 @@ jobs:
 
       - name: Test changed runnable UI behavior
         run: >-
-          node --import tsx --test
+          node --import tsx --test --test-force-exit
           packages/ui/src/components/browser-frame-security.test.ts
           packages/ui/src/components/message-history-pagination.test.ts
           packages/ui/src/components/message-timeline-v2.test.ts
@@ -246,6 +246,8 @@ jobs:
           packages/ui/src/components/session/session-bottom-pin-intent.test.ts
           packages/ui/src/components/session/session-idle-attention.test.ts
           packages/ui/src/components/session-list-visibility.test.ts
+          packages/ui/src/components/tool-call/permission-block.test.ts
+          packages/ui/src/components/tool-call/render-memory.test.ts
           packages/ui/src/components/settings/info-settings-diagnostics.test.ts
           packages/ui/src/components/tool-call/tool-presentation.test.ts
           packages/ui/src/components/transcript-visibility.test.ts
@@ -255,6 +257,7 @@ jobs:
           packages/ui/src/components/virtual-reader-settlement.test.ts
           packages/ui/src/lib/client-identity.test.ts
           packages/ui/src/lib/filesystem-events.test.ts
+          packages/ui/src/lib/global-cache.test.ts
           packages/ui/src/lib/hooks/use-app-session-capture.test.ts
           packages/ui/src/lib/hooks/use-instance-metadata.test.ts
           packages/ui/src/lib/hooks/use-foreground-refresh.test.ts
@@ -263,9 +266,11 @@ jobs:
           packages/ui/src/lib/clipboard.test.ts
           packages/ui/src/lib/message-selection-position.test.ts
           packages/ui/src/lib/model-visibility.test.ts
+          packages/ui/src/lib/retained-size.test.ts
           packages/ui/src/lib/provider-auth.test.ts
           packages/ui/src/lib/native/browser.test.ts
           packages/ui/src/lib/runtime-env.test.ts
+          packages/ui/src/lib/session-transcript-lru.test.ts
           packages/ui/src/lib/server-meta.test.ts
           packages/ui/src/lib/theme-scheme.test.ts
           packages/ui/src/lib/trailing-resync.test.ts
@@ -305,6 +310,10 @@ jobs:
           node --conditions=browser --import tsx --test --test-force-exit
           packages/ui/src/components/form-request-tool-target.test.ts
           packages/ui/src/components/form-request.test.ts
+          packages/ui/src/components/instance/shell/useSessionCache.test.ts
+          packages/ui/src/components/permission-diff-review.test.ts
+          packages/ui/src/components/tool-call/renderers/task-copy.test.ts
+          packages/ui/src/components/tool-call/renderer-copy.test.ts
           packages/ui/src/components/tool-call/diff-payload.test.ts
           packages/ui/src/components/tool-call/renderers/edit.test.ts
           packages/ui/src/components/tool-call/renderers/task-title.test.ts
@@ -319,7 +328,10 @@ jobs:
           packages/ui/src/stores/app-tabs.test.ts
           packages/ui/src/stores/forms.test.ts
           packages/ui/src/stores/instances-restore-ownership.test.ts
+          packages/ui/src/stores/message-v2/bus.test.ts
+          packages/ui/src/stores/message-v2/transcript-eviction.test.ts
           packages/ui/src/stores/opencode-data.test.ts
+          packages/ui/src/stores/opencode-data-idle.test.ts
           packages/ui/src/stores/opencode-data-settlement.test.ts
           packages/ui/src/stores/message-v2/empty-content.test.ts
           packages/ui/src/stores/permission-lifecycle.test.ts
diff --git a/packages/ui/src/components/instance/instance-shell2.tsx b/packages/ui/src/components/instance/instance-shell2.tsx
index 1d836b0e5..71dc45c18 100644
--- a/packages/ui/src/components/instance/instance-shell2.tsx
+++ b/packages/ui/src/components/instance/instance-shell2.tsx
@@ -681,6 +681,7 @@ const InstanceShell2: Component<InstanceShellProps> = (props) => {
     instanceId: () => props.instance.id,
     instanceSessions: allInstanceSessions,
     activeSessionId: activeSessionIdForInstance,
+    isActiveInstance: () => Boolean(props.isActiveInstance),
   })
 
   const showEmbeddedSidebarToggle = createMemo(() => !leftPinned() && !leftOpen())
diff --git a/packages/ui/src/components/instance/shell/useSessionCache.test.ts b/packages/ui/src/components/instance/shell/useSessionCache.test.ts
new file mode 100644
index 000000000..e023aa107
--- /dev/null
+++ b/packages/ui/src/components/instance/shell/useSessionCache.test.ts
@@ -0,0 +1,41 @@
+import assert from "node:assert/strict"
+import { it } from "node:test"
+import { createRoot, createSignal } from "solid-js"
+import { useSessionCache } from "./useSessionCache.ts"
+import { messageStoreBus } from "../../../stores/message-v2/bus.ts"
+import { sessions, setSessions, loading, setLoading } from "../../../stores/session-state.ts"
+import { SESSION_TRANSCRIPT_BYTE_BUDGET } from "../../../stores/session-transcript-memory.ts"
+
+it("keeps a visible over-budget transcript pinned across catalogue and loading changes, then releases it on hide", async () => {
+  const instanceId = "cache-visible-lifetime", sessionId = "selected"
+  const previousSessions = sessions(), previousLoading = loading()
+  const session = { id: sessionId, instanceId, title: "Selected", parentId: null, status: "idle" } as any
+  setSessions(prev => new Map(prev).set(instanceId, new Map([[sessionId, session]])))
+  const store = messageStoreBus.getOrCreate(instanceId)
+  // Exercise the real queue/coordinator without allocating a large payload.
+  store.estimateSessionRetainedBytes = async () => SESSION_TRANSCRIPT_BYTE_BUDGET + 1
+  store.upsertMessage({ id: "message", sessionId, role: "assistant", status: "complete" })
+  const [active, setActive] = createSignal(true)
+  let dispose = () => {}
+  try {
+    createRoot(done => {
+      dispose = done
+      useSessionCache({ instanceId: () => instanceId, activeSessionId: () => sessionId,
+        isActiveInstance: active, instanceSessions: () => sessions().get(instanceId)! })
+    })
+    await new Promise(resolve => setTimeout(resolve, 250))
+    assert.deepEqual(store.getSessionMessageIds(sessionId), ["message"])
+    setSessions(prev => new Map(prev).set(instanceId, new Map([[sessionId, { ...session, title: "Renamed" }]])))
+    assert.deepEqual(store.getSessionMessageIds(sessionId), ["message"])
+    setLoading(prev => ({ ...prev, loadingMessages: new Map(prev.loadingMessages).set(instanceId, new Set(["other"])) }))
+    assert.deepEqual(store.getSessionMessageIds(sessionId), ["message"])
+    setActive(false)
+    assert.equal(store.getMessage("message"), undefined)
+    assert.deepEqual(store.getSessionMessageIds(sessionId), [])
+  } finally {
+    dispose()
+    messageStoreBus.unregisterInstance(instanceId)
+    setSessions(previousSessions)
+    setLoading(previousLoading)
+  }
+})
diff --git a/packages/ui/src/components/instance/shell/useSessionCache.ts b/packages/ui/src/components/instance/shell/useSessionCache.ts
index 35ffe5c78..f68740d0e 100644
--- a/packages/ui/src/components/instance/shell/useSessionCache.ts
+++ b/packages/ui/src/components/instance/shell/useSessionCache.ts
@@ -1,17 +1,14 @@
-import { createEffect, createSignal, type Accessor } from "solid-js"
-import { messageStoreBus } from "../../../stores/message-v2/bus"
-import { clearSessionRenderCache } from "../../message-block"
-import { getLogger } from "../../../lib/logger"
-import { invalidateSessionMessageLoad } from "../../../stores/session-state"
-
-const log = getLogger("session")
-
-const SESSION_CACHE_LIMIT = 5
+import { createEffect, createMemo, on, onCleanup, type Accessor } from "solid-js"
+import {
+  reconcileSessionTranscriptBudget,
+  setSessionTranscriptVisible,
+} from "../../../stores/session-transcript-memory"
 
 type SessionCacheOptions = {
   instanceId: Accessor<string>
   instanceSessions: Accessor<Map<string, unknown>>
   activeSessionId: Accessor<string | null>
+  isActiveInstance: Accessor<boolean>
 }
 
 type SessionCacheState = {
@@ -19,80 +16,27 @@ type SessionCacheState = {
 }
 
 export function useSessionCache(options: SessionCacheOptions): SessionCacheState {
-  const [cachedSessionIds, setCachedSessionIds] = createSignal<string[]>([])
-  const [pendingEvictions, setPendingEvictions] = createSignal<string[]>([])
-
-  const evictSession = (sessionId: string) => {
-    if (!sessionId) return
-    const instanceId = options.instanceId()
-    log.info("Evicting cached session", { instanceId, sessionId })
-    const store = messageStoreBus.getInstance(instanceId)
-    invalidateSessionMessageLoad(instanceId, sessionId)
-    store?.clearSession(sessionId, { preserveScroll: true, notify: false })
-    clearSessionRenderCache(instanceId, sessionId)
-  }
-
-  const scheduleEvictions = (ids: string[]) => {
-    if (!ids.length) return
-    setPendingEvictions((current) => {
-      const existing = new Set(current)
-      const next = [...current]
-      ids.forEach((id) => {
-        if (!existing.has(id)) {
-          next.push(id)
-          existing.add(id)
-        }
-      })
-      return next
-    })
-  }
-
-  createEffect(() => {
-    const pending = pendingEvictions()
-    if (!pending.length) return
-    const cached = new Set(cachedSessionIds())
-    const remaining: string[] = []
-    pending.forEach((id) => {
-      if (cached.has(id)) {
-        remaining.push(id)
-      } else {
-        evictSession(id)
-      }
-    })
-    if (remaining.length !== pending.length) {
-      setPendingEvictions(remaining)
-    }
-  })
-
-  createEffect(() => {
+  const visibleSessionId = createMemo(() => {
     const instanceSessions = options.instanceSessions()
     const activeId = options.activeSessionId()
+    if (!options.isActiveInstance() || !activeId || activeId === "info" || !instanceSessions.has(activeId)) return null
+    return activeId
+  })
+  const cachedSessionIds = createMemo(() => {
+    const sessionId = visibleSessionId()
+    return sessionId ? [sessionId] : []
+  })
 
-    setCachedSessionIds((current) => {
-      const next = current.filter((id) => id !== "info" && instanceSessions.has(id))
-
-      const touch = (id: string | null) => {
-        if (!id || id === "info") return
-        if (!instanceSessions.has(id)) return
-
-        const index = next.indexOf(id)
-        if (index !== -1) {
-          next.splice(index, 1)
-        }
-        next.unshift(id)
-      }
-
-      touch(activeId)
-
-      const trimmed = next.length > SESSION_CACHE_LIMIT ? next.slice(0, SESSION_CACHE_LIMIT) : next
+  // Enforcement reads session/loading state. Those reads must not become
+  // visibility dependencies and briefly unpin an unchanged visible identity.
+  createEffect(on([options.instanceId, visibleSessionId], ([instanceId, sessionId]) => {
+    if (!sessionId) return
+    setSessionTranscriptVisible(instanceId, sessionId, true)
+    onCleanup(() => setSessionTranscriptVisible(instanceId, sessionId, false))
+  }))
 
-      const trimmedSet = new Set(trimmed)
-      const removed = current.filter((id) => !trimmedSet.has(id))
-      if (removed.length) {
-        scheduleEvictions(removed)
-      }
-      return trimmed
-    })
+  onCleanup(() => {
+    reconcileSessionTranscriptBudget()
   })
 
   return {
diff --git a/packages/ui/src/components/markdown.tsx b/packages/ui/src/components/markdown.tsx
index 91d40793d..ca2af1514 100644
--- a/packages/ui/src/components/markdown.tsx
+++ b/packages/ui/src/components/markdown.tsx
@@ -1,9 +1,10 @@
-import { createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
+import { Show, createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
 import { useGlobalCache } from "../lib/hooks/use-global-cache"
 import type { TextPart, RenderCache } from "../types/message"
 import { getLogger } from "../lib/logger"
 import { copyToClipboard } from "../lib/clipboard"
 import { useI18n } from "../lib/i18n"
+import { limitToolOutputForRender, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT } from "./tool-call/utils"
 
 const log = getLogger("session")
 
@@ -89,6 +90,10 @@ function renderFallbackHtml(content: string): string {
   return escapeHtml(content).replace(/\n/g, "<br />")
 }
 
+export function getMarkdownTextForRender(content: string): string {
+  return limitToolOutputForRender(content)
+}
+
 interface MarkdownProps {
   part: TextPart
   instanceId?: string
@@ -158,7 +163,7 @@ export function Markdown(props: MarkdownProps) {
   const resolved = createMemo(() => {
     const part = props.part
     const rawText = typeof part.text === "string" ? part.text : ""
-    const text = decodeHtmlEntitiesLocally(rawText)
+    const text = decodeHtmlEntitiesLocally(getMarkdownTextForRender(rawText))
     const themeKey = Boolean(props.isDark) ? "dark" : "light"
     const highlightEnabled = !props.disableHighlight
     const escapeRawHtml = Boolean(props.escapeRawHtml)
@@ -346,15 +351,31 @@ export function Markdown(props: MarkdownProps) {
   })
 
   return (
-    <div
-      ref={containerRef}
-      class="markdown-body"
-      dir="auto"
-      data-view="markdown"
-      data-part-id={resolved().partId}
-      data-markdown-theme={resolved().themeKey}
-      data-markdown-highlight={resolved().highlightEnabled ? "true" : "false"}
-      innerHTML={html()}
-    />
+    <>
+      <div
+        ref={containerRef}
+        class="markdown-body"
+        dir="auto"
+        data-view="markdown"
+        data-part-id={resolved().partId}
+        data-markdown-theme={resolved().themeKey}
+        data-markdown-highlight={resolved().highlightEnabled ? "true" : "false"}
+        innerHTML={html()}
+      />
+      <Show when={(typeof props.part.text === "string" ? props.part.text.length : 0) > TOOL_OUTPUT_RENDER_CHARACTER_LIMIT}>
+        <button
+          type="button"
+          class="message-action-button markdown-source-copy"
+          onClick={() => void copyToClipboard(typeof props.part.text === "string" ? props.part.text : "")}
+          aria-label={t("messageItem.actions.copyTitle")}
+          title={t("messageItem.actions.copyTitle")}
+        >
+          <svg class="w-3.5 h-3.5" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
+            <rect x="9" y="9" width="13" height="13" />
+            <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
+          </svg>
+        </button>
+      </Show>
+    </>
   )
 }
diff --git a/packages/ui/src/components/message-block.tsx b/packages/ui/src/components/message-block.tsx
index 2fd9b018c..9110d532c 100644
--- a/packages/ui/src/components/message-block.tsx
+++ b/packages/ui/src/components/message-block.tsx
@@ -22,6 +22,15 @@ import { copyToClipboard } from "../lib/clipboard"
 import SpeechActionButton from "./speech-action-button"
 import type { VisibilityPreference } from "../stores/preferences"
 import type { ToolState, ToolStateCompleted, ToolStateError, ToolStateRunning } from "../types/tool-state"
+import {
+  clearInstanceMessageRenderCaches,
+  clearSessionMessageRenderCache,
+  getSessionMessageRenderCache,
+  peekSessionMessageRenderCache,
+  purgeMessageRenderCache,
+  extractReasoningTextForCopy,
+} from "../lib/message-render-cache"
+import { accountSessionTranscript } from "../stores/session-transcript-memory"
 import { parseReasoningSummary } from "../lib/reasoning-summary"
 import { getFormQueue } from "../stores/forms"
 import { backgroundSession, deleteMessagePart, deleteTechnicalPartGroup } from "../stores/session-actions"
@@ -127,47 +136,27 @@ interface CachedBlockEntry {
   toolKeys: string[]
 }
 
-interface SessionRenderCache {
-  messageItems: Map<string, ContentDisplayItem>
-  toolItems: Map<string, ToolDisplayItem>
-  messageBlocks: Map<string, CachedBlockEntry>
-}
-
-const renderCaches = new Map<string, SessionRenderCache>()
-
-function makeSessionCacheKey(instanceId: string, sessionId: string) {
-  return `${instanceId}:${sessionId}`
-}
-
 export function clearSessionRenderCache(instanceId: string, sessionId: string) {
-  renderCaches.delete(makeSessionCacheKey(instanceId, sessionId))
+  clearSessionMessageRenderCache(instanceId, sessionId)
 }
 
-function getSessionRenderCache(instanceId: string, sessionId: string): SessionRenderCache {
-  const key = makeSessionCacheKey(instanceId, sessionId)
-  let cache = renderCaches.get(key)
-  if (!cache) {
-    cache = {
-      messageItems: new Map(),
-      toolItems: new Map(),
-      messageBlocks: new Map(),
-    }
-    renderCaches.set(key, cache)
+function clearMessageRenderCache(instanceId: string, sessionId: string, messageIds: readonly string[]) {
+  const cache = peekSessionMessageRenderCache(instanceId, sessionId)
+  if (!cache) return
+  purgeMessageRenderCache(cache, messageIds)
+  if (cache.messageBlocks.size === 0 && cache.messageItems.size === 0 && cache.toolItems.size === 0) {
+    clearSessionMessageRenderCache(instanceId, sessionId)
   }
-  return cache
 }
 
 function clearInstanceCaches(instanceId: string) {
   clearRecordDisplayCacheForInstance(instanceId)
-  const prefix = `${instanceId}:`
-  for (const key of renderCaches.keys()) {
-    if (key.startsWith(prefix)) {
-      renderCaches.delete(key)
-    }
-  }
+  clearInstanceMessageRenderCaches(instanceId)
 }
 
 messageStoreBus.onInstanceDestroyed(clearInstanceCaches)
+messageStoreBus.onSessionCleared(clearSessionRenderCache)
+messageStoreBus.onMessagesRemoved(clearMessageRenderCache)
 
 function removeSearchMarks(root: HTMLElement) {
   const marks = Array.from(root.querySelectorAll("mark.session-search-match"))
@@ -251,6 +240,7 @@ interface ContentDisplayItem {
   key: string
   messageId: string
   startPartId: string
+  partIds: string[]
 }
 
 interface ToolDisplayItem {
@@ -266,6 +256,7 @@ interface MessageContentItemProps {
   store: () => InstanceMessageStore
   messageId: string
   startPartId: string
+  partIds: string[]
   messageIndex: number
   onRevert?: (messageId: string) => void
   onFork?: (messageId?: string) => void
@@ -302,18 +293,12 @@ function MessageContentItem(props: MessageContentItemProps) {
   const parts = createMemo<ClientPart[]>(() => {
     const current = record()
     if (!current) return []
-    const ids = current.partIds
-    const startIndex = ids.indexOf(props.startPartId)
-    if (startIndex === -1) return []
-
     const resolved: ClientPart[] = []
-    for (let idx = startIndex; idx < ids.length; idx++) {
-      const partId = ids[idx]
+    for (const partId of props.partIds) {
       const part = current.parts[partId]?.data
       if (!part) continue
       if (!isSupportedPartType(part)) continue
-
-      if (!isContentPartType((part as any).type)) break
+      if (!isContentPartType((part as any).type)) continue
       resolved.push(part)
     }
 
@@ -391,6 +376,7 @@ function MessageContentItem(props: MessageContentItemProps) {
 interface ToolCallItemProps {
   instanceId: string
   sessionId: string
+  isActive?: Accessor<boolean>
   store: () => InstanceMessageStore
   messageId: string
   partId: string
@@ -491,6 +477,7 @@ function ToolCallItem(props: ToolCallItemProps) {
             partVersion={partVersion()}
             instanceId={props.instanceId}
             sessionId={props.sessionId}
+            isActive={props.isActive}
             onContentRendered={props.onContentRendered}
             headerAction={isBackgroundableTool(toolPart()) ? (
               <button
@@ -563,14 +550,17 @@ type SystemDisplayItem = { type: "system"; key: string; part: Extract<ClientPart
 type MessageBlockItem = ContentDisplayItem | ToolDisplayItem | ExplorationDisplayItem | StepDisplayItem | ReasoningDisplayItem | CompactionDisplayItem | SystemDisplayItem
 
 interface MessageDisplayBlock {
-  record: MessageRecord
+  messageId: string
+  status: MessageRecord["status"]
   items: MessageBlockItem[]
+  truncated: boolean
 }
 
 interface MessageBlockProps {
   messageId: string
   instanceId: string
   sessionId: string
+  isActive?: Accessor<boolean>
   store: () => InstanceMessageStore
   messageIndex: number
   showThinking: () => boolean
@@ -603,7 +593,11 @@ export default function MessageBlock(props: MessageBlockProps) {
   const { t } = useI18n()
   const record = createMemo(() => props.store().getMessage(props.messageId))
   const messageInfo = createMemo(() => props.store().getMessageInfo(props.messageId))
-  const sessionCache = getSessionRenderCache(props.instanceId, props.sessionId)
+  const sessionCache = getSessionMessageRenderCache(props.instanceId, props.sessionId) as {
+    messageItems: Map<string, ContentDisplayItem>
+    toolItems: Map<string, ToolDisplayItem>
+    messageBlocks: Map<string, CachedBlockEntry>
+  }
   const [blockRef, setBlockRef] = createSignal<HTMLDivElement>()
   const [systemDisclosureRevision, setSystemDisclosureRevision] = createSignal(0)
   const isSearchResult = () => Boolean(props.searchResultMessageIds?.().has(props.messageId))
@@ -618,6 +612,12 @@ export default function MessageBlock(props: MessageBlockProps) {
   const pendingFormToolTargets = () => props.pendingFormToolTargets?.() ?? localPendingFormToolTargets()
   const technicalCleanupPartKeys = () => props.technicalCleanupPartKeys?.() ?? new Set<string>()
   let lastInlineScrolledSearchMatchId: string | null = null
+  const handleContentRendered = () => {
+    props.onContentRendered?.()
+    accountSessionTranscript(props.instanceId, props.sessionId)
+  }
+
+  onCleanup(() => accountSessionTranscript(props.instanceId, props.sessionId))
 
   createEffect(() => {
     const query = props.searchQuery?.() ?? ""
@@ -690,12 +690,16 @@ export default function MessageBlock(props: MessageBlockProps) {
 
       const segmentKey = `${current.id}:content:${startPartId}`
       let cached = sessionCache.messageItems.get(segmentKey)
-      if (!cached) {
+      const partIds = pendingParts.flatMap((part) => typeof part.id === "string" ? [part.id] : [])
+      // Index rows observe item identity, not mutations to this plain cached
+      // object. Publish changed selections so appended/tail parts reach the row.
+      if (!cached || cached.partIds.length !== partIds.length || cached.partIds.some((id, index) => id !== partIds[index])) {
         cached = {
           type: "content",
           key: segmentKey,
           messageId: current.id,
           startPartId,
+          partIds,
         }
         sessionCache.messageItems.set(segmentKey, cached)
       }
@@ -845,7 +849,7 @@ export default function MessageBlock(props: MessageBlockProps) {
 
     flushContent()
 
-    const resultBlock: MessageDisplayBlock = { record: current, items }
+    const resultBlock: MessageDisplayBlock = { messageId: current.id, status: current.status, items, truncated: displayData.truncated }
     sessionCache.messageBlocks.set(current.id, {
       signature: cacheSignature,
       displayData,
@@ -853,6 +857,7 @@ export default function MessageBlock(props: MessageBlockProps) {
       contentKeys: blockContentKeys.slice(),
       toolKeys: blockToolKeys.slice(),
     })
+    accountSessionTranscript(props.instanceId, props.sessionId)
 
     const messagePrefix = `${current.id}:`
     for (const [key] of sessionCache.messageItems) {
@@ -907,19 +912,21 @@ export default function MessageBlock(props: MessageBlockProps) {
     .filter(isDisplayItemVisible)
     .map((item) => item.key)))
   return (
-    <Show when={visibleItemKeys().size > 0}>
-      <div
-        ref={(element) => {
-          setBlockRef(element)
-          onCleanup(() => setBlockRef(undefined))
-        }}
-        class="message-stream-block"
-        data-message-id={block()!.record.id}
-        data-search-result={isSearchResult() ? "true" : undefined}
-        data-search-active={isActiveSearchResult() ? "true" : undefined}
-      >
-        <Index each={block()!.items}>
-          {(item, index) => (
+    <Show when={block()}>
+      {(resolvedBlock) => (
+        <Show when={resolvedBlock().truncated || resolvedBlock().items.some(isDisplayItemVisible)}>
+          <div
+            ref={(element) => {
+              setBlockRef(element)
+              onCleanup(() => setBlockRef(undefined))
+            }}
+            class="message-stream-block"
+            data-message-id={resolvedBlock().messageId}
+            data-search-result={isSearchResult() ? "true" : undefined}
+            data-search-active={isActiveSearchResult() ? "true" : undefined}
+          >
+            <Index each={resolvedBlock().items}>
+              {(item) => (
               <Switch>
                 <Match when={item().type === "content"}>
                   <MessageContentItem
@@ -928,6 +935,7 @@ export default function MessageBlock(props: MessageBlockProps) {
                     store={props.store}
                     messageId={(item() as ContentDisplayItem).messageId}
                     startPartId={(item() as ContentDisplayItem).startPartId}
+                    partIds={(item() as ContentDisplayItem).partIds}
                     messageIndex={props.messageIndex}
                     onRevert={props.onRevert}
                     onFork={props.onFork}
@@ -945,7 +953,7 @@ export default function MessageBlock(props: MessageBlockProps) {
                       (item() as ContentDisplayItem).startPartId,
                       hovered,
                     )}
-                    onContentRendered={props.onContentRendered}
+                    onContentRendered={handleContentRendered}
                   />
                 </Match>
                 <Match when={item().type === "tool"}>
@@ -959,10 +967,11 @@ export default function MessageBlock(props: MessageBlockProps) {
                       <ToolCallItem
                         instanceId={props.instanceId}
                         sessionId={props.sessionId}
+                        isActive={props.isActive}
                         store={props.store}
                         messageId={(item() as ToolDisplayItem).messageId}
                         partId={(item() as ToolDisplayItem).partId}
-                        onContentRendered={props.onContentRendered}
+                        onContentRendered={handleContentRendered}
                       />
                     </div>
                   </Show>
@@ -978,6 +987,7 @@ export default function MessageBlock(props: MessageBlockProps) {
                       completed={(item() as ExplorationDisplayItem).completed}
                       instanceId={props.instanceId}
                       sessionId={props.sessionId}
+                      isActive={props.isActive}
                       store={props.store}
                       pendingFormToolTargets={pendingFormToolTargets()}
                       activePartId={activeSearchMatch()?.partId}
@@ -989,7 +999,7 @@ export default function MessageBlock(props: MessageBlockProps) {
                         ? (expanded) => props.setTechnicalGroupExpanded?.((item() as ExplorationDisplayItem).technicalGroup!.id, expanded)
                         : undefined}
                       technicalCleanupPartKeys={technicalCleanupPartKeys}
-                      onContentRendered={props.onContentRendered}
+                      onContentRendered={handleContentRendered}
                     />
                   </Show>
                 </Match>
@@ -1014,7 +1024,7 @@ export default function MessageBlock(props: MessageBlockProps) {
                     instanceId={props.instanceId}
                     sessionId={props.sessionId}
                     messageId={props.messageId}
-                    onContentRendered={props.onContentRendered}
+                    onContentRendered={handleContentRendered}
                   />
                 </Match>
                 <Match when={item().type === "system"}>
@@ -1026,12 +1036,12 @@ export default function MessageBlock(props: MessageBlockProps) {
                   <CompactionCard
                     part={(item() as CompactionDisplayItem).part}
                     messageInfo={(item() as CompactionDisplayItem).messageInfo}
-                    status={block()!.record.status}
+                    status={resolvedBlock().status}
                     borderColor={(item() as CompactionDisplayItem).accentColor}
                     instanceId={props.instanceId}
                     sessionId={props.sessionId}
                     messageId={(item() as CompactionDisplayItem).messageId}
-                    onContentRendered={props.onContentRendered}
+                    onContentRendered={handleContentRendered}
                   />
                 </Match>
                 <Match when={item().type === "reasoning"}>
@@ -1043,10 +1053,10 @@ export default function MessageBlock(props: MessageBlockProps) {
                     completed={(item() as ReasoningDisplayItem).completed}
                     instanceId={props.instanceId}
                     sessionId={props.sessionId}
-                    status={block()!.record.status}
+                    status={resolvedBlock().status}
                     showAgentMeta={(item() as ReasoningDisplayItem).showAgentMeta}
                     defaultExpanded={(item() as ReasoningDisplayItem).defaultExpanded}
-                    onContentRendered={props.onContentRendered}
+                    onContentRendered={handleContentRendered}
                     activePartId={activeSearchMatch()?.partId}
                     showHeader={technicalGroupStartsHere((item() as ReasoningDisplayItem).technicalGroup)}
                     expanded={(item() as ReasoningDisplayItem).technicalGroup
@@ -1062,9 +1072,28 @@ export default function MessageBlock(props: MessageBlockProps) {
                   />
                 </Match>
               </Switch>
-          )}
-        </Index>
-      </div>
+              )}
+            </Index>
+            <Show when={resolvedBlock().truncated}>
+              <div class="tool-call-diagnostic-message" role="status">
+                <span>{t("toolCall.output.truncated")}</span>
+                <button
+                  type="button"
+                  class="tool-call-header-icon-button tool-call-io-copy"
+                  onClick={() => {
+                    const current = props.store().getMessage(resolvedBlock().messageId)
+                    if (current) void copyToClipboard(JSON.stringify(orderedMessageParts(current), null, 2))
+                  }}
+                  aria-label={t("toolCall.io.copyOutputAriaLabel")}
+                  title={t("toolCall.io.copyOutputTitle")}
+                >
+                  <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+                </button>
+              </div>
+            </Show>
+          </div>
+        </Show>
+      )}
     </Show>
   )
 }
@@ -1076,6 +1105,7 @@ interface ExplorationGroupProps {
   completed: boolean
   instanceId: string
   sessionId: string
+  isActive?: Accessor<boolean>
   store: () => InstanceMessageStore
   pendingFormToolTargets: ReadonlySet<string>
   activePartId?: string
@@ -1177,6 +1207,7 @@ function ExplorationGroup(props: ExplorationGroupProps) {
       <ToolCallItem
         instanceId={props.instanceId}
         sessionId={props.sessionId}
+        isActive={props.isActive}
         store={props.store}
         messageId={item.messageId}
         partId={item.partId}
@@ -1264,6 +1295,13 @@ function ExplorationGroup(props: ExplorationGroupProps) {
   )
 }
 
+function orderedMessageParts(record: MessageRecord): ClientPart[] {
+  return record.partIds.flatMap((partId) => {
+    const part = record.parts[partId]?.data
+    return part ? [part] : []
+  })
+}
+
 interface StepCardProps {
   kind: "start" | "finish"
   part: ClientPart
@@ -1596,6 +1634,9 @@ function ReasoningGroupCard(props: {
   const renderCard = (item: ReasoningDisplayPart) => (
     <ReasoningCard
       part={item.part}
+      copyText={() => extractReasoningTextForCopy(
+        messageStoreBus.getOrCreate(props.instanceId).getMessage(item.messageId)?.parts[item.partId]?.data,
+      )}
       messageInfo={item.messageInfo}
       durationMs={item.durationMs}
       instanceId={props.instanceId}
@@ -1666,6 +1707,7 @@ function ReasoningGroupCard(props: {
 
 interface ReasoningCardProps {
   part: ClientPart
+  copyText: () => string
   messageInfo?: MessageInfo
   durationMs?: number
   instanceId: string
@@ -1801,14 +1843,14 @@ function ReasoningCard(props: ReasoningCardProps) {
   }
 
   const speech = useSpeech({
-    id: () => `${props.instanceId}:${props.sessionId}:${props.messageId}:${(props.part as any)?.id ?? "reasoning"}`,
+    id: () => `${props.instanceId}:${props.sessionId}:${props.messageId}:${props.part.id || "reasoning"}`,
     text: reasoningText,
   })
 
   const canSpeakReasoning = () => reasoningText().trim().length > 0 && speech.canUseSpeech()
 
   const handleCopyReasoning = async () => {
-    const text = reasoningText()
+    const text = props.copyText()
     if (!text.trim()) return
     await copyToClipboard(text)
   }
diff --git a/packages/ui/src/components/message-history-pagination.test.ts b/packages/ui/src/components/message-history-pagination.test.ts
index 1624a0a49..75c8a7303 100644
--- a/packages/ui/src/components/message-history-pagination.test.ts
+++ b/packages/ui/src/components/message-history-pagination.test.ts
@@ -325,7 +325,7 @@ describe("message history pagination", () => {
 
       assert.deepEqual(locatorCalls, ["middle", "middle"])
       const source = fs.readFileSync(new URL("./message-section.tsx", import.meta.url), "utf8")
-      assert.match(source, /batch\(\(\) => \{\s*setSearchMatches\(page\.hits\.map[\s\S]*?setActiveSearchIndex\(0\)[\s\S]*?setIsSearchPending\(false\)\s*\}\)/)
+      assert.match(source, /batch\(\(\) => \{\s*setSearchMatches\(page\.hits(?:\.filter\([^)]*\))?\.map[\s\S]*?setActiveSearchIndex\(0\)[\s\S]*?setIsSearchPending\(false\)\s*\}\)/)
       dispose()
     })
   })
diff --git a/packages/ui/src/components/message-section.tsx b/packages/ui/src/components/message-section.tsx
index ac052e3bc..f2998547d 100644
--- a/packages/ui/src/components/message-section.tsx
+++ b/packages/ui/src/components/message-section.tsx
@@ -19,7 +19,7 @@ import { copyToClipboard } from "../lib/clipboard"
 import { showToastNotification } from "../lib/notifications"
 import type { InstanceMessageStore } from "../stores/message-v2/instance-store"
 import { isHiddenSyntheticTextPart, partHasRenderableText } from "../types/message"
-import { buildRecordDisplayData } from "../stores/message-v2/record-display-cache"
+import { buildRecordDisplayData, getRecordDisplayPartIds } from "../stores/message-v2/record-display-cache"
 import { getMessageSelectionActionPosition } from "../lib/message-selection-position"
 import { findHistoryMatches } from "../stores/session-history"
 import HistoryStatistics from "./history-statistics"
@@ -31,8 +31,8 @@ import { createSessionOutlineProjection } from "./session-outline-projection"
 import SessionCleanupProgress from "./session-cleanup-progress"
 import type { SessionSearchMatch } from "../lib/session-search"
 import { resolveThinkingExpansionDefault, resolveToolVisibility } from "./tool-call/tool-registry"
-import { createSearchLocatorAuthority, getMessageWindowPageKey, hasMessageSearchAuthority, loadPagesUntilAnchor, MESSAGE_HISTORY_TRAVERSAL_PAGE_LIMIT } from "./message-history-pagination"
-import { isLatestWindow, toWindowSnapshot } from "../stores/message-v2/message-window"
+import { isLatestWindow, preserveMessageWindowCursor, toWindowSnapshot } from "../stores/message-v2/message-window"
+import { createSearchLocatorAuthority, getMessageWindowPageKey, hasMessageSearchAuthority, loadPagesUntilAnchor } from "./message-history-pagination"
 import { getLogger } from "../lib/logger"
 import { beginMessageHistoryTraversal, invalidateMessageHistoryTraversal } from "../stores/session-api"
 import { getOpenCodeInstanceGeneration, getOpenCodeMutationRevision } from "../stores/opencode-data"
@@ -71,11 +71,11 @@ export interface MessageSectionProps {
   onQuoteSelection?: (text: string, mode: "quote" | "code") => void
   onReloadMessages?: () => void
   hasMoreMessages?: boolean
-  onLoadMoreMessages?: (signal?: AbortSignal) => Promise<void>
-  onLoadNewerMessages?: (signal?: AbortSignal) => Promise<void>
-  onLoadLatestMessages?: (signal?: AbortSignal) => Promise<void>
-  onLoadOldestMessages?: (signal?: AbortSignal) => Promise<void>
-  onLoadMessageAnchor?: (messageId: string, signal?: AbortSignal) => Promise<void>
+  onLoadMoreMessages?: (signal?: AbortSignal) => Promise<boolean | void>
+  onLoadNewerMessages?: (signal?: AbortSignal) => Promise<boolean | void>
+  onLoadLatestMessages?: (signal?: AbortSignal) => Promise<boolean | void>
+  onLoadOldestMessages?: (signal?: AbortSignal) => Promise<boolean | void>
+  onLoadMessageAnchor?: (messageId: string, signal?: AbortSignal) => Promise<boolean | void>
   getMessageHistoryCursor?: () => string | undefined
   isActive?: boolean
   sessionStreamingActive?: boolean
@@ -225,12 +225,13 @@ export default function MessageSection(props: MessageSectionProps) {
     const resolvedStore = store()
     const record = resolvedStore.getMessage(messageId)
     if (!record) return ""
-    const groups = Array.from(new Set(record.partIds.flatMap((partId) => {
+    const displayPartIds = getRecordDisplayPartIds(record)
+    const groups = Array.from(new Set(displayPartIds.flatMap((partId) => {
       const group = technicalGroupForPart(messageId, partId)
       return group ? [group.signature] : []
     }))).join(";")
     const pendingForms = pendingFormToolTargets()
-    const tools = record.partIds.flatMap((partId) => {
+    const tools = displayPartIds.flatMap((partId) => {
       const part = record.parts[partId]?.data
       if (part?.type !== "tool") return []
       const pending = Boolean(
@@ -517,14 +518,24 @@ export default function MessageSection(props: MessageSectionProps) {
       const snapshot = overlayWindowOnSnapshot(options?.snapshot ?? listApi()?.captureScrollSnapshot())
       if (snapshot) {
         setLastGoodScrollSnapshot(sessionId, snapshot)
-        store().setScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE, snapshot)
+        const resolvedStore = store()
+        resolvedStore.setScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE, preserveMessageWindowCursor(
+          snapshot,
+          resolvedStore.getScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE),
+          resolvedStore.getMessageWindow(sessionId),
+        ))
         return
       }
     }
 
     const lastGoodScrollSnapshot = getLastGoodScrollSnapshot(sessionId)
     if (lastGoodScrollSnapshot) {
-      store().setScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE, lastGoodScrollSnapshot)
+      const resolvedStore = store()
+      resolvedStore.setScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE, preserveMessageWindowCursor(
+        lastGoodScrollSnapshot,
+        resolvedStore.getScrollSnapshot(sessionId, MESSAGE_SCROLL_CACHE_SCOPE),
+        resolvedStore.getMessageWindow(sessionId),
+      ))
       return
     }
 
@@ -668,7 +679,7 @@ export default function MessageSection(props: MessageSectionProps) {
             hasAnchor: () => visibleMessageIds().includes(snapshot.anchorKey!),
             hasMore: () => Boolean(props.hasMoreMessages),
             isCurrent: isCurrentRestore,
-            loadMore: props.onLoadMoreMessages!,
+            loadMore: async () => { await props.onLoadMoreMessages?.() },
             getCursor: () => props.getMessageHistoryCursor?.(),
           })
         } catch (error) {
@@ -925,8 +936,8 @@ export default function MessageSection(props: MessageSectionProps) {
       if (!isCurrent()) return
       const previousPage = messageWindowPageKey()
       const previousPosition = direction === "older" || direction === "newer" ? api.captureScrollSnapshot() : undefined
-      await load(controller.signal)
-      if (!isCurrent()) return
+      const committed = await load(controller.signal)
+      if (committed === false || !isCurrent()) return
       // An empty boundary probe retires the older cursor without changing the
       // resident page. Do not jump from its top back to its bottom in that case.
       if (direction === "older" && messageWindowPageKey() === previousPage) return
@@ -1000,6 +1011,7 @@ export default function MessageSection(props: MessageSectionProps) {
     const query = debouncedSearchQuery()
     const workspace = searchWorkspace()
     const technical = includeTechnical()
+    const systemVisibility = preferences().systemMessagesVisibility
     const cursor = searchPageCursor()
     const mutationRevision = getOpenCodeMutationRevision(props.instanceId, props.sessionId)
     const instanceGeneration = getOpenCodeInstanceGeneration(props.instanceId)
@@ -1036,7 +1048,7 @@ export default function MessageSection(props: MessageSectionProps) {
       frame = requestAnimationFrame(() => {
         if (!isCurrentSearch()) return
         batch(() => {
-          setSearchMatches(page.hits.map(hit => ({
+          setSearchMatches(page.hits.filter(hit => hit.role !== "system" || systemVisibility !== "hidden").map(hit => ({
             id: `${hit.sessionID}:${hit.messageID}:${hit.partIndex}`,
             sessionId: hit.sessionID, messageId: hit.messageID, partType: hit.kind,
             role: hit.role === "user" ? "user" : "assistant", start: 0, end: query.length,
@@ -1343,6 +1355,7 @@ export default function MessageSection(props: MessageSectionProps) {
               messageId={messageId}
               instanceId={props.instanceId}
               sessionId={props.sessionId}
+              isActive={isActive}
               store={store}
               messageIndex={index()}
               showThinking={() => preferences().showThinkingBlocks}
diff --git a/packages/ui/src/components/permission-approval-modal.tsx b/packages/ui/src/components/permission-approval-modal.tsx
index 1c0be9f7d..a482e9060 100644
--- a/packages/ui/src/components/permission-approval-modal.tsx
+++ b/packages/ui/src/components/permission-approval-modal.tsx
@@ -11,10 +11,13 @@ import {
 import { activeSessionId, ensureSessionAncestorsExpanded, loadMessages, sessions as sessionStateSessions, setActiveSessionFromList } from "../stores/sessions"
 import { messageStoreBus } from "../stores/message-v2/bus"
 import { PERMISSION_REJECT_REASON_MAX_LENGTH } from "./tool-call/permission-constants"
+import { getPermissionDiffPayload, isPermissionApprovalBlocked } from "./tool-call/permission-block"
 import FormRequest from "./form-request"
 import { getFormQueue, type FormInfo } from "../stores/forms"
 import { sendFormCancel, sendFormReply } from "../stores/instances"
 import { shouldRenderFormInFallback } from "./form-request-tool-target"
+import { createPermissionDiffReviews } from "./permission-diff-review"
+import { PermissionFallbackDiff } from "./permission-fallback-diff"
 
 const LazyToolCall = lazy(() => import("./tool-call"))
 
@@ -141,6 +144,7 @@ const PermissionApprovalModal: Component<PermissionApprovalModalProps> = (props)
     if (!permissionId) return
 
     if (permissionSubmitting().has(permissionId)) return
+    if (response !== "reject" && isPermissionApprovalBlocked(getPermissionDiffPayload(permission), diffReview(permission)?.reviewed() ?? false)) return
 
     setPermissionBusy(permissionId, true)
     setPermissionItemError(permissionId, null)
@@ -161,6 +165,7 @@ const PermissionApprovalModal: Component<PermissionApprovalModalProps> = (props)
   }
 
   const permissionQueue = createMemo(() => getPermissionQueue(props.instanceId))
+  const diffReview = createPermissionDiffReviews(() => props.instanceId, permissionQueue)
   const formQueue = createMemo(() => getFormQueue(props.instanceId))
   const active = createMemo(() => activeInterruption().get(props.instanceId) ?? null)
 
@@ -353,6 +358,9 @@ const PermissionApprovalModal: Component<PermissionApprovalModalProps> = (props)
                                     <code>{primaryTitle()}</code>
                                   </div>
                                   <Show when={item.kind === "permission"}>
+                                    <Show when={diffReview(item.payload as PermissionRequest)} keyed>
+                                      {(review) => <PermissionFallbackDiff review={review} />}
+                                    </Show>
                                     <div class="tool-call-permission-reject-reason">
                                       <textarea
                                         id={`permission-center-reject-reason-${item.id}`}
@@ -368,10 +376,10 @@ const PermissionApprovalModal: Component<PermissionApprovalModalProps> = (props)
                                     </div>
                                     <div class="tool-call-permission-actions">
                                       <div class="tool-call-permission-buttons">
-                                        <button type="button" class="tool-call-permission-button" disabled={permissionSubmitting().has(item.id)} onClick={() => void handlePermissionDecision(item.payload as PermissionRequest, "once")}>
+                                        <button type="button" class="tool-call-permission-button" disabled={permissionSubmitting().has(item.id) || isPermissionApprovalBlocked(getPermissionDiffPayload(item.payload as PermissionRequest), diffReview(item.payload as PermissionRequest)?.reviewed() ?? false)} onClick={() => void handlePermissionDecision(item.payload as PermissionRequest, "once")}>
                                           {t("permissionApproval.actions.allowOnce")}
                                         </button>
-                                        <button type="button" class="tool-call-permission-button" disabled={permissionSubmitting().has(item.id)} onClick={() => void handlePermissionDecision(item.payload as PermissionRequest, "always")}>
+                                        <button type="button" class="tool-call-permission-button" disabled={permissionSubmitting().has(item.id) || isPermissionApprovalBlocked(getPermissionDiffPayload(item.payload as PermissionRequest), diffReview(item.payload as PermissionRequest)?.reviewed() ?? false)} onClick={() => void handlePermissionDecision(item.payload as PermissionRequest, "always")}>
                                           {t("permissionApproval.actions.alwaysAllow")}
                                         </button>
                                         <button
diff --git a/packages/ui/src/components/permission-diff-review.test.ts b/packages/ui/src/components/permission-diff-review.test.ts
new file mode 100644
index 000000000..f8abb5b6c
--- /dev/null
+++ b/packages/ui/src/components/permission-diff-review.test.ts
@@ -0,0 +1,67 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { createRoot, createSignal } from "solid-js"
+import type { PermissionRequest } from "../types/permission"
+import { createPermissionDiffReviews } from "./permission-diff-review"
+
+const request = (diff = "x".repeat(20_001)): PermissionRequest => ({
+  id: "request", sessionID: "session", action: "edit", resources: ["a.ts"], metadata: { diff, path: "a.ts" },
+})
+
+test("same-request reconciliation preserves access but diff/path changes invalidate it", () => {
+  createRoot((dispose) => {
+    const initial = request()
+    const [queue, setQueue] = createSignal([initial])
+    const review = createPermissionDiffReviews(() => "instance", queue)
+    const first = review(initial)!
+    first.complete()
+    assert.equal(first.reviewed(), true)
+    setQueue([{ ...initial, metadata: { ...initial.metadata, refreshed: true } }])
+    assert.equal(review(initial), first)
+    setQueue([request("changed".repeat(3_000))])
+    assert.equal(review(initial)!.reviewed(), false)
+    first.complete()
+    assert.equal(review(initial)!.reviewed(), false)
+    setQueue([initial])
+    assert.notEqual(review(initial), first)
+    assert.equal(review(initial)!.reviewed(), false)
+    review(initial)!.complete()
+    // Reconciliation must invalidate even if a closed view never reads the interim diff.
+    setQueue([request("interim")])
+    setQueue([initial])
+    assert.equal(review(initial)!.reviewed(), false)
+    review(initial)!.complete()
+    setQueue([{ ...initial, metadata: { ...initial.metadata, path: "b.ts" } }])
+    assert.equal(review(initial)!.reviewed(), false)
+    dispose()
+  })
+})
+
+test("access stays scoped to instance/session/request and late completion is fenced", () => {
+  createRoot((dispose) => {
+    const initial = request()
+    const [queue, setQueue] = createSignal([initial])
+    const [instance, setInstance] = createSignal("instance")
+    const review = createPermissionDiffReviews(instance, queue)
+    const first = review(initial)!
+    first.complete()
+    const sibling = { ...initial, id: "sibling" }
+    setQueue([initial, sibling])
+    assert.equal(review(sibling)!.reviewed(), false)
+    const moved = { ...initial, sessionID: "other-session" }
+    setQueue([moved])
+    assert.equal(review(moved)!.reviewed(), false)
+    review(moved)!.complete()
+    setInstance("other-instance")
+    assert.equal(review(moved)!.reviewed(), false)
+    const removed = review(moved)!
+    setQueue([])
+    removed.complete()
+    assert.equal(removed.reviewed(), false)
+    setQueue([moved])
+    const disposed = review(moved)!
+    dispose()
+    disposed.complete()
+    assert.equal(disposed.reviewed(), false)
+  })
+})
diff --git a/packages/ui/src/components/permission-diff-review.ts b/packages/ui/src/components/permission-diff-review.ts
new file mode 100644
index 000000000..ccaa841f1
--- /dev/null
+++ b/packages/ui/src/components/permission-diff-review.ts
@@ -0,0 +1,42 @@
+import { createMemo, createSignal, onCleanup, type Accessor } from "solid-js"
+import type { PermissionRequest } from "../types/permission"
+import { getPermissionDiffPayload } from "./tool-call/permission-block"
+import type { DiffPayload } from "./tool-call/types"
+
+export interface PermissionDiffReview {
+  payload: DiffPayload
+  reviewed: Accessor<boolean>
+  complete: () => void
+}
+
+/** Keep access acknowledgements across queue refreshes, only for the exact pending diff. */
+export function createPermissionDiffReviews(instanceId: Accessor<string>, permissions: Accessor<PermissionRequest[]>) {
+  let disposed = false
+  onCleanup(() => { disposed = true })
+  const key = (permission: PermissionRequest) => JSON.stringify([instanceId(), permission.sessionID, permission.id])
+  const reviews = createMemo<Map<string, PermissionDiffReview>>((previous) => {
+    const next = new Map<string, PermissionDiffReview>()
+    for (const permission of permissions()) {
+      const payload = getPermissionDiffPayload(permission)
+      if (!payload) continue
+      const id = key(permission)
+      const existing = previous?.get(id)
+      if (existing?.payload.diffText === payload.diffText && existing.payload.filePath === payload.filePath) {
+        next.set(id, existing)
+        continue
+      }
+      const [reviewed, setReviewed] = createSignal(false)
+      const review: PermissionDiffReview = {
+        payload,
+        reviewed,
+        complete: () => {
+          // A late clipboard result cannot acknowledge a replaced/removed request.
+          if (!disposed && reviews().get(id) === review) setReviewed(true)
+        },
+      }
+      next.set(id, review)
+    }
+    return next
+  })
+  return (permission: PermissionRequest) => reviews().get(key(permission))
+}
diff --git a/packages/ui/src/components/permission-fallback-diff.tsx b/packages/ui/src/components/permission-fallback-diff.tsx
new file mode 100644
index 000000000..24d733fc3
--- /dev/null
+++ b/packages/ui/src/components/permission-fallback-diff.tsx
@@ -0,0 +1,73 @@
+import { Show, createSignal, onCleanup } from "solid-js"
+import { ChevronLeft, ChevronRight, Copy } from "lucide-solid"
+import { useI18n } from "../lib/i18n"
+import { copyToClipboard } from "../lib/clipboard"
+import { TOOL_OUTPUT_RENDER_CHARACTER_LIMIT, getRelativePath } from "./tool-call/utils"
+import type { PermissionDiffReview } from "./permission-diff-review"
+
+/** Full source is accessible in fixed-size pages, never mounted as one huge DOM node. */
+export function PermissionFallbackDiff(props: { review: PermissionDiffReview }) {
+  const { t } = useI18n()
+  const [page, setPage] = createSignal(0)
+  const [copying, setCopying] = createSignal(false)
+  const [copyStatus, setCopyStatus] = createSignal("")
+  let scrollContainer: HTMLDivElement | undefined
+  let disposed = false
+  onCleanup(() => { disposed = true })
+  const text = () => props.review.payload.diffText
+  const pageCount = () => Math.max(1, Math.ceil(text().length / TOOL_OUTPUT_RENDER_CHARACTER_LIMIT))
+  const pageText = () => text().slice(page() * TOOL_OUTPUT_RENDER_CHARACTER_LIMIT, (page() + 1) * TOOL_OUTPUT_RENDER_CHARACTER_LIMIT)
+  const showPage = (index: number) => {
+    setPage(index)
+    if (scrollContainer) scrollContainer.scrollTop = 0
+  }
+  const nextPage = () => {
+    const next = Math.min(page() + 1, pageCount() - 1)
+    showPage(next)
+    // Navigation is sequential: reaching the final page exposes every character.
+    if (next === pageCount() - 1) props.review.complete()
+  }
+  const copy = async () => {
+    if (copying()) return
+    const review = props.review
+    setCopying(true)
+    setCopyStatus("")
+    const copied = await copyToClipboard(review.payload.diffText)
+    if (disposed || props.review !== review) return
+    setCopying(false)
+    setCopyStatus(t(copied ? "markdown.codeBlock.copy.copied" : "messageSection.quote.copyFailed"))
+    if (copied) review.complete()
+  }
+
+  return <div class="tool-call-permission-diff">
+    <div ref={scrollContainer} class="message-text tool-call-markdown tool-call-markdown-large tool-call-diff-shell">
+      <div class="tool-call-diff-toolbar" role="group" aria-label={t("toolCall.permission.requestedDiff.label")}>
+        <span class="tool-call-diff-toolbar-label">{props.review.payload.filePath
+          ? t("toolCall.permission.requestedDiff.withPath", { path: getRelativePath(props.review.payload.filePath!) })
+          : t("toolCall.permission.requestedDiff.label")}</span>
+        <div class="file-viewer-toolbar">
+          <button type="button" class="file-viewer-toolbar-icon-button" disabled={copying()} onClick={() => void copy()}
+            aria-label={t("toolCall.diff.copyPatch")} title={t("toolCall.diff.copyPatch")}>
+            <Copy class="h-4 w-4" aria-hidden="true" />
+          </button>
+          <Show when={pageCount() > 1}>
+            <button type="button" class="file-viewer-toolbar-icon-button" disabled={page() === 0} onClick={() => showPage(page() - 1)}
+              aria-label={t("toolCall.permission.diff.previous")} title={t("toolCall.permission.diff.previous")}>
+              <ChevronLeft class="h-4 w-4" aria-hidden="true" />
+            </button>
+            <span>{t("toolCall.permission.diff.page", { page: page() + 1, total: pageCount() })}</span>
+            <button type="button" class="file-viewer-toolbar-icon-button" disabled={page() === pageCount() - 1} onClick={nextPage}
+              aria-label={t("toolCall.permission.diff.next")} title={t("toolCall.permission.diff.next")}>
+              <ChevronRight class="h-4 w-4" aria-hidden="true" />
+            </button>
+          </Show>
+        </div>
+      </div>
+      <Show when={pageCount() > 1 && !props.review.reviewed()}>
+        <p class="tool-call-permission-queued-text">{t("toolCall.permission.diff.reviewRequired")}</p>
+      </Show>
+      <Show when={copyStatus()}><p role="status">{copyStatus()}</p></Show>
+      <pre class="tool-call-diff-fallback">{pageText()}</pre>
+    </div>
+  </div>
+}
diff --git a/packages/ui/src/components/session/session-view.tsx b/packages/ui/src/components/session/session-view.tsx
index 5e133091c..1ba3b7883 100644
--- a/packages/ui/src/components/session/session-view.tsx
+++ b/packages/ui/src/components/session/session-view.tsx
@@ -27,6 +27,7 @@ import { isSnapshotAutoFollowing } from "../virtual-follow-behavior"
 import { getSubmitBottomPinTargetCount, resolveSessionBottomPinIntent, shouldClearSessionBottomPinIntent, type SessionBottomPinIntent } from "./session-bottom-pin-intent"
 import { focusConversationStream } from "../focus-conversation"
 import { getOpenCodeSessionInbox, syncOpenCodeSessionInbox } from "../../stores/opencode-data"
+import { messagesLoaded } from "../../stores/session-state"
 import { stageSessionRevert } from "../../stores/session-actions"
 
 const log = getLogger("session")
@@ -352,6 +353,10 @@ export const SessionView: Component<SessionViewProps> = (props) => {
     isActive: () => Boolean(props.isActive),
     instanceId: () => props.instanceId,
     session,
+    shouldLoad: () => {
+      const id = session()?.id
+      return Boolean(id && !messagesLoaded().get(props.instanceId)?.has(id))
+    },
     loadMessages,
     waitForHydration: waitForInstanceReady,
     onError: (error) => log.error("Failed to load messages", error),
diff --git a/packages/ui/src/components/tool-call.tsx b/packages/ui/src/components/tool-call.tsx
index af60cbbdb..499627da3 100644
--- a/packages/ui/src/components/tool-call.tsx
+++ b/packages/ui/src/components/tool-call.tsx
@@ -20,7 +20,7 @@ import { resolveFormToolTarget } from "./form-request-tool-target"
 import { createAnsiContentRenderer } from "./tool-call/ansi-render"
 import { createDiffContentRenderer } from "./tool-call/diff-render"
 import { createMarkdownContentRenderer } from "./tool-call/markdown-render"
-import { extractDiagnostics, diagnosticFileName } from "./tool-call/diagnostics"
+import { extractDiagnosticsView, diagnosticFileName } from "./tool-call/diagnostics"
 import { renderDiagnosticsSection } from "./tool-call/diagnostics-section"
 import type {
   DiffPayload,
@@ -32,10 +32,15 @@ import type {
 import {
   buildToolSpeechText,
   ensureMarkdownContent,
+  formatToolInputForCopy,
+  formatToolInputForRender,
   getToolName,
   getToolTitleDetail,
   isToolStateCompleted,
   isToolStateRunning,
+  limitToolOutputForRender,
+  limitToolTitleForRender,
+  TOOL_OUTPUT_RENDER_CHARACTER_LIMIT,
   getDefaultToolAction,
   readToolStatePayload,
 } from "./tool-call/utils"
@@ -74,6 +79,7 @@ interface ToolCallProps {
   partVersion?: number
   instanceId: string
   sessionId: string
+  isActive?: Accessor<boolean>
   onContentRendered?: () => void
   /**
    * When true, tool call starts collapsed regardless of user preferences.
@@ -118,6 +124,7 @@ function ToolCallDetails(props: {
   toolCallIdentifier: () => string
   instanceId: string
   sessionId: string
+  isActive?: Accessor<boolean>
   messageId?: string
   messageVersion?: number
   partVersion?: number
@@ -187,6 +194,7 @@ function ToolCallDetails(props: {
   })
 
   const [permissionSubmitting, setPermissionSubmitting] = createSignal(false)
+  const [permissionApprovalBlocked, setPermissionApprovalBlocked] = createSignal(true)
   const [permissionError, setPermissionError] = createSignal<string | null>(null)
 
   const followScroll = createFollowScroll({
@@ -249,6 +257,7 @@ function ToolCallDetails(props: {
       if (isTextInputFocused()) return
       const permission = permissionDetails()
       if (!permission || !props.isPermissionActive()) return
+      if (permissionApprovalBlocked()) return
       if (event.key === "Enter") {
         event.preventDefault()
         void handlePermissionResponse(permission, "once")
@@ -272,25 +281,15 @@ function ToolCallDetails(props: {
 
   const status = () => props.toolState()?.status || ""
 
-  const toolInputDisplay = createMemo((): { content: string; copyText: string; language: string } | null => {
+  const toolInputDisplay = createMemo((): { content: string; language: string } | null => {
     const input = props.toolInput()
-    if (!input || Object.keys(input).length === 0) return null
-
-    try {
-      const yamlText = stringifyYaml(input)
-      const content = ensureMarkdownContent(yamlText, "yaml", true)
-      return content ? { content, copyText: yamlText, language: "yaml" } : null
-    } catch (error) {
-      log.error("Failed to convert tool call input to YAML", error)
-      try {
-        const jsonText = JSON.stringify(input, null, 2)
-        const content = ensureMarkdownContent(jsonText, "json", true)
-        return content ? { content, copyText: jsonText, language: "json" } : null
-      } catch (nestedError) {
-        log.error("Failed to stringify tool call input", nestedError)
-        return null
-      }
-    }
+    if (!input) return null
+    if (!props.inputSectionExpanded()) return { content: "", language: "json" }
+    const formatted = formatToolInputForRender(input)
+    if (!formatted) return null
+    const language = formatted.language ?? "text"
+    const content = ensureMarkdownContent(formatted.text, language, true)
+    return content ? { content, language } : null
   })
 
   const renderer = createMemo(() => resolveToolRenderer(props.toolName()))
@@ -328,7 +327,7 @@ function ToolCallDetails(props: {
   })
 
   const renderOutputMarkdownContent: ToolRendererContext["renderMarkdown"] = (options) =>
-    renderMarkdownContent({ ...options, wrap: options.wrap ?? props.outputWrapEnabled() })
+    renderMarkdownContent({ ...options, content: limitToolOutputForRender(options.content), wrap: options.wrap ?? props.outputWrapEnabled() })
 
   const rendererContext: ToolRendererContext = {
     toolCall: props.toolCallMemo,
@@ -336,6 +335,7 @@ function ToolCallDetails(props: {
     toolName: props.toolName,
     instanceId: props.instanceId,
     sessionId: props.sessionId,
+    isActive: () => props.isActive?.() ?? true,
     t: props.t,
     messageVersion: messageVersionAccessor,
     partVersion: partVersionAccessor,
@@ -353,6 +353,7 @@ function ToolCallDetails(props: {
           partVersion={options.partVersion}
           instanceId={props.instanceId}
           sessionId={options.sessionId}
+          isActive={rendererContext.isActive}
           onContentRendered={props.onContentRendered}
           forceCollapsed={options.forceCollapsed}
         />
@@ -393,13 +394,21 @@ function ToolCallDetails(props: {
   }
 
   const outputChrome = createMemo<ToolOutputChrome>(() => renderer().getOutputChrome?.(rendererContext) ?? {})
+  const resolveOutputCopyText = () => outputChrome().copyText || outputChrome().getCopyText?.() || ""
+  const canCopyOutput = () => outputChrome().hasCopyText ?? Boolean(outputChrome().copyText || outputChrome().getCopyText)
 
   const renderError = () => {
     const state = props.toolState()
     if (state?.status === "error" && state.error) {
+      const truncated = state.error.length > TOOL_OUTPUT_RENDER_CHARACTER_LIMIT
       return (
         <div class="tool-call-error-content">
-          <strong>{props.t("toolCall.error.label")}</strong> {state.error}
+          <strong>{props.t("toolCall.error.label")}</strong> {limitToolOutputForRender(state.error)}
+          <Show when={truncated}>
+            <button type="button" class="tool-call-header-icon-button tool-call-io-copy" onClick={(event) => void copyIoText(event, state.error)} aria-label={props.t("toolCall.io.copyOutputAriaLabel")} title={props.t("toolCall.io.copyOutputTitle")}>
+              <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+            </button>
+          </Show>
         </div>
       )
     }
@@ -414,6 +423,7 @@ function ToolCallDetails(props: {
       error={permissionError}
       renderDiff={renderDiffContent}
       fallbackSessionId={() => props.sessionId}
+      onApprovalBlockedChange={setPermissionApprovalBlocked}
       onRespond={(permission, sessionId, response, message) => void handlePermissionResponse(permission, response, message)}
     />
   )
@@ -430,6 +440,10 @@ function ToolCallDetails(props: {
     await copyToClipboard(text)
   }
 
+  const copyToolInput = async (event: MouseEvent) => {
+    await copyIoText(event, formatToolInputForCopy(props.toolInput())?.text)
+  }
+
   const outputWrapTitle = () =>
     props.outputWrapEnabled()
       ? props.t("toolCall.diff.disableWordWrap")
@@ -443,6 +457,7 @@ function ToolCallDetails(props: {
     copyText?: () => string | null | undefined
     copyTitle?: () => string
     copyAriaLabel?: () => string
+    onCopy?: (event: MouseEvent) => void
     actions?: () => JSXElement
   }) => (
     <div class="tool-call-io-header">
@@ -458,18 +473,16 @@ function ToolCallDetails(props: {
         {(actions) => <span class="tool-call-io-actions">{actions()}</span>}
       </Show>
 
-      <Show when={options.copyText?.()}>
-        {(copyText) => (
-          <button
-            type="button"
-            class="tool-call-header-icon-button tool-call-header-copy tool-call-io-copy"
-            onClick={(event) => void copyIoText(event, copyText())}
-            aria-label={options.copyAriaLabel?.() ?? props.t("toolCall.io.copyOutputAriaLabel")}
-            title={options.copyTitle?.() ?? props.t("toolCall.io.copyOutputTitle")}
-          >
-            <Copy class="w-3.5 h-3.5" aria-hidden="true" />
-          </button>
-        )}
+      <Show when={Boolean(options.copyText?.() || options.onCopy)}>
+        <button
+          type="button"
+          class="tool-call-header-icon-button tool-call-io-copy"
+          onClick={(event) => options.onCopy ? options.onCopy(event) : void copyIoText(event, options.copyText?.())}
+          aria-label={options.copyAriaLabel?.() ?? props.t("toolCall.io.copyOutputAriaLabel")}
+          title={options.copyTitle?.() ?? props.t("toolCall.io.copyOutputTitle")}
+        >
+          <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+        </button>
       </Show>
     </div>
   )
@@ -556,7 +569,7 @@ function ToolCallDetails(props: {
                   language: () => toolInputDisplay()?.language,
                   expanded: props.inputSectionExpanded,
                   onToggle: props.toggleInputSection,
-                  copyText: () => toolInputDisplay()?.copyText,
+                  onCopy: copyToolInput,
                   copyTitle: () => props.t("toolCall.io.copyInputTitle"),
                   copyAriaLabel: () => props.t("toolCall.io.copyInputAriaLabel"),
                 })
@@ -581,6 +594,7 @@ function ToolCallDetails(props: {
                     expanded: props.outputSectionExpanded,
                     onToggle: props.toggleOutputSection,
                     copyText: () => outputChrome().copyText,
+                    onCopy: canCopyOutput() ? (event) => void copyIoText(event, resolveOutputCopyText()) : undefined,
                     copyTitle: () => props.t("toolCall.io.copyOutputTitle"),
                     copyAriaLabel: () => props.t("toolCall.io.copyOutputAriaLabel"),
                     actions: () => outputChrome().actions,
@@ -715,7 +729,9 @@ export default function ToolCall(props: ToolCallProps) {
 
   const hasToolInput = createMemo(() => {
     const input = toolInput()
-    return input && Object.keys(input).length > 0
+    if (!input) return false
+    for (const key in input) if (Object.prototype.hasOwnProperty.call(input, key)) return true
+    return false
   })
 
   const [toolCallRootEl, setToolCallRootEl] = createSignal<HTMLDivElement | undefined>()
@@ -728,11 +744,7 @@ export default function ToolCall(props: ToolCallProps) {
     if (override !== undefined) return override
     return diagnosticsDefaultExpanded()
   }
-  const diagnosticsEntries = createMemo(() => {
-    const state = toolState()
-    if (!state) return []
-    return extractDiagnostics(state)
-  })
+  const diagnosticsView = createMemo(() => extractDiagnosticsView(toolState()))
 
   const toggleInputSection = () => {
     setInputSectionOverride((prev) => {
@@ -842,6 +854,7 @@ export default function ToolCall(props: ToolCallProps) {
   }
 
   const toolTypeLabel = createMemo(() => toolName())
+  const renderedToolTypeLabel = createMemo(() => limitToolTitleForRender(toolTypeLabel()))
 
   const headerTitleDetail = createMemo(() => getToolTitleDetail(renderToolTitle(), toolName()))
 
@@ -851,9 +864,10 @@ export default function ToolCall(props: ToolCallProps) {
     const detail = headerTitleDetail()
     return [typeLabel, detail].filter(Boolean).join(" ")
   })
+  const renderedHeaderTitleDetail = createMemo(() => limitToolTitleForRender(headerTitleDetail()))
 
-  const headerCopyText = createMemo(() => headerOutputChrome().copyText || "")
-  const canCopyHeaderOutput = () => headerCopyText().length > 0
+  const headerCopyText = () => headerOutputChrome().copyText || headerOutputChrome().getCopyText?.() || ""
+  const canCopyHeaderOutput = () => headerOutputChrome().hasCopyText ?? Boolean(headerOutputChrome().copyText || headerOutputChrome().getCopyText)
   const speechText = createMemo(() =>
     buildToolSpeechText({
       title: headerText(),
@@ -949,8 +963,8 @@ export default function ToolCall(props: ToolCallProps) {
         >
           <ChevronRight class="tool-call-disclosure disclosure-chevron" aria-hidden="true" />
           <span class="tool-call-summary">
-            <span class="tool-call-summary-type">{toolTypeLabel()}</span>
-            <Show when={headerTitleDetail()}>
+            <span class="tool-call-summary-type">{renderedToolTypeLabel()}</span>
+            <Show when={renderedHeaderTitleDetail()}>
               {(detail) => <span class="tool-call-summary-title">{detail()}</span>}
             </Show>
             <ToolStatusIndicator status={status} t={t} />
@@ -965,7 +979,7 @@ export default function ToolCall(props: ToolCallProps) {
             aria-label={t("toolCall.header.copyOutputAriaLabel")}
             title={t("toolCall.header.copyOutputTitle")}
           >
-            <Copy class="w-3.5 h-3.5" />
+            <Copy class="w-3.5 h-3.5" aria-hidden="true" />
           </button>
         </Show>
 
@@ -1020,6 +1034,7 @@ export default function ToolCall(props: ToolCallProps) {
           toolCallIdentifier={toolCallIdentifier}
           instanceId={props.instanceId}
           sessionId={props.sessionId}
+          isActive={props.isActive}
           messageId={props.messageId}
           messageVersion={props.messageVersion}
           partVersion={props.partVersion}
@@ -1046,17 +1061,17 @@ export default function ToolCall(props: ToolCallProps) {
         />
       </Show>
  
-      <Show when={!hasPendingForm() && diagnosticsEntries().length && diagnosticsVisibility() !== "hidden"}>
+      <Show when={!hasPendingForm() && (diagnosticsView().entries.length > 0 || diagnosticsView().truncated) && diagnosticsVisibility() !== "hidden"}>
 
         {renderDiagnosticsSection(
           t,
-          diagnosticsEntries(),
+          diagnosticsView(),
           diagnosticsExpanded(),
           () => setDiagnosticsOverride((prev) => {
             const current = prev === undefined ? diagnosticsDefaultExpanded() : prev
             return !current
           }),
-          diagnosticFileName(diagnosticsEntries()),
+          diagnosticFileName(diagnosticsView().entries),
         )}
       </Show>
 
diff --git a/packages/ui/src/components/tool-call/ansi-render.tsx b/packages/ui/src/components/tool-call/ansi-render.tsx
index d7eb2e7de..b378920d0 100644
--- a/packages/ui/src/components/tool-call/ansi-render.tsx
+++ b/packages/ui/src/components/tool-call/ansi-render.tsx
@@ -3,6 +3,7 @@ import type { RenderCache } from "../../types/message"
 import { ansiToHtml, createAnsiStreamRenderer, hasAnsi } from "../../lib/ansi"
 import { escapeHtml } from "../../lib/text-render-utils"
 import type { AnsiRenderOptions, ToolScrollHelpers } from "./types"
+import { limitToolOutputForRender } from "./utils"
 
 type AnsiRenderCache = RenderCache & { hasAnsi: boolean }
 
@@ -129,6 +130,7 @@ export function createAnsiContentRenderer(params: {
       return null
     }
 
+    const content = limitToolOutputForRender(options.content)
     const size = options.size || "default"
     const messageClass = `message-text tool-call-markdown${size === "large" ? " tool-call-markdown-large" : ""}`
     const cacheHandle = options.variant === "running" ? params.ansiRunningCache : params.ansiFinalCache
@@ -143,7 +145,6 @@ export function createAnsiContentRenderer(params: {
     let nextCache: AnsiRenderCache
 
     if (isRunningVariant) {
-      const content = options.content
       const resetStreaming = !cached || !cached.text || !content.startsWith(cached.text) || cached.text !== runningAnsiSource
 
       if (resetStreaming) {
@@ -182,12 +183,12 @@ export function createAnsiContentRenderer(params: {
       runningAnsiSource = nextCache.text
       cacheHandle.set(nextCache)
     } else {
-      if (cached && cached.text === options.content) {
+      if (cached && cached.text === content) {
         nextCache = { ...cached, mode }
       } else {
-        const detectedAnsi = hasAnsi(options.content)
-        const html = detectedAnsi ? ansiToHtml(options.content) : escapeHtml(options.content)
-        nextCache = { text: options.content, html, mode, hasAnsi: detectedAnsi }
+        const detectedAnsi = hasAnsi(content)
+        const html = detectedAnsi ? ansiToHtml(content) : escapeHtml(content)
+        nextCache = { text: content, html, mode, hasAnsi: detectedAnsi }
         cacheHandle.set(nextCache)
       }
     }
diff --git a/packages/ui/src/components/tool-call/diagnostic-selection.ts b/packages/ui/src/components/tool-call/diagnostic-selection.ts
new file mode 100644
index 000000000..304563099
--- /dev/null
+++ b/packages/ui/src/components/tool-call/diagnostic-selection.ts
@@ -0,0 +1,12 @@
+export function selectSeverityBounded<T>(values: readonly T[], rank: (value: T) => number | undefined, limit: number): T[] {
+  const buckets: T[][] = [[], [], []]
+  const scanLimit = Math.max(limit, limit * 100)
+  for (let index = 0; index < values.length && index < scanLimit; index += 1) {
+    const value = values[index]
+    const valueRank = rank(value)
+    if (valueRank === undefined) continue
+    const bucket = buckets[Math.max(0, Math.min(2, valueRank))]!
+    if (bucket.length < limit) bucket.push(value)
+  }
+  return buckets.flat().slice(0, limit)
+}
diff --git a/packages/ui/src/components/tool-call/diagnostics-section.tsx b/packages/ui/src/components/tool-call/diagnostics-section.tsx
index 9362baeb7..eb4adb118 100644
--- a/packages/ui/src/components/tool-call/diagnostics-section.tsx
+++ b/packages/ui/src/components/tool-call/diagnostics-section.tsx
@@ -1,15 +1,29 @@
 import { For, Show } from "solid-js"
-import { ChevronRight } from "lucide-solid"
-import type { DiagnosticEntry } from "./diagnostics"
+import { ChevronRight, Copy } from "lucide-solid"
+import { hasDiagnosticMessages, type DiagnosticsMap, type DiagnosticsView } from "./diagnostics"
+import { copyToClipboard } from "../../lib/clipboard"
+import { formatUnknownForCopy } from "./utils"
 
+export function DiagnosticsPayloadAccess(props: { diagnostics: DiagnosticsMap; truncated: boolean; t: (key: string, params?: Record<string, unknown>) => string }) {
+  return (
+    <div class="tool-call-diagnostic-row">
+      <span class="tool-call-diagnostic-message" role="status">
+        {props.t(props.truncated ? "toolCall.output.truncated" : "toolCall.diagnostics.title")}
+      </span>
+      <button type="button" class="tool-call-header-icon-button tool-call-io-copy" onClick={() => void copyToClipboard(formatUnknownForCopy(props.diagnostics)?.text ?? "")} aria-label={props.t("toolCall.io.copyOutputAriaLabel")} title={props.t("toolCall.io.copyOutputTitle")}>
+        <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+      </button>
+    </div>
+  )
+}
 export function renderDiagnosticsSection(
   t: (key: string, params?: Record<string, unknown>) => string,
-  entries: DiagnosticEntry[],
+  view: DiagnosticsView,
   expanded: boolean,
   toggle: () => void,
   fileLabel: string,
 ) {
-  if (entries.length === 0) return null
+  if (!hasDiagnosticMessages(view.diagnostics)) return null
   return (
     <div class="tool-call-diagnostics-wrapper">
       <button
@@ -23,14 +37,18 @@ export function renderDiagnosticsSection(
           🛠
         </span>
         <span class="tool-call-summary">{t("toolCall.diagnostics.title")}</span>
+        <Show when={view.truncated}>
+          <span class="tool-call-diagnostic-message">{t("toolCall.output.truncated")}</span>
+        </Show>
         <span class="tool-call-diagnostics-file" title={fileLabel}>
           {fileLabel}
         </span>
       </button>
       <Show when={expanded}>
         <div class="tool-call-diagnostics" role="region" aria-label={t("toolCall.diagnostics.ariaLabel")}>
+          <DiagnosticsPayloadAccess diagnostics={view.diagnostics} truncated={view.truncated} t={t} />
           <div class="tool-call-diagnostics-body" role="list">
-            <For each={entries}>
+            <For each={view.entries}>
               {(entry) => (
                 <div class="tool-call-diagnostic-row" role="listitem">
                   <span class={`tool-call-diagnostic-chip tool-call-diagnostic-${entry.tone}`}>
diff --git a/packages/ui/src/components/tool-call/diagnostics.ts b/packages/ui/src/components/tool-call/diagnostics.ts
index f7f50dcab..5bd739cad 100644
--- a/packages/ui/src/components/tool-call/diagnostics.ts
+++ b/packages/ui/src/components/tool-call/diagnostics.ts
@@ -1,6 +1,7 @@
 import type { ToolState } from "../../types/tool-state"
 import { getRelativePath, isToolStateCompleted, isToolStateError, isToolStateRunning } from "./utils"
 import { tGlobal } from "../../lib/i18n"
+import { selectSeverityBounded } from "./diagnostic-selection"
 
 interface LspRangePosition {
   line?: number
@@ -26,12 +27,50 @@ export interface DiagnosticEntry {
   label: string
   icon: string
   message: string
+  messageTruncated: boolean
   filePath: string
   displayPath: string
   line: number
   column: number
 }
 
+export interface DiagnosticsView {
+  diagnostics: DiagnosticsMap
+  entries: DiagnosticEntry[]
+  key?: string
+  truncated: boolean
+}
+
+function diagnosticListHasMessages(list: unknown): boolean {
+  if (!Array.isArray(list)) return false
+  for (let index = 0; index < list.length && index < 10_000; index += 1) {
+    if (typeof list[index]?.message === "string") return true
+  }
+  return list.length > 10_000
+}
+
+const DIAGNOSTIC_SCAN_LIMIT = 10_000
+
+export function hasDiagnosticMessages(diagnostics: DiagnosticsMap): boolean {
+  let scanned = 0
+  let scannedKeys = 0
+  for (const key in diagnostics) {
+    if (!Object.prototype.hasOwnProperty.call(diagnostics, key)) continue
+    scannedKeys += 1
+    if (scannedKeys > DIAGNOSTIC_SCAN_LIMIT) return true
+    const list = diagnostics[key]
+    if (!Array.isArray(list)) continue
+    const remaining = DIAGNOSTIC_SCAN_LIMIT - scanned
+    if (remaining <= 0) return true
+    for (let index = 0; index < list.length && index < remaining; index += 1) {
+      scanned += 1
+      if (typeof list[index]?.message === "string") return true
+    }
+    if (list.length > remaining) return true
+  }
+  return false
+}
+
 export function normalizeDiagnosticPath(path: string) {
   return path.replace(/\\/g, "/")
 }
@@ -48,26 +87,45 @@ function getSeverityMeta(tone: DiagnosticEntry["tone"]) {
   return { label: tGlobal("toolCall.diagnostics.severity.info.short"), icon: "i", rank: 2 }
 }
 
-export function extractDiagnostics(state: ToolState | undefined): DiagnosticEntry[] {
-  if (!state) return []
+export function extractDiagnosticsView(state: ToolState | undefined): DiagnosticsView {
+  if (!state) return buildDiagnosticView({}, [])
   const supportsMetadata = isToolStateRunning(state) || isToolStateCompleted(state) || isToolStateError(state)
-  if (!supportsMetadata) return []
+  if (!supportsMetadata) return buildDiagnosticView({}, [])
 
   const metadata = (state.metadata || {}) as Record<string, unknown>
   const input = (state.input || {}) as Record<string, unknown>
   const diagnosticsMap = metadata?.diagnostics as DiagnosticsMap | undefined
-  if (!diagnosticsMap) return []
+  if (!diagnosticsMap) return buildDiagnosticView({}, [])
 
-  return buildDiagnosticEntries(diagnosticsMap, [input.filePath, metadata.filePath, metadata.filepath, input.path].map((value) =>
+  const view = buildDiagnosticView(diagnosticsMap, [input.filePath, metadata.filePath, metadata.filepath, input.path].map((value) =>
     typeof value === "string" ? value : undefined,
   ))
+  let scanned = 0
+  let scannedKeys = 0
+  for (const key in diagnosticsMap) {
+    if (!Object.prototype.hasOwnProperty.call(diagnosticsMap, key)) continue
+    scannedKeys += 1
+    if (scannedKeys > DIAGNOSTIC_SCAN_LIMIT) return { ...view, truncated: true }
+    const list = diagnosticsMap[key]
+    if (!Array.isArray(list)) continue
+    const remaining = DIAGNOSTIC_SCAN_LIMIT - scanned
+    if (remaining <= 0) return { ...view, truncated: true }
+    for (let index = 0; index < list.length && index < remaining; index += 1) {
+      scanned += 1
+      if (key !== view.key && typeof list[index]?.message === "string") return { ...view, truncated: true }
+    }
+    if (list.length > remaining) return { ...view, truncated: true }
+  }
+  return view
 }
 
-export function resolveDiagnosticsKey(diagnostics: DiagnosticsMap, preferredPaths: Array<string | undefined>): string | undefined {
-  if (Object.keys(diagnostics).length === 0) return undefined
+export function extractDiagnostics(state: ToolState | undefined): DiagnosticEntry[] {
+  return extractDiagnosticsView(state).entries
+}
 
+export function resolveDiagnosticsKey(diagnostics: DiagnosticsMap, preferredPaths: Array<string | undefined>): string | undefined {
   const normalizedPreferred = preferredPaths
-    .filter((value): value is string => typeof value === "string" && value.length > 0)
+    .filter((value): value is string => typeof value === "string" && value.length > 0 && value.length <= 4_096)
     .map((value) => normalizeDiagnosticPath(value))
 
   if (normalizedPreferred.length === 0) return undefined
@@ -76,7 +134,15 @@ export function resolveDiagnosticsKey(diagnostics: DiagnosticsMap, preferredPath
     if (diagnostics[preferred]) return preferred
   }
 
-  const keys = Object.keys(diagnostics)
+  const keys: string[] = []
+  let scannedKeys = 0
+  for (const key in diagnostics) {
+    if (!Object.prototype.hasOwnProperty.call(diagnostics, key)) continue
+    scannedKeys += 1
+    if (scannedKeys > 10_000) break
+    if (key.length > 4_096) continue
+    keys.push(key)
+  }
 
   for (const preferred of normalizedPreferred) {
     const direct = keys.find((key) => normalizeDiagnosticPath(key) === preferred)
@@ -94,29 +160,38 @@ export function resolveDiagnosticsKey(diagnostics: DiagnosticsMap, preferredPath
   return undefined
 }
 
-export function buildDiagnosticEntries(diagnostics: DiagnosticsMap, preferredPaths: Array<string | undefined>): DiagnosticEntry[] {
+export function buildDiagnosticView(diagnostics: DiagnosticsMap, preferredPaths: Array<string | undefined>): DiagnosticsView {
   const key = resolveDiagnosticsKey(diagnostics, preferredPaths)
-  if (!key) return []
+  if (!key) return { diagnostics, entries: [], truncated: false }
 
   const list = diagnostics[key]
-  if (!Array.isArray(list) || list.length === 0) return []
+  if (!Array.isArray(list) || list.length === 0) return { diagnostics, entries: [], key, truncated: false }
 
+  const limit = 100
   const entries: DiagnosticEntry[] = []
   const normalizedPath = normalizeDiagnosticPath(key)
-  for (let index = 0; index < list.length; index++) {
-    const diagnostic = list[index]
+  const selected = selectSeverityBounded(
+    list,
+    (diagnostic) => diagnostic && typeof diagnostic.message === "string"
+      ? getSeverityMeta(determineSeverityTone(diagnostic.severity)).rank
+      : undefined,
+    limit,
+  )
+  for (const diagnostic of selected) {
+    const index = entries.length
     if (!diagnostic || typeof diagnostic.message !== "string") continue
     const tone = determineSeverityTone(typeof diagnostic.severity === "number" ? diagnostic.severity : undefined)
     const severityMeta = getSeverityMeta(tone)
     const line = typeof diagnostic.range?.start?.line === "number" ? diagnostic.range.start.line + 1 : 0
     const column = typeof diagnostic.range?.start?.character === "number" ? diagnostic.range.start.character + 1 : 0
     entries.push({
-      id: `${normalizedPath}-${index}-${diagnostic.message}`,
+      id: String(index),
       severity: severityMeta.rank,
       tone,
       label: severityMeta.label,
       icon: severityMeta.icon,
-      message: diagnostic.message,
+      message: diagnostic.message.slice(0, 2_000),
+      messageTruncated: diagnostic.message.length > 2_000,
       filePath: normalizedPath,
       displayPath: getRelativePath(normalizedPath),
       line,
@@ -124,7 +199,16 @@ export function buildDiagnosticEntries(diagnostics: DiagnosticsMap, preferredPat
     })
   }
 
-  return entries.sort((a, b) => a.severity - b.severity)
+  return {
+    diagnostics,
+    entries,
+    key,
+    truncated: list.length > entries.length || entries.some((entry) => entry.messageTruncated),
+  }
+}
+
+export function buildDiagnosticEntries(diagnostics: DiagnosticsMap, preferredPaths: Array<string | undefined>): DiagnosticEntry[] {
+  return buildDiagnosticView(diagnostics, preferredPaths).entries
 }
 
 export function diagnosticFileName(entries: DiagnosticEntry[]) {
diff --git a/packages/ui/src/components/tool-call/diff-render.tsx b/packages/ui/src/components/tool-call/diff-render.tsx
index bdaaac953..9c1b5ea2e 100644
--- a/packages/ui/src/components/tool-call/diff-render.tsx
+++ b/packages/ui/src/components/tool-call/diff-render.tsx
@@ -1,11 +1,11 @@
-import { Suspense, createEffect, createMemo, createSignal, lazy, onMount, type Accessor, type JSXElement } from "solid-js"
+import { Show, Suspense, createEffect, createMemo, createSignal, lazy, onMount, type Accessor, type JSXElement } from "solid-js"
 import type { ToolState } from "../../types/tool-state"
 import useMediaQuery from "@suid/material/useMediaQuery"
 import { AlignJustify, Copy, Split, WrapText } from "lucide-solid"
 import type { RenderCache } from "../../types/message"
 import type { DiffViewMode } from "../../stores/preferences"
 import type { DiffPayload, DiffRenderOptions, ToolScrollHelpers } from "./types"
-import { getRelativePath } from "./utils"
+import { getRelativePath, limitToolOutputForRender, shouldRenderDiffPayloadAsPlainText } from "./utils"
 import { getCacheEntry } from "../../lib/global-cache"
 import { copyToClipboard } from "../../lib/clipboard"
 
@@ -65,6 +65,8 @@ export function createDiffContentRenderer(params: {
   }
 
   function renderDiffContent(payload: DiffPayload, options?: DiffRenderOptions): JSXElement | null {
+    const renderedDiffText = limitToolOutputForRender(payload.diffText)
+    const diffWasTruncated = shouldRenderDiffPayloadAsPlainText(payload)
     const relativePath = payload.filePath ? getRelativePath(payload.filePath) : ""
     const toolbarLabel = options?.label || (relativePath
       ? params.t("toolCall.diff.label.withPath", { path: relativePath })
@@ -100,7 +102,7 @@ export function createDiffContentRenderer(params: {
       const cached = getCacheEntry<RenderCache>(cacheEntryParams)
       if (
         cached
-        && cached.text === payload.diffText
+        && cached.text === renderedDiffText
         && cached.theme === themeKey
         && cached.mode === currentMode()
         && cached.wrap === currentWrap()
@@ -127,6 +129,10 @@ export function createDiffContentRenderer(params: {
         ? params.t("toolCall.diff.disableWordWrap")
         : params.t("toolCall.diff.enableWordWrap")
     const copyPatchTitle = () => params.t("toolCall.diff.copyPatch")
+    const copyFullDiff = async () => {
+      const copiedDiff = payload.copyText ?? payload.diffText
+      if (await copyToClipboard(copiedDiff)) options?.onFullDiffAccess?.(copiedDiff)
+    }
 
     const handleDiffRendered = () => {
       params.handleScrollRendered()
@@ -146,40 +152,44 @@ export function createDiffContentRenderer(params: {
             <button
               type="button"
               class="file-viewer-toolbar-icon-button"
-              onClick={() => void copyToClipboard(payload.diffText)}
+              onClick={() => void copyFullDiff()}
               aria-label={copyPatchTitle()}
               title={copyPatchTitle()}
             >
               <Copy class="h-4 w-4" aria-hidden="true" />
             </button>
-            <button
-              type="button"
-              class="file-viewer-toolbar-icon-button icon-toggle"
-              onClick={() => handleModeChange(nextViewMode())}
-              aria-label={viewModeTitle()}
-              aria-pressed={currentMode() === "split"}
-              title={viewModeTitle()}
-            >
-              {nextViewMode() === "split" ? <Split class="h-4 w-4" aria-hidden="true" /> : <AlignJustify class="h-4 w-4" aria-hidden="true" />}
-            </button>
-            <button
-              type="button"
-              class="file-viewer-toolbar-icon-button icon-toggle"
-              onClick={() => setWordWrapEnabled((enabled) => !enabled)}
-              aria-label={wordWrapTitle()}
-              aria-pressed={wordWrapEnabled()}
-              title={wordWrapTitle()}
-            >
-              <WrapText class="h-4 w-4" aria-hidden="true" />
-            </button>
+            <Show when={!diffWasTruncated}>
+              <button
+                type="button"
+                class="file-viewer-toolbar-icon-button icon-toggle"
+                onClick={() => handleModeChange(nextViewMode())}
+                aria-label={viewModeTitle()}
+                aria-pressed={currentMode() === "split"}
+                title={viewModeTitle()}
+              >
+                {nextViewMode() === "split" ? <Split class="h-4 w-4" aria-hidden="true" /> : <AlignJustify class="h-4 w-4" aria-hidden="true" />}
+              </button>
+              <button
+                type="button"
+                class="file-viewer-toolbar-icon-button icon-toggle"
+                onClick={() => setWordWrapEnabled((enabled) => !enabled)}
+                aria-label={wordWrapTitle()}
+                aria-pressed={wordWrapEnabled()}
+                title={wordWrapTitle()}
+              >
+                <WrapText class="h-4 w-4" aria-hidden="true" />
+              </button>
+            </Show>
           </div>
         </div>
-        {cachedHtml() ? (
+        {diffWasTruncated ? (
+          <pre class="tool-call-diff-fallback">{renderedDiffText}</pre>
+        ) : cachedHtml() ? (
           <CachedDiffMarkup html={cachedHtml()!} onRendered={handleDiffRendered} />
         ) : (
-          <Suspense fallback={<pre class="tool-call-diff-fallback">{payload.diffText}</pre>}>
+          <Suspense fallback={<pre class="tool-call-diff-fallback">{renderedDiffText}</pre>}>
             <LazyToolCallDiffViewer
-              diffText={payload.diffText}
+              diffText={renderedDiffText}
               filePath={payload.filePath}
               theme={themeKey}
               mode={currentMode()}
diff --git a/packages/ui/src/components/tool-call/permission-block.test.ts b/packages/ui/src/components/tool-call/permission-block.test.ts
new file mode 100644
index 000000000..73655ceeb
--- /dev/null
+++ b/packages/ui/src/components/tool-call/permission-block.test.ts
@@ -0,0 +1,11 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { getPermissionDiffPayload, isPermissionApprovalBlocked } from "./permission-block.tsx"
+
+test("requires full access before approving a truncated permission diff", () => {
+  const payload = { diffText: "x".repeat(10_001) }
+  assert.equal(isPermissionApprovalBlocked(payload, false), true)
+  assert.equal(isPermissionApprovalBlocked(payload, true), false)
+  assert.equal(isPermissionApprovalBlocked({ diffText: "small" }, false), false)
+  assert.deepEqual(getPermissionDiffPayload({ metadata: { diff: payload.diffText, path: "/file" } } as any), { diffText: payload.diffText, filePath: "/file" })
+})
diff --git a/packages/ui/src/components/tool-call/permission-block.tsx b/packages/ui/src/components/tool-call/permission-block.tsx
index 129447f84..0787b835f 100644
--- a/packages/ui/src/components/tool-call/permission-block.tsx
+++ b/packages/ui/src/components/tool-call/permission-block.tsx
@@ -6,9 +6,22 @@ import { useI18n } from "../../lib/i18n"
 import { PERMISSION_REJECT_REASON_MAX_LENGTH } from "./permission-constants"
 import type { DiffPayload, DiffRenderOptions } from "./types"
 import { getRelativePath } from "./utils"
+import { shouldRenderDiffPayloadAsPlainText } from "./utils"
 
 type PermissionResponse = "once" | "always" | "reject"
 
+export function isPermissionApprovalBlocked(payload: DiffPayload | null, fullDiffReviewed: boolean): boolean {
+  return Boolean(payload && shouldRenderDiffPayloadAsPlainText(payload) && !fullDiffReviewed)
+}
+
+export function getPermissionDiffPayload(permission: PermissionRequest | undefined): DiffPayload | null {
+  if (!permission) return null
+  const metadata = (permission.metadata ?? {}) as Record<string, unknown>
+  const diffText = typeof metadata.diff === "string" ? metadata.diff : null
+  const filePath = typeof metadata.filePath === "string" ? metadata.filePath : typeof metadata.path === "string" ? metadata.path : undefined
+  return diffText?.trim() ? { diffText, filePath } : null
+}
+
 export type PermissionToolBlockProps = {
   permission: Accessor<PermissionRequest | undefined>
   active: Accessor<boolean>
@@ -17,11 +30,13 @@ export type PermissionToolBlockProps = {
   onRespond: (permission: PermissionRequest, sessionId: string, response: PermissionResponse, message?: string) => void | Promise<void>
   renderDiff: (payload: DiffPayload, options?: DiffRenderOptions) => JSXElement | null
   fallbackSessionId: Accessor<string>
+  onApprovalBlockedChange?: (blocked: boolean) => void
 }
 
 export function PermissionToolBlock(props: PermissionToolBlockProps) {
   const { t } = useI18n()
   const [rejectReason, setRejectReason] = createSignal("")
+  const [fullDiffReviewed, setFullDiffReviewed] = createSignal(false)
   // Pending-request reconciliation replaces objects for the same request.
   // Only a new request should discard the user's explanation.
   const requestId = createMemo(() => props.permission()?.id)
@@ -29,25 +44,10 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
   createEffect(() => {
     requestId()
     setRejectReason("")
+    setFullDiffReviewed(false)
   })
 
-  const diffPayload = () => {
-    const permission = props.permission()
-    if (!permission) return null
-    const metadata = (permission.metadata ?? {}) as Record<string, unknown>
-    const diffValue = typeof metadata.diff === "string" ? (metadata.diff as string) : null
-    const diffPathRaw = (() => {
-      if (typeof metadata.filePath === "string") {
-        return metadata.filePath as string
-      }
-      if (typeof metadata.path === "string") {
-        return metadata.path as string
-      }
-      return undefined
-    })()
-    if (!diffValue || diffValue.trim().length === 0) return null
-    return { diffText: diffValue, filePath: diffPathRaw } satisfies DiffPayload
-  }
+  const diffPayload = () => getPermissionDiffPayload(props.permission())
 
   const respond = (response: PermissionResponse, message?: string) => {
     const permission = props.permission()
@@ -59,6 +59,11 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
   const confirmReject = () => {
     respond("reject", rejectReason().trim() || undefined)
   }
+  const approvalBlocked = () => {
+    const payload = diffPayload()
+    return isPermissionApprovalBlocked(payload, fullDiffReviewed())
+  }
+  createEffect(() => props.onApprovalBlockedChange?.(approvalBlocked()))
 
   return (
     <Show when={props.permission()}>
@@ -83,6 +88,7 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
                     label: payload().filePath
                       ? t("toolCall.permission.requestedDiff.withPath", { path: getRelativePath(payload().filePath || "") })
                       : t("toolCall.permission.requestedDiff.label"),
+                    onFullDiffAccess: () => setFullDiffReviewed(true),
                   })}
                 </div>
               )}
@@ -108,7 +114,7 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
                 <button
                   type="button"
                   class="tool-call-permission-button"
-                  disabled={props.submitting()}
+                  disabled={props.submitting() || approvalBlocked()}
                   onClick={() => respond("once")}
                 >
                   {t("toolCall.permission.actions.allowOnce")}
@@ -116,7 +122,7 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
                 <button
                   type="button"
                   class="tool-call-permission-button"
-                  disabled={props.submitting()}
+                  disabled={props.submitting() || approvalBlocked()}
                   onClick={() => respond("always")}
                 >
                   {t("toolCall.permission.actions.alwaysAllow")}
@@ -125,7 +131,7 @@ export function PermissionToolBlock(props: PermissionToolBlockProps) {
                   {t("toolCall.permission.actions.deny")}
                 </button>
               </div>
-              <Show when={props.active()}>
+              <Show when={props.active() && !approvalBlocked()}>
                 <div class="tool-call-permission-shortcuts">
                   <kbd class="kbd">Enter</kbd>
                   <span>{t("toolCall.permission.shortcuts.allowOnce")}</span>
diff --git a/packages/ui/src/components/tool-call/render-memory.test.ts b/packages/ui/src/components/tool-call/render-memory.test.ts
new file mode 100644
index 000000000..8af174b08
--- /dev/null
+++ b/packages/ui/src/components/tool-call/render-memory.test.ts
@@ -0,0 +1,32 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {
+  limitToolOutputForRender,
+  limitToolTitleForRender,
+  shouldRenderDiffAsPlainText,
+  TOOL_OUTPUT_RENDER_CHARACTER_LIMIT,
+  TOOL_TITLE_RENDER_CHARACTER_LIMIT,
+} from "./utils.ts"
+import { collectChildTaskSteps } from "./renderers/task-summary.ts"
+
+test("bounds representative tool output, title, and diff rendering", () => {
+  const tail = "COPY_TAIL"
+  const rendered = limitToolOutputForRender(`${"x".repeat(20_000)}${tail}`)
+  assert.equal(rendered.length, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT)
+  assert.equal(rendered.includes(tail), false)
+  assert.equal(limitToolTitleForRender("x".repeat(20_000)).length, TOOL_TITLE_RENDER_CHARACTER_LIMIT)
+  assert.equal(shouldRenderDiffAsPlainText("x".repeat(TOOL_OUTPUT_RENDER_CHARACTER_LIMIT + 1)), true)
+})
+
+test("collects complete child task steps across message windows", () => {
+  const messages = new Map([
+    ["first", { partIds: ["tool-1", "text"], parts: { "tool-1": { data: { id: "tool-1", type: "tool" } }, text: { data: { id: "text", type: "text" } } } }],
+    ["second", { partIds: ["tool-2"], parts: { "tool-2": { data: { id: "tool-2", type: "tool" } } } }],
+  ])
+
+  assert.deepEqual(collectChildTaskSteps(["first", "second"], (id) => messages.get(id)), [
+    { id: "tool-1", type: "tool" },
+    { id: "tool-2", type: "tool" },
+  ])
+})
diff --git a/packages/ui/src/components/tool-call/renderer-copy.test.ts b/packages/ui/src/components/tool-call/renderer-copy.test.ts
new file mode 100644
index 000000000..1504ec285
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderer-copy.test.ts
@@ -0,0 +1,16 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { bashRenderer } from "./renderers/bash.tsx"
+
+test("resolves complete tool output only through lazy copy", () => {
+  const full = `${"x".repeat(10_000)}COPY_TAIL`
+  const chrome = bashRenderer.getOutputChrome?.({
+    toolName: () => "bash",
+    t: (key: string) => key,
+    toolState: () => ({ status: "completed", input: { command: "echo" }, metadata: {}, output: full }),
+  } as any)
+
+  assert.equal(chrome?.copyText, undefined)
+  assert.equal(chrome?.getCopyText?.()?.endsWith(full), true)
+})
diff --git a/packages/ui/src/components/tool-call/renderers/apply-patch-data.ts b/packages/ui/src/components/tool-call/renderers/apply-patch-data.ts
new file mode 100644
index 000000000..13637922f
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderers/apply-patch-data.ts
@@ -0,0 +1,140 @@
+export type ApplyPatchFile = {
+  filePath?: string
+  relativePath?: string
+  type?: string
+  diff?: string
+  patch?: string
+}
+
+export const APPLY_PATCH_FILE_RENDER_LIMIT = 20
+const APPLY_PATCH_SCAN_LIMIT = 10_000
+
+export function getApplyPatchPathLabel(path: string, limit = 384): string {
+  const tail = path.slice(-(limit + 1)).replace(/\\/g, "/")
+  const separator = tail.lastIndexOf("/")
+  const label = separator >= 0 ? tail.slice(separator + 1) : tail
+  return label.length <= limit ? label : `...${label.slice(-(limit - 3))}`
+}
+
+export function* getApplyPatchDiagnosticPaths(diagnostics: Record<string, unknown>): Generator<string> {
+  for (const path in diagnostics) if (Object.prototype.hasOwnProperty.call(diagnostics, path)) yield path
+}
+
+function getApplyPatchDiff(file: ApplyPatchFile): string {
+  return typeof file.diff === "string" ? file.diff : typeof file.patch === "string" ? file.patch : ""
+}
+
+function probeApplyPatchCopyText(file: ApplyPatchFile, limit: number) {
+  const diff = getApplyPatchDiff(file)
+  const prefix = diff.slice(0, Math.max(0, limit))
+  return { hasContent: /\S/.test(prefix), scanned: prefix.length, truncated: prefix.length < diff.length }
+}
+
+export function hasApplyPatchCopyText(files: ApplyPatchFile[], scanLimit = APPLY_PATCH_SCAN_LIMIT): boolean {
+  let characters = 0
+  let index = 0
+  for (; index < files.length && index < scanLimit; index += 1) {
+    const probe = probeApplyPatchCopyText(files[index], scanLimit - characters)
+    if (probe.hasContent || probe.truncated) return true
+    characters += probe.scanned
+  }
+  return index < files.length
+}
+
+export function getApplyPatchCopyText(files: ApplyPatchFile[], limit = Number.POSITIVE_INFINITY): string {
+  const diffs: string[] = []
+  let characters = 0
+  for (const file of files) {
+    const remaining = limit - characters
+    if (remaining <= 0) break
+    const diff = getApplyPatchDiff(file)
+    const copyText = diff.slice(0, remaining)
+    if (!copyText.trim()) {
+      if (copyText.length < diff.length) break
+      continue
+    }
+    diffs.push(copyText)
+    characters += Math.min(diff.length, remaining)
+    if (diff.length > remaining) break
+  }
+  return diffs.join("\n")
+}
+
+export function getApplyPatchCopyOutput(files: ApplyPatchFile[], fallback: unknown): string | null {
+  return getApplyPatchCopyText(files) || (typeof fallback === "string" && fallback.length > 0 ? fallback : null)
+}
+
+export function getApplyPatchCopyAccess(files: ApplyPatchFile[], fallback: unknown) {
+  if (hasApplyPatchCopyText(files)) {
+    return { language: "diff" as const, getCopyText: () => getApplyPatchCopyOutput(files, fallback), hasCopyText: true as const }
+  }
+  if (typeof fallback !== "string" || fallback.length === 0) return undefined
+  return { language: "text" as const, getCopyText: () => fallback, hasCopyText: true as const }
+}
+
+export function getApplyPatchRenderData(files: ApplyPatchFile[], fileLimit: number, characterLimit: number, sourceTruncated = false) {
+  const rendered: Array<{ file: ApplyPatchFile; diffText: string }> = []
+  let characters = 0
+  let scannedCharacters = 0
+  let truncated = sourceTruncated
+  for (const file of files) {
+    if (rendered.length >= fileLimit || characters >= characterLimit) {
+      truncated = true
+      break
+    }
+    const remaining = characterLimit - characters
+    const fullDiff = getApplyPatchDiff(file)
+    const probe = probeApplyPatchCopyText(file, Math.min(APPLY_PATCH_SCAN_LIMIT - scannedCharacters, remaining))
+    scannedCharacters += probe.scanned
+    const firstContent = probe.hasContent ? fullDiff.slice(0, probe.scanned).search(/\S/) : -1
+    const diffText = firstContent >= 0 ? fullDiff.slice(firstContent, firstContent + remaining) : ""
+    rendered.push({ file, diffText })
+    characters += diffText.length
+    if (probe.truncated || (firstContent >= 0 && fullDiff.length - firstContent > remaining)) truncated = true
+  }
+  return { rendered, truncated }
+}
+
+export function getApplyPatchFilesForRender(files: ApplyPatchFile[], diagnosticPaths: Iterable<string>, limit = APPLY_PATCH_FILE_RENDER_LIMIT) {
+  const normalize = (path: string) => path.replace(/\\/g, "/")
+  const matchesPath = (left: string, right: string) => left === right || left.endsWith(`/${right}`) || right.endsWith(`/${left}`)
+  const paths: Array<{ raw: string; normalized: string }> = []
+  let diagnosticPathsTruncated = false
+  for (const path of diagnosticPaths) {
+    if (paths.length >= limit) {
+      diagnosticPathsTruncated = true
+      break
+    }
+    paths.push({ raw: path, normalized: normalize(path) })
+  }
+  const rendered: ApplyPatchFile[] = []
+  const knownPaths: string[] = []
+  let scannedFiles = 0
+  let scannedCharacters = 0
+  for (let fileIndex = 0; fileIndex < files.length && rendered.length < limit; fileIndex += 1) {
+    const file = files[fileIndex]
+    scannedFiles += 1
+    const normalizedFilePaths = [file.filePath, file.relativePath]
+      .filter((path): path is string => typeof path === "string")
+      .map(normalize)
+    const matchesDiagnostic = normalizedFilePaths.some((path) => paths.some((diagnostic) => matchesPath(path, diagnostic.normalized)))
+    const probe = probeApplyPatchCopyText(file, APPLY_PATCH_SCAN_LIMIT - scannedCharacters)
+    scannedCharacters += probe.scanned
+    if (probe.hasContent || probe.truncated || matchesDiagnostic) {
+      rendered.push(file)
+      knownPaths.push(...normalizedFilePaths)
+    }
+    if (scannedFiles >= 10_000) break
+  }
+  for (const path of paths) {
+    if (rendered.length >= limit) break
+    if (!knownPaths.some((knownPath) => matchesPath(knownPath, path.normalized))) {
+      rendered.push({ filePath: path.raw })
+      knownPaths.push(path.normalized)
+    }
+  }
+  return {
+    files: rendered,
+    truncated: scannedFiles < files.length || diagnosticPathsTruncated,
+  }
+}
diff --git a/packages/ui/src/components/tool-call/renderers/apply-patch.tsx b/packages/ui/src/components/tool-call/renderers/apply-patch.tsx
index 65b2bd111..bdf041fec 100644
--- a/packages/ui/src/components/tool-call/renderers/apply-patch.tsx
+++ b/packages/ui/src/components/tool-call/renderers/apply-patch.tsx
@@ -1,16 +1,10 @@
 import { For, Show, createMemo } from "solid-js"
 import type { ToolRenderer } from "../types"
-import { getRelativePath, getToolName, isToolStateCompleted, readToolStatePayload } from "../utils"
-import { buildDiagnosticEntries, type DiagnosticEntry, type DiagnosticsMap } from "../diagnostics"
+import { getToolName, isToolStateCompleted, limitToolOutputForRender, limitToolTitleForRender, readToolStatePayload, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT } from "../utils"
+import { buildDiagnosticView, hasDiagnosticMessages, type DiagnosticEntry, type DiagnosticsMap } from "../diagnostics"
+import { DiagnosticsPayloadAccess } from "../diagnostics-section"
 import { getApplyPatchToolSearchText } from "../search-text"
-
-type ApplyPatchFile = {
-  filePath?: string
-  relativePath?: string
-  type?: string
-  diff?: string
-  patch?: string
-}
+import { APPLY_PATCH_FILE_RENDER_LIMIT, getApplyPatchCopyAccess, getApplyPatchCopyText, getApplyPatchDiagnosticPaths, getApplyPatchFilesForRender, getApplyPatchPathLabel, getApplyPatchRenderData, hasApplyPatchCopyText, type ApplyPatchFile } from "./apply-patch-data"
 
 function DiagnosticsInline(props: { entries: DiagnosticEntry[]; label: string; t: (key: string, params?: Record<string, unknown>) => string }) {
   return (
@@ -68,62 +62,108 @@ export const applyPatchRenderer: ToolRenderer = {
 
     const payload = readToolStatePayload(state)
     const files = Array.isArray((payload.metadata as any).files) ? ((payload.metadata as any).files as ApplyPatchFile[]) : []
-    const diffs = files
-      .map((file) => (typeof file.diff === "string" ? file.diff : typeof file.patch === "string" ? file.patch : ""))
-      .filter((diff) => diff.trim().length > 0)
-    if (diffs.length > 0) {
-      return { language: "diff", copyText: diffs.join("\n"), suppressInnerHeader: false }
-    }
-
-    const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
-    if (!fallback) return undefined
-    return { language: "text", copyText: fallback, wrapToggle: true, suppressInnerHeader: true }
+    const fallback = isToolStateCompleted(state) && typeof state.output === "string" && state.output.length > 0 ? state.output : null
+    const access = getApplyPatchCopyAccess(files, fallback)
+    if (!access) return undefined
+    return access.language === "diff"
+      ? { ...access, suppressInnerHeader: false }
+      : { ...access, wrapToggle: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, renderDiff, renderMarkdown, t }) {
     const state = toolState()
     if (!state || state.status === "pending") return null
 
     const payload = readToolStatePayload(state)
-    const files = createMemo(() => {
-      const list = (payload.metadata as any).files
-      return Array.isArray(list) ? (list as ApplyPatchFile[]) : []
-    })
     const diagnosticsMap = createMemo(() => {
       const value = (payload.metadata as any).diagnostics
       return value && typeof value === "object" ? (value as DiagnosticsMap) : {}
     })
+    const allFiles = createMemo(() => {
+      const list = (payload.metadata as any).files
+      return getApplyPatchFilesForRender(Array.isArray(list) ? list as ApplyPatchFile[] : [], getApplyPatchDiagnosticPaths(diagnosticsMap()))
+    })
+    const renderData = createMemo(() => getApplyPatchRenderData(allFiles().files, APPLY_PATCH_FILE_RENDER_LIMIT, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT, allFiles().truncated))
+    const files = createMemo(() => renderData().rendered)
+    const fallback = createMemo(() => {
+      if (!isToolStateCompleted(state) || hasApplyPatchCopyText(files().map(({ file }) => file))) return null
+      return typeof state.output === "string" && state.output.length > 0 ? state.output : null
+    })
+    const diagnosticViews = createMemo(() => {
+      let remaining = 100
+      return files().map(({ file }) => {
+        const view = buildDiagnosticView(diagnosticsMap(), [file.filePath, file.relativePath])
+        const entries = view.entries.slice(0, remaining)
+        remaining -= entries.length
+        return { ...view, entries, truncated: view.truncated || entries.length < view.entries.length }
+      })
+    })
+    const diagnosticsTruncated = createMemo(() => {
+      const views = diagnosticViews()
+      const renderedKeys = new Set(views.map((view) => view.key).filter(Boolean))
+      if (views.some((view) => view.truncated)) return true
+      let scanned = 0
+      let scannedKeys = 0
+      for (const key in diagnosticsMap()) {
+        if (!Object.prototype.hasOwnProperty.call(diagnosticsMap(), key)) continue
+        scannedKeys += 1
+        if (scannedKeys > 10_000) return true
+        const list = diagnosticsMap()[key]
+        if (!renderedKeys.has(key) && Array.isArray(list)) {
+          const remaining = 10_000 - scanned
+          if (remaining <= 0) return true
+          for (let index = 0; index < list.length && index < remaining; index += 1) {
+            scanned += 1
+            if (typeof list[index]?.message === "string") return true
+          }
+          if (list.length > remaining) return true
+        }
+      }
+      return false
+    })
 
-    if (files().length === 0) {
-      const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
-      if (!fallback) return null
-      return renderMarkdown({ content: fallback, size: "large", disableHighlight: state.status === "running" })
-    }
+    if (files().length === 0 && !fallback() && !renderData().truncated) return null
 
     return (
       <div class="tool-call-apply-patch">
+        <Show when={fallback()}>
+          {(content) => renderMarkdown({ content: limitToolOutputForRender(content()), size: "large", disableHighlight: state.status === "running" })}
+        </Show>
         <For each={files()}>
-          {(file, index) => {
+          {(renderedFile, index) => {
+            const file = renderedFile.file
             const labelBase = file.relativePath || file.filePath || t("toolCall.applyPatch.fileFallback", { number: index() + 1 })
-            const diffText = typeof file.diff === "string" ? file.diff : typeof file.patch === "string" ? file.patch : ""
+            const label = getApplyPatchPathLabel(labelBase)
+            const fullDiff = typeof file.diff === "string" ? file.diff : typeof file.patch === "string" ? file.patch : ""
+            const diffText = renderedFile.diffText
             const filePath = typeof file.filePath === "string" ? file.filePath : file.relativePath
-            const entries = createMemo(() => buildDiagnosticEntries(diagnosticsMap(), [file.filePath, file.relativePath]))
+            const entries = createMemo(() => diagnosticViews()[index()]?.entries ?? [])
 
             return (
               <div class="tool-call-apply-patch-file">
                 <Show when={diffText.trim().length > 0}>
                   {renderDiff(
-                    { diffText, filePath },
+                    { diffText, copyText: fullDiff, filePath },
                     {
-                      label: t("toolCall.diff.label.withPath", { path: getRelativePath(labelBase) }),
-                      cacheKey: `apply_patch:${labelBase}:${index()}`,
+                      label: limitToolTitleForRender(t("toolCall.diff.label.withPath", { path: label })),
+                      cacheKey: `apply_patch:${index()}`,
                     },
                   )}
                 </Show>
-                <DiagnosticsInline entries={entries()} label={labelBase} t={t} />
+                <DiagnosticsInline entries={entries()} label={label} t={t} />
               </div>
             )
           }}
         </For>
+        <Show when={renderData().truncated}>
+          <div class="tool-call-diagnostic-message" role="status">{t("toolCall.output.truncated")}</div>
+        </Show>
+        <Show when={hasDiagnosticMessages(diagnosticsMap())}>
+          <div class="tool-call-diagnostics-wrapper">
+            <div class="tool-call-diagnostics">
+              <DiagnosticsPayloadAccess diagnostics={diagnosticsMap()} truncated={diagnosticsTruncated()} t={t} />
+            </div>
+          </div>
+        </Show>
       </div>
     )
   },
diff --git a/packages/ui/src/components/tool-call/renderers/bash.tsx b/packages/ui/src/components/tool-call/renderers/bash.tsx
index 2123760f7..1d2a815a6 100644
--- a/packages/ui/src/components/tool-call/renderers/bash.tsx
+++ b/packages/ui/src/components/tool-call/renderers/bash.tsx
@@ -1,7 +1,7 @@
 import { Show, createEffect, createMemo, onCleanup, type Accessor } from "solid-js"
 import type { ToolState } from "../../../types/tool-state"
 import type { ToolRenderer, ToolScrollHelpers } from "../types"
-import { ensureMarkdownContent, formatUnknown, getToolName, isToolStateCompleted, isToolStateError, isToolStateRunning, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, formatUnknownForCopy, formatUnknownForRender, getToolName, isToolStateCompleted, isToolStateError, isToolStateRunning, limitToolOutputForRender, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { createStableAnsiStreamUpdater } from "../ansi-render"
 import { ansiToHtml, hasAnsi } from "../../../lib/ansi"
@@ -99,7 +99,7 @@ function getBashCopyText(state: ToolState | undefined): string {
 
   const { input, metadata } = readToolStatePayload(state)
   const command = typeof input.command === "string" && input.command.length > 0 ? `$ ${input.command}` : ""
-  const outputResult = formatUnknown(
+  const outputResult = formatUnknownForCopy(
     isToolStateCompleted(state)
       ? state.output
       : (isToolStateRunning(state) || isToolStateError(state)) && metadata.output
@@ -122,8 +122,8 @@ function BashToolBody(props: {
     if (!current || current.status === "pending") return ""
 
     const { input, metadata } = readToolStatePayload(current)
-    const command = typeof input.command === "string" && input.command.length > 0 ? `$ ${input.command}` : ""
-    const outputResult = formatUnknown(
+    const command = typeof input.command === "string" && input.command.length > 0 ? limitToolOutputForRender(`$ ${input.command}`) : ""
+    const outputResult = formatUnknownForRender(
       isToolStateCompleted(current)
         ? current.output
         : (isToolStateRunning(current) || isToolStateError(current)) && metadata.output
@@ -132,10 +132,11 @@ function BashToolBody(props: {
     )
     return [command, outputResult?.text].filter(Boolean).join("\n")
   })
+  const renderedContent = createMemo(() => limitToolOutputForRender(joinedContent()))
 
   const finalMarkdown = createMemo(() => {
     const current = state()
-    const content = joinedContent()
+    const content = renderedContent()
     if (!current || current.status === "pending" || current.status === "running" || content.length === 0) {
       return null
     }
@@ -147,7 +148,7 @@ function BashToolBody(props: {
 
   const finalAnsiHtml = createMemo(() => {
     const current = state()
-    const content = joinedContent()
+    const content = renderedContent()
     if (!current || current.status === "pending" || current.status === "running" || content.length === 0) {
       return null
     }
@@ -169,7 +170,7 @@ function BashToolBody(props: {
           </Show>
         }
       >
-        <RunningBashOutput content={joinedContent} scrollHelpers={props.scrollHelpers} onContentRendered={props.onContentRendered} />
+        <RunningBashOutput content={renderedContent} scrollHelpers={props.scrollHelpers} onContentRendered={props.onContentRendered} />
       </Show>
     </Show>
   )
@@ -196,9 +197,14 @@ export const bashRenderer: ToolRenderer = {
     return `${baseTitle} · ${tGlobal("toolCall.renderer.bash.title.timeout", { timeout: timeoutLabel })}`
   },
   getOutputChrome({ toolState }) {
-    const text = getBashCopyText(toolState())
-    if (!text) return undefined
-    return { language: "bash", copyText: text, wrapToggle: true, suppressInnerHeader: true }
+    const state = toolState()
+    if (!state || state.status === "pending") return undefined
+    const { input, metadata } = readToolStatePayload(state)
+    const output = isToolStateCompleted(state) ? state.output : (isToolStateRunning(state) || isToolStateError(state)) ? metadata.output : undefined
+    const hasCopyText = (typeof input.command === "string" && input.command.length > 0)
+      || (output !== undefined && output !== null && output !== "" && (!Array.isArray(output) || output.length > 0))
+    if (!hasCopyText) return undefined
+    return { language: "bash", getCopyText: () => getBashCopyText(state), hasCopyText: true, wrapToggle: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, renderMarkdown, scrollHelpers, onContentRendered }) {
     return <BashToolBody toolState={toolState} renderMarkdown={renderMarkdown as any} scrollHelpers={scrollHelpers} onContentRendered={onContentRendered} />
diff --git a/packages/ui/src/components/tool-call/renderers/default.tsx b/packages/ui/src/components/tool-call/renderers/default.tsx
index f19682675..78aaad939 100644
--- a/packages/ui/src/components/tool-call/renderers/default.tsx
+++ b/packages/ui/src/components/tool-call/renderers/default.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, formatUnknown, isToolStateCompleted, isToolStateError, isToolStateRunning, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, formatUnknownForCopy, formatUnknownForRender, isToolStateCompleted, isToolStateError, isToolStateRunning, readToolStatePayload } from "../utils"
 import { getDefaultToolSearchText } from "../search-text"
 
 export const defaultRenderer: ToolRenderer = {
@@ -16,12 +16,13 @@ export const defaultRenderer: ToolRenderer = {
         ? metadata.output
         : metadata.diff ?? metadata.preview ?? input.content
 
-    const result = formatUnknown(primaryOutput)
-    if (!result) return undefined
+    if (primaryOutput === undefined || primaryOutput === null || primaryOutput === "" || (Array.isArray(primaryOutput) && primaryOutput.length === 0)) return undefined
+    const result = formatUnknownForRender(primaryOutput)
 
     return {
-      language: result.language ?? "text",
-      copyText: result.text,
+      language: result?.language ?? "text",
+      getCopyText: () => formatUnknownForCopy(primaryOutput)?.text ?? null,
+      hasCopyText: true,
       wrapToggle: true,
       suppressInnerHeader: true,
     }
@@ -37,7 +38,7 @@ export const defaultRenderer: ToolRenderer = {
         ? metadata.output
         : metadata.diff ?? metadata.preview ?? input.content
 
-    const result = formatUnknown(primaryOutput)
+    const result = formatUnknownForRender(primaryOutput)
     if (!result) return null
 
     const content = ensureMarkdownContent(result.text, result.language, true)
diff --git a/packages/ui/src/components/tool-call/renderers/edit.test.ts b/packages/ui/src/components/tool-call/renderers/edit.test.ts
index 47d7cda22..8471b0d8a 100644
--- a/packages/ui/src/components/tool-call/renderers/edit.test.ts
+++ b/packages/ui/src/components/tool-call/renderers/edit.test.ts
@@ -38,7 +38,9 @@ it("renders the OpenCode 2.x edit diff and titles by input.path", () => {
   const { context, rendered } = createContext("src/example.ts")
 
   assert.equal(editRenderer.getTitle?.(context), "Edit example.ts")
-  assert.equal(editRenderer.getOutputChrome?.(context)?.copyText, patch)
+  const chrome = editRenderer.getOutputChrome?.(context)
+  assert.equal(chrome?.copyText, undefined)
+  assert.equal(chrome?.getCopyText?.(), patch)
   assert.equal(editRenderer.renderBody(context), "diff")
   assert.deepEqual(rendered(), { diffText: patch, filePath: "src/example.ts" })
 })
diff --git a/packages/ui/src/components/tool-call/renderers/edit.tsx b/packages/ui/src/components/tool-call/renderers/edit.tsx
index 0bffd5d7b..5f0e8a615 100644
--- a/packages/ui/src/components/tool-call/renderers/edit.tsx
+++ b/packages/ui/src/components/tool-call/renderers/edit.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, extractDiffPayload, getRelativePath, getToolName, isToolStateCompleted, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, extractDiffPayload, getRelativePath, getToolName, isToolStateCompleted, limitToolOutputForRender, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { getDiffToolSearchText } from "../search-text"
 
@@ -22,7 +22,7 @@ export const editRenderer: ToolRenderer = {
 
     const diffPayload = extractDiffPayload(toolName(), state)
     if (diffPayload) {
-      return { language: "diff", copyText: diffPayload.diffText, suppressInnerHeader: false }
+      return { language: "diff", getCopyText: () => diffPayload.diffText, suppressInnerHeader: false }
     }
 
     const { metadata } = readToolStatePayload(state)
@@ -30,7 +30,7 @@ export const editRenderer: ToolRenderer = {
     const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
     const copyText = diffText || fallback
     if (!copyText) return undefined
-    return { language: "diff", copyText, wrapToggle: true, suppressInnerHeader: true }
+    return { language: "diff", getCopyText: () => copyText, wrapToggle: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, toolName, renderDiff, renderMarkdown }) {
     const state = toolState()
@@ -44,7 +44,8 @@ export const editRenderer: ToolRenderer = {
     const { metadata } = readToolStatePayload(state)
     const diffText = typeof metadata.diff === "string" ? metadata.diff : null
     const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
-    const content = ensureMarkdownContent(diffText || fallback, "diff", true)
+    const value = diffText || fallback
+    const content = ensureMarkdownContent(value ? limitToolOutputForRender(value) : value, "diff", true)
     if (!content) return null
 
     return renderMarkdown({ content, size: "large", disableHighlight: state.status === "running" })
diff --git a/packages/ui/src/components/tool-call/renderers/patch.tsx b/packages/ui/src/components/tool-call/renderers/patch.tsx
index 356bba5a6..cd3a42fe6 100644
--- a/packages/ui/src/components/tool-call/renderers/patch.tsx
+++ b/packages/ui/src/components/tool-call/renderers/patch.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, extractDiffPayload, getRelativePath, getToolName, isToolStateCompleted, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, extractDiffPayload, getRelativePath, getToolName, isToolStateCompleted, limitToolOutputForRender, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { getDiffToolSearchText } from "../search-text"
 
@@ -21,7 +21,7 @@ export const patchRenderer: ToolRenderer = {
 
     const diffPayload = extractDiffPayload(toolName(), state)
     if (diffPayload) {
-      return { language: "diff", copyText: diffPayload.diffText, suppressInnerHeader: false }
+      return { language: "diff", getCopyText: () => diffPayload.diffText, suppressInnerHeader: false }
     }
 
     const { metadata } = readToolStatePayload(state)
@@ -29,7 +29,7 @@ export const patchRenderer: ToolRenderer = {
     const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
     const copyText = diffText || fallback
     if (!copyText) return undefined
-    return { language: "diff", copyText, wrapToggle: true, suppressInnerHeader: true }
+    return { language: "diff", getCopyText: () => copyText, wrapToggle: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, toolName, renderDiff, renderMarkdown }) {
     const state = toolState()
@@ -43,7 +43,8 @@ export const patchRenderer: ToolRenderer = {
     const { metadata } = readToolStatePayload(state)
     const diffText = typeof metadata.diff === "string" ? metadata.diff : null
     const fallback = isToolStateCompleted(state) && typeof state.output === "string" ? state.output : null
-    const content = ensureMarkdownContent(diffText || fallback, "diff", true)
+    const value = diffText || fallback
+    const content = ensureMarkdownContent(value ? limitToolOutputForRender(value) : value, "diff", true)
     if (!content) return null
 
     return renderMarkdown({ content, size: "large", disableHighlight: state.status === "running" })
diff --git a/packages/ui/src/components/tool-call/renderers/read.test.ts b/packages/ui/src/components/tool-call/renderers/read.test.ts
index d718976c9..c551ba6cc 100644
--- a/packages/ui/src/components/tool-call/renderers/read.test.ts
+++ b/packages/ui/src/components/tool-call/renderers/read.test.ts
@@ -15,6 +15,8 @@ it("renders read output from the V2 tool state", () => {
     renderMarkdown: ({ content }: { content: string }) => content,
   } as unknown as ToolRendererContext
 
-  assert.equal(readRenderer.getOutputChrome?.(context)?.copyText, "const value = 1")
+  const chrome = readRenderer.getOutputChrome?.(context)
+  assert.equal(chrome?.copyText, undefined)
+  assert.equal(chrome?.getCopyText?.(), "const value = 1")
   assert.match(String(readRenderer.renderBody(context)), /const value = 1/)
 })
diff --git a/packages/ui/src/components/tool-call/renderers/read.tsx b/packages/ui/src/components/tool-call/renderers/read.tsx
index e8de01d59..2526dacc9 100644
--- a/packages/ui/src/components/tool-call/renderers/read.tsx
+++ b/packages/ui/src/components/tool-call/renderers/read.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, getRelativePath, getToolName, inferLanguageFromPath, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, getRelativePath, getToolName, inferLanguageFromPath, limitToolOutputForRender, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { getReadToolSearchText } from "../search-text"
 
@@ -48,7 +48,7 @@ export const readRenderer: ToolRenderer = {
     const preview = typeof output === "string" ? output : null
     if (!preview) return undefined
     const language = inferLanguageFromPath(getReadPath(input)) ?? "text"
-    return { language, copyText: preview, wrapToggle: true, suppressInnerHeader: true }
+    return { language, getCopyText: () => preview, wrapToggle: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, renderMarkdown }) {
     const state = toolState()
@@ -56,7 +56,7 @@ export const readRenderer: ToolRenderer = {
     const { output, input } = readToolStatePayload(state)
     const preview = typeof output === "string" ? output : null
     const language = inferLanguageFromPath(getReadPath(input))
-    const content = ensureMarkdownContent(preview, language, true)
+    const content = ensureMarkdownContent(preview ? limitToolOutputForRender(preview) : preview, language, true)
     if (!content) return null
     return renderMarkdown({ content, disableHighlight: state.status === "running" })
   },
diff --git a/packages/ui/src/components/tool-call/renderers/skill.tsx b/packages/ui/src/components/tool-call/renderers/skill.tsx
index adaa2cc66..ee783e0f1 100644
--- a/packages/ui/src/components/tool-call/renderers/skill.tsx
+++ b/packages/ui/src/components/tool-call/renderers/skill.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, formatUnknown, getToolName } from "../utils"
+import { ensureMarkdownContent, formatUnknownForCopy, formatUnknownForRender, getToolName } from "../utils"
 import { getDefaultToolSearchText } from "../search-text"
 
 export const skillRenderer: ToolRenderer = {
@@ -12,15 +12,14 @@ export const skillRenderer: ToolRenderer = {
     const state = toolState()
     if (!state || state.status !== "completed") return undefined
 
-    const output = formatUnknown(state.output)?.text ?? null
-    if (!output) return undefined
-    return { copyText: output, suppressInnerHeader: true }
+    if (state.output === undefined || state.output === null || state.output === "" || (Array.isArray(state.output) && state.output.length === 0)) return undefined
+    return { getCopyText: () => formatUnknownForCopy(state.output)?.text ?? null, hasCopyText: true, suppressInnerHeader: true }
   },
   renderBody({ toolState, renderMarkdown }) {
     const state = toolState()
     if (!state || state.status !== "completed") return null
 
-    const output = formatUnknown(state.output)?.text ?? null
+    const output = formatUnknownForRender(state.output)?.text ?? null
     const content = ensureMarkdownContent(output, undefined, false)
     if (!content) return null
     return <div class="tool-call-skill-body">{renderMarkdown({ content })}</div>
diff --git a/packages/ui/src/components/tool-call/renderers/task-copy.test.ts b/packages/ui/src/components/tool-call/renderers/task-copy.test.ts
new file mode 100644
index 000000000..a10f597d2
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderers/task-copy.test.ts
@@ -0,0 +1,309 @@
+import assert from "node:assert/strict"
+import { describe, it } from "node:test"
+import { createRoot, createSignal } from "solid-js"
+import { MESSAGE_HISTORY_TRAVERSAL_PAGE_LIMIT } from "../../message-history-pagination"
+import { useTaskStepCopy } from "./task-copy"
+import { copyTextChunksToClipboard, copyToClipboard } from "../../../lib/clipboard"
+import { installClipboardFallbackDom } from "../../../lib/clipboard.test-fixture"
+
+function deferred() {
+  let resolve!: () => void
+  let reject!: (error: unknown) => void
+  const promise = new Promise<void>((done, fail) => { resolve = done; reject = fail })
+  return { promise, resolve, reject }
+}
+
+const tick = () => new Promise<void>(resolve => setImmediate(resolve))
+
+describe("task copy through the actual clipboard fallback chain", () => {
+  for (const pendingStrategy of ["write", "writeText"] as const) {
+    it(`does not overwrite a newer copy after cancelled ${pendingStrategy} rejects`, async () => {
+      const gate = deferred()
+      const writes: string[] = []
+      let strategyStarted = false
+      let execCalls = 0
+      const state = installClipboardFallbackDom(() => { execCalls++; writes.push("stale execCommand"); return true }, {
+        write: async () => {
+          if (pendingStrategy === "write") { strategyStarted = true; return gate.promise }
+          throw new Error("Try text clipboard")
+        },
+        writeText: async text => {
+          if (text === "NEW USER COPY") { writes.push(text); return }
+          strategyStarted = true
+          return gate.promise
+        },
+      })
+      const fixture = mount({ copy: copyTextChunksToClipboard })
+      try {
+        const oldCopy = fixture.copy()
+        await tick()
+        assert.equal(strategyStarted, true)
+        if (pendingStrategy === "write") fixture.setActive(false)
+        else fixture.dispose()
+        assert.equal(await copyToClipboard("NEW USER COPY"), true)
+        fixture.setActive(true)
+        gate.reject(new Error("Clipboard permission lost"))
+        await oldCopy
+        assert.deepEqual(writes, ["NEW USER COPY"])
+        assert.equal(execCalls, 0)
+      } finally { gate.resolve(); fixture.dispose(); state.restore() }
+    })
+  }
+
+  it("retains the complete output through both fallbacks while the owner is current", async () => {
+    const strategies: string[] = []
+    const state = installClipboardFallbackDom(() => { strategies.push("execCommand"); return true }, {
+      write: async () => { strategies.push("write"); throw new Error("Use text") },
+      writeText: async () => { strategies.push("writeText"); throw new Error("Use DOM") },
+    })
+    const fixture = mount({ copy: copyTextChunksToClipboard })
+    try {
+      await fixture.copy()
+      assert.deepEqual(strategies, ["write", "writeText", "execCommand"])
+      assert.deepEqual(JSON.parse(state.textArea.value), [{ type: "tool", output: "complete" }])
+      assert.equal(state.removed(), true)
+    } finally { fixture.dispose(); state.restore() }
+  })
+})
+
+function mount(overrides: Partial<Parameters<typeof useTaskStepCopy>[0]> = {}) {
+  const [active, setActive] = createSignal(true)
+  const [child, setChild] = createSignal("child-a")
+  const releases: number[] = []
+  const acquisitions: string[] = []
+  const clipboard: string[] = []
+  const loads: Array<{ kind: string; id: string; signal: AbortSignal }> = []
+  let dispose!: () => void
+  const copy = createRoot(done => {
+    dispose = done
+    return useTaskStepCopy({
+      childSessionId: child,
+      isActive: active,
+      beginTraversal: id => {
+        const index = acquisitions.length
+        acquisitions.push(id)
+        return () => { releases.push(index) }
+      },
+      getPageKey: () => "latest",
+      isLatest: () => true,
+      readSteps: () => [{ type: "tool", output: "complete" }],
+      copy: async chunks => { clipboard.push(chunks.join("")) },
+      ...overrides,
+      loadOldest: async (id, signal) => {
+        loads.push({ kind: "oldest", id, signal })
+        return overrides.loadOldest ? overrides.loadOldest(id, signal) : true
+      },
+      loadNewer: async (id, signal) => {
+        loads.push({ kind: "newer", id, signal })
+        return overrides.loadNewer ? overrides.loadNewer(id, signal) : true
+      },
+    })
+  })
+  return { ...copy, setActive, setChild, releases, acquisitions, clipboard, loads, dispose }
+}
+
+describe("full child task-step copy lifetime", () => {
+  it("copies lossless output across replaced pages, beyond the rendered step/title limits", async () => {
+    const pages = Array.from({ length: 3 }, (_, page) => Array.from({ length: 220 }, (_, index) => ({
+      type: "tool", id: `${page}:${index}`, tool: "shell",
+      state: { title: "長い title\n".repeat(500), output: `page ${page} step ${index}\n\u0000\"\\tail` },
+    })))
+    let resident: unknown[] = []
+    let page = 0
+    const fixture = mount({
+      loadOldest: async () => { page = 0; resident = pages[page]; return true },
+      loadNewer: async () => { resident = pages[++page]; return true },
+      getPageKey: () => String(page),
+      isLatest: () => page === pages.length - 1,
+      readSteps: () => resident,
+    })
+    try {
+      await fixture.copy()
+      assert.deepEqual(JSON.parse(fixture.clipboard[0]), pages.flat())
+      assert.equal(fixture.clipboard.length, 1)
+      assert.deepEqual(fixture.loads.map(load => load.kind), ["oldest", "newer", "newer"])
+      assert.ok(fixture.loads.every(load => load.signal === fixture.loads[0].signal))
+      assert.deepEqual(fixture.releases, [0])
+      assert.equal(fixture.pending(), false)
+    } finally { fixture.dispose() }
+  })
+
+  for (const failedPage of ["oldest", "newer"] as const) {
+    it(`does not visit an uncommitted ${failedPage} page or copy resident/partial data`, async () => {
+      let visits = 0
+      let residentIsLatest = failedPage === "oldest"
+      const fixture = mount({
+        loadOldest: async () => failedPage !== "oldest",
+        loadNewer: async () => { residentIsLatest = true; return false },
+        isLatest: () => residentIsLatest,
+        readSteps: () => { visits++; return [{ output: "resident tail is not the complete history" }] },
+      })
+      try {
+        await assert.rejects(fixture.copy(), /page was not committed/)
+        assert.equal(visits, failedPage === "oldest" ? 0 : 1)
+        assert.deepEqual(fixture.loads.map(load => load.kind), failedPage === "oldest" ? ["oldest"] : ["oldest", "newer"])
+        assert.deepEqual(fixture.clipboard, [])
+        assert.deepEqual(fixture.releases, [0])
+        assert.equal(fixture.pending(), false)
+      } finally { fixture.dispose() }
+    })
+  }
+
+  it("coalesces repeated copies and keeps the lifetime through the clipboard callback", async () => {
+    const gate = deferred(), clipboardGate = deferred()
+    let writes = 0
+    const fixture = mount({ loadOldest: () => gate.promise.then(() => true), copy: async () => { writes++; await clipboardGate.promise } })
+    try {
+      const first = fixture.copy()
+      assert.equal(fixture.copy(), first)
+      assert.equal(fixture.loads.length, 1)
+      gate.resolve()
+      await tick()
+      assert.equal(writes, 1)
+      assert.equal(fixture.pending(), true)
+      assert.equal(fixture.copy(), first)
+      clipboardGate.resolve()
+      await first
+      assert.deepEqual(fixture.releases, [0])
+      assert.equal(fixture.pending(), false)
+    } finally { gate.resolve(); clipboardGate.resolve(); fixture.dispose() }
+  })
+
+  it("aborts on deactivation and an old finally cannot release a returning view's copy", async () => {
+    const gates = [deferred(), deferred()]
+    let request = 0
+    const fixture = mount({ loadOldest: () => gates[request++].promise.then(() => true) })
+    try {
+      const old = fixture.copy()
+      fixture.setActive(false)
+      assert.equal(fixture.loads[0].signal.aborted, true)
+      assert.deepEqual(fixture.releases, [0], "release precedes cancelled loader settlement")
+      fixture.setActive(true)
+      const fresh = fixture.copy()
+      gates[0].resolve()
+      await old
+      assert.equal(fixture.pending(), true)
+      assert.equal(fixture.copy(), fresh)
+      assert.deepEqual(fixture.releases, [0])
+      assert.deepEqual(fixture.clipboard, [])
+      assert.equal(fixture.loads[1].signal.aborted, false)
+      gates[1].resolve()
+      await fresh
+      assert.equal(fixture.clipboard.length, 1)
+      assert.deepEqual(fixture.releases, [0, 1])
+    } finally { gates.forEach(gate => gate.resolve()); fixture.dispose() }
+  })
+
+  it("aborts child changes during newer-page loading and never resumes the old pagination", async () => {
+    const gate = deferred()
+    let page = 0
+    const fixture = mount({
+      getPageKey: () => String(page), isLatest: () => false,
+      loadNewer: async () => { await gate.promise; page++; return true },
+    })
+    try {
+      const copy = fixture.copy()
+      await tick()
+      assert.equal(fixture.loads.length, 2)
+      fixture.setChild("child-b")
+      assert.ok(fixture.loads.every(load => load.signal.aborted))
+      assert.deepEqual(fixture.releases, [0])
+      gate.resolve()
+      await copy
+      assert.equal(fixture.loads.length, 2)
+      assert.deepEqual(fixture.clipboard, [])
+    } finally { gate.resolve(); fixture.dispose() }
+  })
+
+  it("aborts on owner cleanup, suppresses abort rejection, and rejects later copy attempts", async () => {
+    const gate = deferred()
+    const fixture = mount({ loadOldest: () => gate.promise.then(() => true) })
+    const copy = fixture.copy()
+    fixture.dispose()
+    assert.equal(fixture.loads[0].signal.aborted, true)
+    assert.deepEqual(fixture.releases, [0])
+    gate.reject(new DOMException("Aborted", "AbortError"))
+    await copy
+    await fixture.copy()
+    assert.equal(fixture.loads.length, 1)
+    assert.deepEqual(fixture.clipboard, [])
+    assert.deepEqual(fixture.releases, [0])
+  })
+
+  it("cancels when the document becomes hidden, even while its session remains active", async () => {
+    class VisibilityDocument extends EventTarget { visibilityState = "visible" }
+    const visibility = new VisibilityDocument()
+    const original = Object.getOwnPropertyDescriptor(globalThis, "document")
+    Object.defineProperty(globalThis, "document", { configurable: true, value: visibility })
+    const gate = deferred()
+    const fixture = mount({ loadOldest: () => gate.promise.then(() => true) })
+    try {
+      const copy = fixture.copy()
+      visibility.visibilityState = "hidden"
+      visibility.dispatchEvent(new Event("visibilitychange"))
+      assert.equal(fixture.loads[0].signal.aborted, true)
+      assert.deepEqual(fixture.releases, [0])
+      await fixture.copy()
+      visibility.visibilityState = "visible"
+      gate.resolve()
+      await copy
+      assert.equal(fixture.loads.length, 1, "showing the window does not revive or restart an explicit copy")
+      assert.deepEqual(fixture.clipboard, [])
+    } finally {
+      gate.resolve()
+      fixture.dispose()
+      if (original) Object.defineProperty(globalThis, "document", original)
+      else Reflect.deleteProperty(globalThis, "document")
+    }
+  })
+
+  it("rechecks authority immediately before clipboard dispatch after the final page", async () => {
+    let active = true
+    const fixture = mount({
+      isActive: () => active,
+      readSteps: () => {
+        // The last visit is synchronous; the completion continuation is async.
+        // No reactive effect is available to save a missing final authority check.
+        queueMicrotask(() => { active = false })
+        return [{ output: "must not be copied" }]
+      },
+    })
+    try {
+      await fixture.copy()
+      assert.deepEqual(fixture.clipboard, [])
+      assert.deepEqual(fixture.releases, [0])
+    } finally { fixture.dispose() }
+  })
+
+  it("fails closed at the traversal budget rather than copying a partial history", async () => {
+    let page = 0
+    const fixture = mount({
+      getPageKey: () => String(page), isLatest: () => false,
+      loadNewer: async () => { page++; return true },
+    })
+    try {
+      await assert.rejects(fixture.copy(), /traversal page limit/)
+      assert.equal(page, MESSAGE_HISTORY_TRAVERSAL_PAGE_LIMIT)
+      assert.deepEqual(fixture.clipboard, [])
+      assert.deepEqual(fixture.releases, [0])
+      assert.equal(fixture.pending(), false)
+    } finally { fixture.dispose() }
+  })
+
+  it("releases failed loaders and clipboard callbacks so an explicit retry can succeed", async () => {
+    let failLoad = true, failCopy = true
+    const fixture = mount({
+      loadOldest: async () => { if (failLoad) throw new Error("load failed"); return true },
+      copy: async () => { if (failCopy) throw new Error("clipboard failed") },
+    })
+    try {
+      await assert.rejects(fixture.copy(), /load failed/)
+      failLoad = false
+      await assert.rejects(fixture.copy(), /clipboard failed/)
+      failCopy = false
+      await fixture.copy()
+      assert.deepEqual(fixture.releases, [0, 1, 2])
+      assert.equal(fixture.pending(), false)
+    } finally { fixture.dispose() }
+  })
+})
diff --git a/packages/ui/src/components/tool-call/renderers/task-copy.ts b/packages/ui/src/components/tool-call/renderers/task-copy.ts
new file mode 100644
index 000000000..ca27cf5bd
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderers/task-copy.ts
@@ -0,0 +1,108 @@
+import { createEffect, createSignal, onCleanup } from "solid-js"
+import type { ClipboardCopyOptions } from "../../../lib/clipboard"
+import { loadCompleteMessageHistory, MESSAGE_HISTORY_TRAVERSAL_PAGE_LIMIT } from "../../message-history-pagination"
+
+interface TaskStepCopyOptions {
+  childSessionId: () => string
+  isActive: () => boolean
+  beginTraversal: (sessionId: string) => () => void
+  getPageKey: (sessionId: string) => string
+  isLatest: (sessionId: string) => boolean
+  loadOldest: (sessionId: string, signal: AbortSignal) => Promise<boolean>
+  loadNewer: (sessionId: string, signal: AbortSignal) => Promise<boolean>
+  readSteps: (sessionId: string) => unknown[]
+  copy: (chunks: readonly string[], options: ClipboardCopyOptions) => Promise<unknown>
+}
+
+/** One explicit full-copy lifetime, independent of the bounded rendered step list. */
+export function useTaskStepCopy(options: TaskStepCopyOptions) {
+  const [pending, setPending] = createSignal(false)
+  const visibilityDocument = typeof document === "undefined" ? undefined : document
+  type Operation = { id: string; controller: AbortController; release?: () => void; promise?: Promise<void> }
+  let current: Operation | undefined
+  let disposed = false
+  const isActive = () => options.isActive() && visibilityDocument?.visibilityState !== "hidden"
+
+  function release(operation: Operation) {
+    const done = operation.release
+    operation.release = undefined
+    done?.()
+  }
+
+  function cancel() {
+    const operation = current
+    if (!operation) return
+    current = undefined
+    setPending(false)
+    // Release synchronously: a returning view can acquire a new traversal even
+    // when the cancelled loader has not settled. Its finally cannot release it.
+    operation.controller.abort()
+    release(operation)
+  }
+
+  createEffect(() => {
+    const id = options.childSessionId()
+    const active = options.isActive()
+    if (current && (!active || current.id !== id)) cancel()
+  })
+  const onVisibilityChange = () => { if (!isActive()) cancel() }
+  visibilityDocument?.addEventListener("visibilitychange", onVisibilityChange)
+  onCleanup(() => {
+    disposed = true
+    visibilityDocument?.removeEventListener("visibilitychange", onVisibilityChange)
+    cancel()
+  })
+
+  function copy(): Promise<void> {
+    if (disposed || !isActive()) return Promise.resolve()
+    const id = options.childSessionId()
+    if (!id) return Promise.resolve()
+    if (current?.id === id) return current.promise ?? Promise.resolve()
+    cancel()
+    const operation: Operation = { id, controller: new AbortController() }
+    current = operation
+    setPending(true)
+    const signal = operation.controller.signal
+    const isCurrent = () => !disposed && current === operation && !signal.aborted
+      && isActive() && options.childSessionId() === id
+    const loadPage = async (load: TaskStepCopyOptions["loadOldest"]) => {
+      // A superseded native read can resolve without committing a page while
+      // this view stays active. Never mistake the resident tail for that page.
+      if (!await load(id, signal)) throw new Error("Task step copy page was not committed")
+    }
+
+    operation.promise = (async () => {
+      try {
+        operation.release = options.beginTraversal(id)
+        const steps = await loadCompleteMessageHistory({
+          getPageKey: () => options.getPageKey(id),
+          isCurrent,
+          isLatest: () => options.isLatest(id),
+          loadOldest: () => loadPage(options.loadOldest),
+          loadNewer: () => loadPage(options.loadNewer),
+          visit: () => options.readSteps(id).map(step => JSON.stringify(step, null, 2)),
+          // Bound network work, never truncate copied steps/strings to a render
+          // budget. Retain serialized output across evicted pages until copying;
+          // exhausting the operation budget fails without copying partial data.
+          maxPages: MESSAGE_HISTORY_TRAVERSAL_PAGE_LIMIT,
+        })
+        if (!steps || !isCurrent()) return
+        const chunks = ["[\n"]
+        steps.forEach((step, index) => chunks.push(index === 0 ? step : `,\n${step}`))
+        chunks.push("\n]")
+        if (isCurrent()) await options.copy(chunks, { isCurrent, signal })
+      } catch (error) {
+        if (isCurrent()) throw error
+      } finally {
+        release(operation)
+        if (current === operation) {
+          current = undefined
+          setPending(false)
+        }
+      }
+    })()
+    return operation.promise
+  }
+
+  return { copy, pending }
+}
diff --git a/packages/ui/src/components/tool-call/renderers/task-summary.ts b/packages/ui/src/components/tool-call/renderers/task-summary.ts
new file mode 100644
index 000000000..2186674fd
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderers/task-summary.ts
@@ -0,0 +1,60 @@
+import { limitToolTitleForRender } from "../utils"
+
+export const TASK_STEP_RENDER_LIMIT = 200
+
+export function isTaskStepListTruncated(count: number): boolean {
+  return count > TASK_STEP_RENDER_LIMIT
+}
+
+export function isTaskScanTruncated(...sources: boolean[]): boolean {
+  return sources.some(Boolean)
+}
+
+export function resolveTaskStepTruncation(childSourceActive: boolean, childTruncated: boolean, legacyTruncated: boolean): boolean {
+  return childTruncated || (!childSourceActive && legacyTruncated)
+}
+
+export function getTaskOutputCopyText(state: unknown): string | null {
+  const output = (state as { output?: unknown } | null | undefined)?.output
+  return typeof output === "string" && output.length > 0 ? output : null
+}
+
+export function collectChildTaskSteps(
+  messageIds: readonly string[],
+  getMessage: (messageId: string) => { partIds: readonly string[]; parts: Record<string, { data?: unknown } | undefined> } | undefined,
+): unknown[] {
+  const steps: unknown[] = []
+  for (const messageId of messageIds) {
+    const message = getMessage(messageId)
+    if (!message) continue
+    for (const partId of message.partIds) {
+      const part = message.parts[partId]?.data as { type?: unknown } | undefined
+      if (part?.type === "tool") steps.push(part)
+    }
+  }
+  return steps
+}
+
+export function stringifyChildTaskSteps(
+  messageIds: readonly string[],
+  getMessage: (messageId: string) => { partIds: readonly string[]; parts: Record<string, { data?: unknown } | undefined> } | undefined,
+): string {
+  return JSON.stringify(collectChildTaskSteps(messageIds, getMessage), null, 2)
+}
+
+export function getLegacyTaskSummary(summary: unknown) {
+  const entries = Array.isArray(summary) ? summary : []
+  return {
+    entries,
+    renderedEntries: entries.slice(-TASK_STEP_RENDER_LIMIT),
+    truncated: isTaskStepListTruncated(entries.length),
+  }
+}
+
+export function stringifyLegacyTaskSummary(summary: unknown): string {
+  return JSON.stringify(getLegacyTaskSummary(summary).entries, null, 2)
+}
+
+export function getTruncatedTaskStepTitleCopyText(title: string): string | null {
+  return limitToolTitleForRender(title) === title ? null : title
+}
diff --git a/packages/ui/src/components/tool-call/renderers/task.tsx b/packages/ui/src/components/tool-call/renderers/task.tsx
index c8f36c423..dee90df85 100644
--- a/packages/ui/src/components/tool-call/renderers/task.tsx
+++ b/packages/ui/src/components/tool-call/renderers/task.tsx
@@ -1,16 +1,27 @@
-import { For, Index, Show, createEffect, createMemo, createSignal, untrack } from "solid-js"
+import { For, Index, Show, createEffect, createMemo, createSignal, onCleanup, untrack } from "solid-js"
 import { Dynamic } from "solid-js/web"
+import { Copy } from "lucide-solid"
 import type { ToolState } from "../../../types/tool-state"
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, getDefaultToolAction, getToolName, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, getDefaultToolAction, getToolName, limitToolOutputForRender, limitToolTitleForRender, readToolStatePayload } from "../utils"
 import { messageStoreBus } from "../../../stores/message-v2/bus"
-import { loadMessages } from "../../../stores/session-api"
-import { loading, messagesLoaded } from "../../../stores/session-state"
+import { beginMessageHistoryTraversal, isLatestMessageWindow, loadMessages, loadNewerMessageWindow, loadOldestMessageWindow } from "../../../stores/session-api"
+import { getSessionMessagesLoadError, messagesLoaded, sessions } from "../../../stores/session-state"
+import { setSessionTranscriptVisible } from "../../../stores/session-transcript-memory"
+import { waitForInstanceWorkspaceMetadataHydration } from "../../../stores/instances"
+import { useActiveSessionMessageLoad } from "../../../lib/hooks/use-active-session-message-load"
 import { getMessageContentIcon } from "../../message-content-icons"
 import { getTaskToolSearchText } from "../search-text"
+import { copyTextChunksToClipboard, copyToClipboard } from "../../../lib/clipboard"
+import LoadErrorState from "../../load-error-state"
+import { collectChildTaskSteps, getLegacyTaskSummary, getTaskOutputCopyText, getTruncatedTaskStepTitleCopyText, isTaskScanTruncated, isTaskStepListTruncated, resolveTaskStepTruncation, stringifyLegacyTaskSummary, TASK_STEP_RENDER_LIMIT } from "./task-summary"
+import { getMessageWindowPageKey } from "../../message-history-pagination"
+import { useTaskStepCopy } from "./task-copy"
 import { getCanonicalToolName } from "../tool-presentation"
 import { describeTaskTitle, readSubagentName } from "./task-title"
 
+const TASK_MESSAGE_SCAN_LIMIT = 10_000
+
 interface TaskSummaryItem {
   id: string
   tool: string
@@ -21,6 +32,8 @@ interface TaskSummaryItem {
   title?: string
 }
 
+type TaskScanBudget = { remaining: number }
+
 function extractSessionIdFromTaskState(state?: ToolState): string {
   if (!state) return ""
   const metadata = (state as unknown as { metadata?: Record<string, unknown> }).metadata ?? {}
@@ -154,15 +167,18 @@ export const taskRenderer: ToolRenderer = {
   tools: ["task"],
   getSearchText: getTaskToolSearchText,
   getAction: ({ t }) => t("toolCall.task.action.delegating"),
+  getOutputChrome({ toolState }) {
+    const output = getTaskOutputCopyText(toolState())
+    return output ? { getCopyText: () => output, hasCopyText: true } : undefined
+  },
   getTitle({ toolState, toolName }) {
     const state = toolState()
     if (!state) return undefined
     const { input } = readToolStatePayload(state)
     return describeTaskTitle(input, toolName())
   },
-  renderBody({ toolState, instanceId, renderToolCall, messageVersion, partVersion, scrollHelpers, renderMarkdown, t, onContentRendered }) {
+  renderBody({ toolState, instanceId, isActive, renderToolCall, messageVersion, partVersion, scrollHelpers, renderMarkdown, t, onContentRendered }) {
     const store = messageStoreBus.getOrCreate(instanceId)
-    const [requestedChildLoad, setRequestedChildLoad] = createSignal(false)
 
     const childSessionId = createMemo(() => {
       const state = toolState()
@@ -176,24 +192,41 @@ export const taskRenderer: ToolRenderer = {
       return loadedForInstance?.has(id) ?? false
     })
 
-    const childSessionLoading = createMemo(() => {
+    const childSessionLoadError = createMemo(() => {
       const id = childSessionId()
-      if (!id) return false
-      const loadingSet = loading().loadingMessages.get(instanceId)
-      return loadingSet?.has(id) ?? false
+      return id && !childSessionLoaded() ? getSessionMessagesLoadError(instanceId, id) : undefined
+    })
+
+    function retryChildSessionLoad() {
+      const id = childSessionId()
+      if (!id || isActive?.() === false) return
+      void loadMessages(instanceId, id, { force: true }).catch(() => {})
+    }
+
+    useActiveSessionMessageLoad({
+      isActive: () => Boolean(childSessionId()) && isActive?.() !== false,
+      instanceId: () => instanceId,
+      session: () => {
+        const id = childSessionId()
+        return id ? sessions().get(instanceId)?.get(id) : undefined
+      },
+      shouldLoad: () => !childSessionLoaded(),
+      loadMessages: (childInstanceId, id, options) => loadMessages(childInstanceId, id, {
+        signal: options?.signal,
+        registerInvalidation: options?.registerInvalidation,
+      }),
+      waitForHydration: waitForInstanceWorkspaceMetadataHydration,
     })
 
     createEffect(() => {
       const id = childSessionId()
-      if (!id) return
-      if (requestedChildLoad()) return
-      if (childSessionLoaded()) return
-      if (childSessionLoading()) return
-      setRequestedChildLoad(true)
-      void loadMessages(instanceId, id)
+      if (!id || isActive?.() === false) return
+      untrack(() => setSessionTranscriptVisible(instanceId, id, true))
+      onCleanup(() => setSessionTranscriptVisible(instanceId, id, false))
     })
 
     const [childToolKeys, setChildToolKeys] = createSignal<string[]>([])
+    const [childToolsTruncated, setChildToolsTruncated] = createSignal(false)
 
     let indexedSessionId = ""
     let indexedMessageCount = 0
@@ -206,21 +239,32 @@ export const taskRenderer: ToolRenderer = {
       indexedMessageTail = ""
       indexedPartCounts.clear()
       setChildToolKeys([])
+      setChildToolsTruncated(false)
     }
 
-    function scanMessageToolParts(messageId: string, startIndex: number) {
+    function scanMessageToolParts(messageId: string, startIndex: number, limit: number, budget: TaskScanBudget) {
+      if (budget.remaining <= 0) {
+        setChildToolsTruncated(true)
+        return [] as string[]
+      }
+      budget.remaining -= 1
       const record = store.getMessage(messageId)
       if (!record) return [] as string[]
 
       const partIds = record.partIds
       const keys: string[] = []
-      for (let idx = startIndex; idx < partIds.length; idx += 1) {
+      const oldestScannedIndex = Math.max(startIndex, partIds.length - budget.remaining)
+      if (oldestScannedIndex > startIndex) setChildToolsTruncated(true)
+      let idx = partIds.length - 1
+      for (; idx >= oldestScannedIndex && keys.length < limit && budget.remaining > 0; idx -= 1) {
+        budget.remaining -= 1
         const partId = partIds[idx]
         const entry = record.parts?.[partId]
         const data = entry?.data
         if (!data || (data as any).type !== "tool") continue
-        keys.push(`${messageId}::${partId}`)
+        keys.unshift(`${messageId}::${partId}`)
       }
+      if (idx >= oldestScannedIndex) setChildToolsTruncated(true)
       indexedPartCounts.set(messageId, partIds.length)
       return keys
     }
@@ -230,12 +274,22 @@ export const taskRenderer: ToolRenderer = {
       indexedMessageCount = messageIds.length
       indexedMessageTail = messageIds[messageIds.length - 1] ?? ""
       indexedPartCounts.clear()
+      setChildToolsTruncated(false)
 
       const nextKeys: string[] = []
-      for (const messageId of messageIds) {
-        nextKeys.push(...scanMessageToolParts(messageId, 0))
+      const scanLimit = TASK_STEP_RENDER_LIMIT + 1
+      const budget = { remaining: TASK_MESSAGE_SCAN_LIMIT }
+      const oldestScannedIndex = Math.max(0, messageIds.length - TASK_MESSAGE_SCAN_LIMIT)
+      for (let index = messageIds.length - 1; index >= oldestScannedIndex && nextKeys.length < scanLimit && budget.remaining > 0; index -= 1) {
+        const keys = scanMessageToolParts(messageIds[index], 0, scanLimit - nextKeys.length, budget)
+        for (let keyIndex = keys.length - 1; keyIndex >= 0; keyIndex -= 1) nextKeys.unshift(keys[keyIndex])
       }
-      setChildToolKeys(nextKeys)
+      for (let index = oldestScannedIndex; index < messageIds.length; index += 1) {
+        const messageId = messageIds[index]
+        if (!indexedPartCounts.has(messageId)) indexedPartCounts.set(messageId, store.getMessage(messageId)?.partIds.length ?? 0)
+      }
+      setChildToolsTruncated((truncated) => isTaskScanTruncated(truncated, oldestScannedIndex > 0, isTaskStepListTruncated(nextKeys.length)))
+      setChildToolKeys(nextKeys.slice(-TASK_STEP_RENDER_LIMIT))
     }
 
     createEffect(() => {
@@ -275,33 +329,47 @@ export const taskRenderer: ToolRenderer = {
         }
 
         const appendedKeys: string[] = []
+        const budget = { remaining: TASK_MESSAGE_SCAN_LIMIT }
 
         // Scan any new messages appended since last index.
-        for (let idx = indexedMessageCount; idx < messageIds.length; idx += 1) {
+        const appendedStart = Math.max(indexedMessageCount, messageIds.length - TASK_MESSAGE_SCAN_LIMIT)
+        if (appendedStart > indexedMessageCount) setChildToolsTruncated(true)
+        for (let idx = appendedStart; idx < messageIds.length && budget.remaining > 0; idx += 1) {
           const messageId = messageIds[idx]
-          appendedKeys.push(...scanMessageToolParts(messageId, 0))
+          appendedKeys.push(...scanMessageToolParts(messageId, 0, TASK_STEP_RENDER_LIMIT, budget))
+          if (appendedKeys.length > TASK_STEP_RENDER_LIMIT) {
+            setChildToolsTruncated(true)
+            appendedKeys.splice(0, appendedKeys.length - TASK_STEP_RENDER_LIMIT)
+          }
         }
 
-        // Scan a small window of recent messages for newly appended parts.
-        // Deltas typically affect the most recent tool call, so this avoids
-        // iterating every message on every revision.
+        // Scan the bounded indexed window so out-of-order updates are not missed.
         const existingCount = Math.min(indexedMessageCount, messageIds.length)
-        const windowStart = Math.max(0, existingCount - 3)
-        for (let idx = windowStart; idx < existingCount; idx += 1) {
+        const windowStart = Math.max(0, existingCount - TASK_MESSAGE_SCAN_LIMIT)
+        for (let idx = windowStart; idx < existingCount && budget.remaining > 0; idx += 1) {
           const messageId = messageIds[idx]
           const previousPartCount = indexedPartCounts.get(messageId) ?? 0
           const record = store.getMessage(messageId)
           const nextPartCount = record?.partIds.length ?? 0
           if (nextPartCount > previousPartCount) {
-            appendedKeys.push(...scanMessageToolParts(messageId, previousPartCount))
+            appendedKeys.push(...scanMessageToolParts(messageId, previousPartCount, TASK_STEP_RENDER_LIMIT, budget))
+            if (appendedKeys.length > TASK_STEP_RENDER_LIMIT) {
+              setChildToolsTruncated(true)
+              appendedKeys.splice(0, appendedKeys.length - TASK_STEP_RENDER_LIMIT)
+            }
           }
         }
 
         indexedMessageCount = messageIds.length
         indexedMessageTail = messageIds[messageIds.length - 1] ?? ""
+        if (indexedPartCounts.size > TASK_MESSAGE_SCAN_LIMIT) {
+          const retainedIds = new Set(messageIds.slice(-TASK_MESSAGE_SCAN_LIMIT))
+          for (const messageId of indexedPartCounts.keys()) if (!retainedIds.has(messageId)) indexedPartCounts.delete(messageId)
+        }
 
         if (appendedKeys.length > 0) {
-          setChildToolKeys((prev) => [...prev, ...appendedKeys])
+          if (childToolKeys().length + appendedKeys.length > TASK_STEP_RENDER_LIMIT) setChildToolsTruncated(true)
+          setChildToolKeys((prev) => [...prev, ...appendedKeys].slice(-TASK_STEP_RENDER_LIMIT))
         }
       })
     })
@@ -310,21 +378,22 @@ export const taskRenderer: ToolRenderer = {
       if (!state) return null
       const { input } = readToolStatePayload(state)
       const prompt = typeof input.prompt === "string" ? input.prompt : null
-      return ensureMarkdownContent(prompt, undefined, false)
+      return ensureMarkdownContent(prompt ? limitToolOutputForRender(prompt) : prompt, undefined, false)
     })
 
     const outputContent = createMemo(() => {
       const state = toolState()
       if (!state) return null
       const output = typeof (state as { output?: unknown }).output === "string" ? ((state as { output?: string }).output as string) : null
-      return ensureMarkdownContent(output, undefined, false)
+      return ensureMarkdownContent(output ? limitToolOutputForRender(output) : output, undefined, false)
     })
 
     const agentLabel = createMemo(() => {
       const state = toolState()
       if (!state) return null
       const { input } = readToolStatePayload(state)
-      return readSubagentName(input) ?? null
+      const agent = readSubagentName(input)
+      return agent ? limitToolTitleForRender(agent) : null
     })
 
     const modelLabel = createMemo(() => {
@@ -333,8 +402,8 @@ export const taskRenderer: ToolRenderer = {
       const { metadata } = readToolStatePayload(state)
       const model = (metadata as any).model
       if (!model || typeof model !== "object") return null
-      const providerId = typeof model.providerID === "string" ? model.providerID : null
-      const modelId = typeof model.modelID === "string" ? model.modelID : null
+      const providerId = typeof model.providerID === "string" ? limitToolTitleForRender(model.providerID) : null
+      const modelId = typeof model.modelID === "string" ? limitToolTitleForRender(model.modelID) : null
       if (!providerId && !modelId) return null
       if (providerId && modelId) return `${providerId}/${modelId}`
       return providerId ?? modelId
@@ -343,27 +412,26 @@ export const taskRenderer: ToolRenderer = {
     const headerMeta = createMemo(() => {
       const agent = agentLabel()
       const model = modelLabel()
-      if (agent && model) return `${agent} \u2022 ${model}`
-      if (agent) return agent
-      if (model) return model
+      if (agent && model) return limitToolTitleForRender(t("toolCall.task.meta.agentModel", { agent, model }))
+      if (agent) return limitToolTitleForRender(t("toolCall.task.meta.agent", { agent }))
+      if (model) return limitToolTitleForRender(t("toolCall.task.meta.model", { model }))
       return null
     })
 
-    const legacyItems = createMemo(() => {
+    const legacySummary = createMemo(() => {
       // Track the reactive change points so we only recompute when the part/message changes
       messageVersion?.()
       partVersion?.()
 
       const state = toolState()
-      if (!state) return []
-
-      // Prefer deriving steps from the child session when loaded.
-      if (childSessionLoaded()) return []
-
+      if (!state) return getLegacyTaskSummary(undefined)
       const { metadata } = readToolStatePayload(state)
-      const summary = Array.isArray((metadata as any).summary) ? ((metadata as any).summary as any[]) : []
+      return getLegacyTaskSummary((metadata as any).summary)
+    })
 
-      return summary.map((entry, index) => {
+    const legacyItems = createMemo(() => {
+      if (childToolKeys().length > 0) return []
+      return legacySummary().renderedEntries.map((entry, index) => {
         const tool = typeof entry?.tool === "string" ? (entry.tool as string) : "unknown"
         const stateValue = typeof entry?.state === "object" ? (entry.state as ToolState) : undefined
         const metadataFromEntry = typeof entry?.metadata === "object" && entry.metadata ? entry.metadata : {}
@@ -374,6 +442,25 @@ export const taskRenderer: ToolRenderer = {
         return { id, tool, input: fallbackInput, metadata: metadataFromEntry, state: stateValue, status: statusValue, title }
       })
     })
+    const childTranscriptTruncated = () => {
+      const id = childSessionId()
+      const window = id ? store.getMessageWindow(id) : undefined
+      return childToolsTruncated() || Boolean(window && (window.kind !== "latest" || window.olderCursor))
+    }
+    const childSourceActive = () => childToolKeys().length > 0 || childTranscriptTruncated()
+    const stepsTruncated = () => resolveTaskStepTruncation(childSourceActive(), childTranscriptTruncated(), legacySummary().truncated)
+
+    const childTaskCopy = useTaskStepCopy({
+      childSessionId,
+      isActive: () => isActive?.() ?? true,
+      beginTraversal: id => beginMessageHistoryTraversal(instanceId, id),
+      getPageKey: id => getMessageWindowPageKey(store.getMessageWindow(id)),
+      isLatest: id => isLatestMessageWindow(instanceId, id),
+      loadOldest: (id, signal) => loadOldestMessageWindow(instanceId, id, signal),
+      loadNewer: (id, signal) => loadNewerMessageWindow(instanceId, id, signal),
+      readSteps: id => collectChildTaskSteps(store.getSessionMessageIds(id), store.getMessage),
+      copy: copyTextChunksToClipboard,
+    })
 
     createEffect(() => {
       const childCount = childToolKeys().length
@@ -406,15 +493,42 @@ export const taskRenderer: ToolRenderer = {
           </section>
         </Show>
 
-        <Show when={childToolKeys().length > 0 || legacyItems().length > 0}>
+        <Show when={childSessionLoadError()}>
+          {(error) => (
+            <LoadErrorState
+              title={t("messageSection.loadError.title")}
+              error={error()}
+              retryLabel={t("messageSection.loadError.reload")}
+              onRetry={retryChildSessionLoad}
+              variant="compact"
+            />
+          )}
+        </Show>
+
+        <Show when={childToolKeys().length > 0 || legacyItems().length > 0 || stepsTruncated()}>
           <section class="tool-call-task-section">
             <header class="tool-call-task-section-header">
               <span class="tool-call-task-section-title">{t("toolCall.task.sections.steps")}</span>
-              <span class="tool-call-task-section-meta">
-                {t("toolCall.task.steps.count", { count: childToolKeys().length > 0 ? childToolKeys().length : legacyItems().length })}
+              <span class="tool-call-io-actions">
+                <span class="tool-call-task-section-meta">
+                  {t("toolCall.task.steps.count", { count: stepsTruncated() ? `${TASK_STEP_RENDER_LIMIT}+` : childSourceActive() ? childToolKeys().length : legacyItems().length })}
+                </span>
+                <Show when={childTranscriptTruncated()}>
+                  <button type="button" class="tool-call-header-icon-button tool-call-io-copy" disabled={childTaskCopy.pending()} onClick={() => void childTaskCopy.copy().catch(() => {})} aria-label={t("toolCall.io.copyOutputAriaLabel")} title={t("toolCall.io.copyOutputTitle")}>
+                    <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+                  </button>
+                </Show>
+                <Show when={childToolKeys().length === 0 && legacySummary().truncated}>
+                  <button type="button" class="tool-call-header-icon-button tool-call-io-copy" onClick={() => void copyToClipboard(stringifyLegacyTaskSummary(legacySummary().entries))} aria-label={t("toolCall.io.copyOutputAriaLabel")} title={t("toolCall.io.copyOutputTitle")}>
+                    <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+                  </button>
+                </Show>
               </span>
             </header>
             <div class="tool-call-task-section-body">
+              <Show when={stepsTruncated()}>
+                <div class="tool-call-diagnostic-message" role="status">{t("toolCall.task.steps.truncated", { count: TASK_STEP_RENDER_LIMIT })}</div>
+              </Show>
               <Show
                 when={childToolKeys().length > 0}
                 fallback={
@@ -429,8 +543,10 @@ export const taskRenderer: ToolRenderer = {
                       <For each={legacyItems()}>
                         {(item) => {
                           const icon = getMessageContentIcon(item.tool)
-                          const description = describeToolTitle(item)
-                          const toolLabel = getToolName(item.tool)
+                          const fullDescription = describeToolTitle(item)
+                          const description = limitToolTitleForRender(fullDescription)
+                          const copyTitle = getTruncatedTaskStepTitleCopyText(fullDescription)
+                          const toolLabel = limitToolTitleForRender(getToolName(item.tool))
                           const status = normalizeStatus(item.status ?? item.state?.status)
                           const statusIcon = summarizeStatusIcon(status)
                           const statusKey = summarizeStatusLabel(status)
@@ -446,6 +562,13 @@ export const taskRenderer: ToolRenderer = {
                               <span class="tool-call-task-label">{toolLabel}</span>
                               <span class="tool-call-task-separator" aria-hidden="true">—</span>
                               <span class="tool-call-task-text">{description}</span>
+                              <Show when={copyTitle}>
+                                {(title) => (
+                                  <button type="button" class="tool-call-header-icon-button tool-call-io-copy" onClick={() => void copyToClipboard(title())} aria-label={t("toolCall.io.copyOutputAriaLabel")} title={t("toolCall.io.copyOutputTitle")}>
+                                    <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+                                  </button>
+                                )}
+                              </Show>
                               <Show when={statusIcon}>
                                 <span class="tool-call-task-status" aria-label={statusLabel} title={statusLabel}>
                                   {statusIcon}
diff --git a/packages/ui/src/components/tool-call/renderers/todo-data.ts b/packages/ui/src/components/tool-call/renderers/todo-data.ts
new file mode 100644
index 000000000..c8ebc3ebd
--- /dev/null
+++ b/packages/ui/src/components/tool-call/renderers/todo-data.ts
@@ -0,0 +1,94 @@
+import type { ToolState } from "../../../types/tool-state"
+import { readToolStatePayload, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT } from "../utils"
+
+export type TodoViewStatus = "pending" | "in_progress" | "completed" | "cancelled"
+
+export interface TodoViewItem {
+  id: string
+  content: string
+  status: TodoViewStatus
+}
+
+type TodoViewItems = TodoViewItem[] & { partial?: boolean }
+export const TODO_ITEM_RENDER_LIMIT = 200
+
+function normalizeTodoStatus(rawStatus: unknown): TodoViewStatus {
+  if (rawStatus === "completed" || rawStatus === "in_progress" || rawStatus === "cancelled") return rawStatus
+  return "pending"
+}
+
+export function extractTodosFromState(state?: ToolState): TodoViewItems {
+  if (!state) return []
+  const { metadata } = readToolStatePayload(state)
+  const todos: any[] = Array.isArray((metadata as any).todos) ? (metadata as any).todos : []
+  const normalized: TodoViewItems = []
+  let characters = 0
+  let scannedCharacters = 0
+  let index = 0
+  for (; index < todos.length && index < 10_000 && normalized.length < TODO_ITEM_RENDER_LIMIT && scannedCharacters < TOOL_OUTPUT_RENDER_CHARACTER_LIMIT; index += 1) {
+    const todo = todos[index]
+    const rawContent = typeof todo?.content === "string" ? todo.content : ""
+    const contentPrefix = rawContent.slice(0, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT - scannedCharacters)
+    scannedCharacters += contentPrefix.length
+    const contentStart = contentPrefix.search(/\S/)
+    if (contentStart < 0) {
+      if (contentPrefix.length < rawContent.length) break
+      continue
+    }
+    const remaining = TOOL_OUTPUT_RENDER_CHARACTER_LIMIT - characters
+    const contentSlice = contentPrefix.slice(contentStart, contentStart + remaining)
+    const content = contentSlice.trimEnd()
+    if (!content) continue
+    const status = normalizeTodoStatus(todo.status)
+    const id = typeof todo?.id === "string" && todo.id.length > 0 ? todo.id : String(index)
+    normalized.push({ id, content, status })
+    characters += content.length
+    if (contentStart + contentSlice.length < rawContent.length) break
+  }
+  if (index < todos.length) normalized.partial = true
+  return normalized
+}
+
+export function getRenderedTodos(todos: TodoViewItem[]) {
+  const items: TodoViewItem[] = []
+  let characters = 0
+  for (let index = 0; index < todos.length && index < TODO_ITEM_RENDER_LIMIT; index += 1) {
+    if (characters >= TOOL_OUTPUT_RENDER_CHARACTER_LIMIT) break
+    const todo = todos[index]
+    const content = todo.content.slice(0, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT - characters)
+    items.push({ ...todo, content })
+    characters += content.length
+  }
+  return { items, truncated: Boolean((todos as TodoViewItems).partial) || items.length < todos.length }
+}
+
+export function hasTodoCopyText(state?: ToolState): boolean {
+  if (!state) return false
+  const { metadata } = readToolStatePayload(state)
+  return Array.isArray((metadata as any).todos) && (metadata as any).todos.length > 0
+}
+
+export function getTodoCopyText(state?: ToolState): string {
+  if (!state) return "[]"
+  const { metadata } = readToolStatePayload(state)
+  return JSON.stringify(Array.isArray((metadata as any).todos) ? (metadata as any).todos : [], null, 2)
+}
+
+export function getTodoTitleKind(state?: ToolState): "plan" | "creating" | "completing" | "updating" {
+  if (state?.status !== "completed") return "plan"
+  const { metadata } = readToolStatePayload(state)
+  const todos: any[] = Array.isArray((metadata as any).todos) ? (metadata as any).todos : []
+  if (todos.length === 0) return "plan"
+  let allPending = true
+  let allCompleted = true
+  for (let index = 0; index < todos.length && index < 10_000; index += 1) {
+    const status = normalizeTodoStatus(todos[index]?.status)
+    allPending = allPending && status === "pending"
+    allCompleted = allCompleted && status === "completed"
+    if (!allPending && !allCompleted) return "updating"
+  }
+  if (todos.length > 10_000) return "updating"
+  if (allPending) return "creating"
+  if (allCompleted) return "completing"
+  return "updating"
+}
diff --git a/packages/ui/src/components/tool-call/renderers/todo.tsx b/packages/ui/src/components/tool-call/renderers/todo.tsx
index 6dc820d99..01952d5b6 100644
--- a/packages/ui/src/components/tool-call/renderers/todo.tsx
+++ b/packages/ui/src/components/tool-call/renderers/todo.tsx
@@ -1,41 +1,11 @@
 import { For, Show } from "solid-js"
 import type { ToolState } from "../../../types/tool-state"
-import { CheckCircle, CircleEllipsis, MinusCircle, PauseCircle } from "lucide-solid"
+import { CheckCircle, CircleEllipsis, Copy, MinusCircle, PauseCircle } from "lucide-solid"
 import type { ToolRenderer } from "../types"
-import { readToolStatePayload } from "../utils"
 import { useI18n, tGlobal } from "../../../lib/i18n"
 import { getTodoToolSearchText } from "../search-text"
-
-export type TodoViewStatus = "pending" | "in_progress" | "completed" | "cancelled"
-
-export interface TodoViewItem {
-  id: string
-  content: string
-  status: TodoViewStatus
-}
-
-function normalizeTodoStatus(rawStatus: unknown): TodoViewStatus {
-  if (rawStatus === "completed" || rawStatus === "in_progress" || rawStatus === "cancelled") return rawStatus
-  return "pending"
-}
-
-function extractTodosFromState(state?: ToolState): TodoViewItem[] {
-  if (!state) return []
-  const { metadata } = readToolStatePayload(state)
-  const todos = Array.isArray((metadata as any).todos) ? (metadata as any).todos : []
-  const items: TodoViewItem[] = []
-
-  for (let index = 0; index < todos.length; index++) {
-    const todo = todos[index]
-    const content = typeof todo?.content === "string" ? todo.content.trim() : ""
-    if (!content) continue
-    const status = normalizeTodoStatus((todo as any).status)
-    const id = typeof todo?.id === "string" && todo.id.length > 0 ? todo.id : `${index}-${content}`
-    items.push({ id, content, status })
-  }
-
-  return items
-}
+import { extractTodosFromState, getRenderedTodos, getTodoCopyText, getTodoTitleKind, hasTodoCopyText, type TodoViewItem, type TodoViewStatus } from "./todo-data"
+import { copyToClipboard } from "../../../lib/clipboard"
 
 function summarizeTodos(todos: TodoViewItem[]) {
   return todos.reduce(
@@ -82,17 +52,18 @@ interface TodoListViewProps {
 
 export function TodoListView(props: TodoListViewProps) {
   const { t } = useI18n()
-  const todos = extractTodosFromState(props.state)
-  const counts = summarizeTodos(todos)
+  const allTodos = extractTodosFromState(props.state)
+  const todos = getRenderedTodos(allTodos)
+  const counts = summarizeTodos(allTodos)
 
-  if (counts.total === 0) {
+  if (counts.total === 0 && !todos.truncated) {
     return <div class="tool-call-todo-empty">{props.emptyLabel ?? t("toolCall.renderer.todo.empty")}</div>
   }
 
   return (
     <div class="tool-call-todo-region">
       <div class="tool-call-todos" role="list">
-        <For each={todos}>
+        <For each={todos.items}>
           {(todo) => {
             const label = getTodoStatusLabel(t, todo.status)
             return (
@@ -120,20 +91,20 @@ export function TodoListView(props: TodoListViewProps) {
           }}
         </For>
       </div>
+      <Show when={todos.truncated}>
+        <div class="tool-call-diagnostic-message">
+          <span role="status">{t("toolCall.output.truncated")}</span>
+          <button type="button" class="tool-call-header-icon-button tool-call-io-copy" onClick={() => void copyToClipboard(getTodoCopyText(props.state))} aria-label={t("toolCall.io.copyOutputAriaLabel")} title={t("toolCall.io.copyOutputTitle")}>
+            <Copy class="w-3.5 h-3.5" aria-hidden="true" />
+          </button>
+        </div>
+      </Show>
     </div>
   )
 }
 
 export function getTodoTitle(state?: ToolState): string {
-  if (!state) return tGlobal("toolCall.renderer.todo.title.plan")
-
-  const todos = extractTodosFromState(state)
-  if (state.status !== "completed" || todos.length === 0) return tGlobal("toolCall.renderer.todo.title.plan")
-
-  const counts = summarizeTodos(todos)
-  if (counts.pending === counts.total) return tGlobal("toolCall.renderer.todo.title.creating")
-  if (counts.completed === counts.total) return tGlobal("toolCall.renderer.todo.title.completing")
-  return tGlobal("toolCall.renderer.todo.title.updating")
+  return tGlobal(`toolCall.renderer.todo.title.${getTodoTitleKind(state)}`)
 }
 
 export const todoRenderer: ToolRenderer = {
@@ -143,6 +114,10 @@ export const todoRenderer: ToolRenderer = {
   getTitle({ toolState }) {
     return getTodoTitle(toolState())
   },
+  getOutputChrome({ toolState }) {
+    const state = toolState()
+    return hasTodoCopyText(state) ? { getCopyText: () => getTodoCopyText(state), hasCopyText: true } : undefined
+  },
   renderBody({ toolState }) {
     const state = toolState()
     if (!state) return null
diff --git a/packages/ui/src/components/tool-call/renderers/webfetch.tsx b/packages/ui/src/components/tool-call/renderers/webfetch.tsx
index 59aa5645a..a0f7b0536 100644
--- a/packages/ui/src/components/tool-call/renderers/webfetch.tsx
+++ b/packages/ui/src/components/tool-call/renderers/webfetch.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, formatUnknown, getToolName, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, formatUnknownForCopy, formatUnknownForRender, getToolName, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { getWebfetchToolSearchText } from "../search-text"
 
@@ -21,16 +21,14 @@ export const webfetchRenderer: ToolRenderer = {
     if (!state || state.status === "pending") return undefined
 
     const { metadata } = readToolStatePayload(state)
-    const result = formatUnknown(
-      state.status === "completed"
-        ? state.output
-        : metadata.output,
-    )
-    if (!result) return undefined
+    const output = state.status === "completed" ? state.output : metadata.output
+    if (output === undefined || output === null || output === "" || (Array.isArray(output) && output.length === 0)) return undefined
+    const result = formatUnknownForRender(output)
 
     return {
-      language: result.language ?? "text",
-      copyText: result.text,
+      language: result?.language ?? "text",
+      getCopyText: () => formatUnknownForCopy(output)?.text ?? null,
+      hasCopyText: true,
       wrapToggle: true,
       suppressInnerHeader: true,
     }
@@ -40,7 +38,7 @@ export const webfetchRenderer: ToolRenderer = {
     if (!state || state.status === "pending") return null
 
     const { metadata } = readToolStatePayload(state)
-    const result = formatUnknown(
+    const result = formatUnknownForRender(
       state.status === "completed"
         ? state.output
         : metadata.output,
diff --git a/packages/ui/src/components/tool-call/renderers/write.tsx b/packages/ui/src/components/tool-call/renderers/write.tsx
index 9a7f3d540..486c69e73 100644
--- a/packages/ui/src/components/tool-call/renderers/write.tsx
+++ b/packages/ui/src/components/tool-call/renderers/write.tsx
@@ -1,5 +1,5 @@
 import type { ToolRenderer } from "../types"
-import { ensureMarkdownContent, getRelativePath, getToolName, inferLanguageFromPath, readToolStatePayload } from "../utils"
+import { ensureMarkdownContent, getRelativePath, getToolName, inferLanguageFromPath, limitToolOutputForRender, readToolStatePayload } from "../utils"
 import { tGlobal } from "../../../lib/i18n"
 import { getWriteToolSearchText } from "../search-text"
 
@@ -24,7 +24,7 @@ export const writeRenderer: ToolRenderer = {
     const filePath = typeof input.filePath === "string" ? input.filePath : undefined
     return {
       language: inferLanguageFromPath(filePath) ?? "text",
-      copyText: contentValue,
+      getCopyText: () => contentValue,
       wrapToggle: true,
       suppressInnerHeader: true,
     }
@@ -35,7 +35,7 @@ export const writeRenderer: ToolRenderer = {
     const { metadata, input } = readToolStatePayload(state)
     const contentValue = typeof input.content === "string" ? input.content : metadata.content
     const filePath = typeof input.filePath === "string" ? input.filePath : undefined
-    const content = ensureMarkdownContent(contentValue ?? null, inferLanguageFromPath(filePath), true)
+    const content = ensureMarkdownContent(typeof contentValue === "string" ? limitToolOutputForRender(contentValue) : null, inferLanguageFromPath(filePath), true)
     if (!content) return null
     return renderMarkdown({ content, size: "large", disableHighlight: state.status === "running" })
   },
diff --git a/packages/ui/src/components/tool-call/types.ts b/packages/ui/src/components/tool-call/types.ts
index d9f4baebe..a11838558 100644
--- a/packages/ui/src/components/tool-call/types.ts
+++ b/packages/ui/src/components/tool-call/types.ts
@@ -6,6 +6,7 @@ export type ToolCallPart = Extract<ClientPart, { type: "tool" }>
 
 export interface DiffPayload {
   diffText: string
+  copyText?: string
   filePath?: string
 }
 
@@ -37,6 +38,7 @@ export interface DiffRenderOptions {
   variant?: string
   disableScrollTracking?: boolean
   label?: string
+  onFullDiffAccess?: (diffText: string) => void
   /**
    * Optional cache key suffix to avoid collisions when rendering multiple diffs
    * within the same tool call (e.g. apply_patch).
@@ -57,6 +59,8 @@ export interface ToolRendererContext {
   toolName: Accessor<string>
   instanceId: string
   sessionId: string
+  /** Activity of the owning conversation, inherited by nested child-session tools. */
+  isActive?: Accessor<boolean>
   t: (key: string, params?: Record<string, unknown>) => string
   messageVersion?: Accessor<number | undefined>
   partVersion?: Accessor<number | undefined>
@@ -103,6 +107,8 @@ export interface ToolOutputChrome {
   title?: string
   language?: string
   copyText?: string | null
+  getCopyText?: () => string | null
+  hasCopyText?: boolean
   actions?: JSXElement
   wrapToggle?: boolean
   suppressInnerHeader?: boolean
diff --git a/packages/ui/src/components/tool-call/utils.ts b/packages/ui/src/components/tool-call/utils.ts
index be08beeec..fbd16a70f 100644
--- a/packages/ui/src/components/tool-call/utils.ts
+++ b/packages/ui/src/components/tool-call/utils.ts
@@ -4,6 +4,7 @@ import type { ToolState, ToolStateCompleted, ToolStateError, ToolStateRunning }
 import type { DiffPayload } from "./types"
 import { getLogger } from "../../lib/logger"
 import { tGlobal } from "../../lib/i18n"
+import { exceedsRetainedByteLimit } from "../../lib/retained-size"
 import { getCanonicalToolName } from "./tool-presentation"
 const log = getLogger("session")
 
@@ -11,6 +12,33 @@ const log = getLogger("session")
 export type { ToolStateCompleted, ToolStateError, ToolStateRunning }
 
 export const diffCapableTools = new Set(["edit", "patch"])
+export const TOOL_OUTPUT_RENDER_CHARACTER_LIMIT = 10_000
+export const TOOL_TITLE_RENDER_CHARACTER_LIMIT = 384
+export const MESSAGE_PART_RENDER_LIMIT = 200
+
+export function getItemsForRender<T>(items: readonly T[], limit: number) {
+  return { parts: items.slice(0, limit), truncated: items.length > limit }
+}
+
+export function limitToolOutputForRender(text: string): string {
+  if (text.length <= TOOL_OUTPUT_RENDER_CHARACTER_LIMIT) return text
+  const suffix = `\n\n${tGlobal("toolCall.output.truncated")}`
+  return `${text.slice(0, Math.max(0, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT - suffix.length))}${suffix}`
+}
+
+export function shouldRenderDiffAsPlainText(text: string): boolean {
+  return text.length > TOOL_OUTPUT_RENDER_CHARACTER_LIMIT
+}
+
+export function shouldRenderDiffPayloadAsPlainText(payload: DiffPayload): boolean {
+  return shouldRenderDiffAsPlainText(payload.diffText)
+    || (payload.copyText?.length ?? 0) > TOOL_OUTPUT_RENDER_CHARACTER_LIMIT
+}
+
+export function limitToolTitleForRender(text: string): string {
+  if (text.length <= TOOL_TITLE_RENDER_CHARACTER_LIMIT) return text
+  return `${text.slice(0, TOOL_TITLE_RENDER_CHARACTER_LIMIT - 3)}...`
+}
 
 export function isToolStateRunning(state: ToolState): state is ToolStateRunning {
   return state.status === "running"
@@ -133,6 +161,41 @@ export function formatUnknown(value: unknown): { text: string; language?: string
   return null
 }
 
+export function formatUnknownForRender(value: unknown): { text: string; language?: string } | null {
+  if (typeof value !== "string" && exceedsRetainedByteLimit(value, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT)) {
+    return { text: tGlobal("toolCall.output.tooLarge") }
+  }
+  const result = formatUnknown(value)
+  return result ? { ...result, text: limitToolOutputForRender(result.text) } : null
+}
+
+export function formatToolInputForCopy(input: unknown): { text: string; language?: string } | null {
+  try {
+    const text = JSON.stringify(input, null, 2)
+    return typeof text === "string" ? { text, language: "json" } : null
+  } catch (error) {
+    log.error("Failed to stringify tool call input", error)
+    return null
+  }
+}
+
+export function formatToolInputForRender(input: unknown): { text: string; language?: string } | null {
+  if (typeof input !== "string" && exceedsRetainedByteLimit(input, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT)) {
+    return { text: JSON.stringify(tGlobal("toolCall.output.tooLarge")), language: "json" }
+  }
+  const formatted = formatToolInputForCopy(input)
+  return formatted ? { ...formatted, text: limitToolOutputForRender(formatted.text) } : null
+}
+
+export function formatUnknownForCopy(value: unknown): { text: string; language?: string } | null {
+  try {
+    return formatUnknown(value)
+  } catch (error) {
+    log.error("Failed to format tool call output for copy", error)
+    return { text: tGlobal("toolCall.output.tooLarge") }
+  }
+}
+
 export function inferLanguageFromPath(path?: string): string | undefined {
   return getLanguageFromPath(path || "")
 }
@@ -147,7 +210,11 @@ export function extractDiffPayload(toolName: string, state?: ToolState): DiffPay
   let diffText: string | null = null
 
   for (const candidate of candidates) {
-    if (typeof candidate === "string" && isRenderableDiffText(candidate)) {
+    if (typeof candidate !== "string") continue
+    const renderable = candidate.length > TOOL_OUTPUT_RENDER_CHARACTER_LIMIT
+      ? /(^|\n)@@/.test(candidate.slice(0, TOOL_OUTPUT_RENDER_CHARACTER_LIMIT))
+      : isRenderableDiffText(candidate)
+    if (renderable) {
       diffText = candidate
       break
     }
@@ -237,13 +304,14 @@ export function buildToolSpeechText(options: {
 }): string {
   const sections: string[] = []
 
-  if (options.title.trim()) {
-    sections.push(options.title.trim())
+  const title = limitToolOutputForRender(options.title).trim()
+  if (title) {
+    sections.push(title)
   }
 
   const { input, output } = readToolStatePayload(options.state)
-  const formattedInput = formatUnknown(input)
-  const formattedOutput = formatUnknown(output)
+  const formattedInput = formatUnknownForRender(input)
+  const formattedOutput = formatUnknownForRender(output)
 
   if (formattedInput?.text?.trim()) {
     sections.push(`${options.t("toolCall.io.input")}:\n${formattedInput.text.trim()}`)
@@ -253,13 +321,14 @@ export function buildToolSpeechText(options: {
     sections.push(`${options.t("toolCall.io.output")}:\n${formattedOutput.text.trim()}`)
   }
 
-  if (options.state?.status === "error" && options.state.error?.trim()) {
-    sections.push(`${options.t("toolCall.error.label")} ${options.state.error.trim()}`)
+  const error = options.state?.status === "error" ? limitToolOutputForRender(options.state.error ?? "").trim() : ""
+  if (error) {
+    sections.push(`${options.t("toolCall.error.label")} ${error}`)
   }
 
   if (sections.length === 1 && options.state?.status === "pending") {
     sections.push(options.t("toolCall.pending.waitingToRun"))
   }
 
-  return sections.join("\n\n").trim()
+  return limitToolOutputForRender(sections.join("\n\n").trim())
 }
diff --git a/packages/ui/src/lib/clipboard.test-fixture.ts b/packages/ui/src/lib/clipboard.test-fixture.ts
new file mode 100644
index 000000000..b5343af6c
--- /dev/null
+++ b/packages/ui/src/lib/clipboard.test-fixture.ts
@@ -0,0 +1,43 @@
+export function installClipboardFallbackDom(execCommand: () => boolean, clipboard?: Partial<Pick<Clipboard, "write" | "writeText">>) {
+  const navigatorDescriptor = Object.getOwnPropertyDescriptor(globalThis, "navigator")
+  const documentDescriptor = Object.getOwnPropertyDescriptor(globalThis, "document")
+  const itemDescriptor = Object.getOwnPropertyDescriptor(globalThis, "ClipboardItem")
+  let removed = false
+  let focusRestored = false
+  const textArea = {
+    value: "",
+    readOnly: false,
+    style: {} as CSSStyleDeclaration,
+    focus() {},
+    select() {},
+    remove() { removed = true },
+  }
+  const activeElement = { focus() { focusRestored = true } }
+  const documentMock = Object.assign(new EventTarget(), {
+    visibilityState: "visible",
+    activeElement,
+    createElement: () => textArea,
+    body: { appendChild() {} },
+    execCommand,
+  })
+
+  Object.defineProperty(globalThis, "navigator", { configurable: true, value: { clipboard } })
+  Object.defineProperty(globalThis, "document", { configurable: true, value: documentMock })
+  Object.defineProperty(globalThis, "ClipboardItem", { configurable: true, value: class {} })
+
+  return {
+    textArea,
+    removed: () => removed,
+    focusRestored: () => focusRestored,
+    restore() {
+      restoreGlobal("navigator", navigatorDescriptor)
+      restoreGlobal("document", documentDescriptor)
+      restoreGlobal("ClipboardItem", itemDescriptor)
+    },
+  }
+}
+
+function restoreGlobal(name: "navigator" | "document" | "ClipboardItem", descriptor?: PropertyDescriptor) {
+  if (descriptor) Object.defineProperty(globalThis, name, descriptor)
+  else Reflect.deleteProperty(globalThis, name)
+}
diff --git a/packages/ui/src/lib/clipboard.test.ts b/packages/ui/src/lib/clipboard.test.ts
index 159b3a7b4..032ef48e5 100644
--- a/packages/ui/src/lib/clipboard.test.ts
+++ b/packages/ui/src/lib/clipboard.test.ts
@@ -1,7 +1,8 @@
 import assert from "node:assert/strict"
 import { describe, it } from "node:test"
 
-import { copyToClipboard } from "./clipboard"
+import { copyTextChunksToClipboard, copyToClipboard } from "./clipboard"
+import { installClipboardFallbackDom } from "./clipboard.test-fixture"
 
 describe("copyToClipboard fallback", () => {
   it("restores focus and removes its temporary textarea", async () => {
@@ -28,44 +29,30 @@ describe("copyToClipboard fallback", () => {
       state.restore()
     }
   })
-})
-
-function installClipboardFallbackDom(execCommand: () => boolean) {
-  const navigatorDescriptor = Object.getOwnPropertyDescriptor(globalThis, "navigator")
-  const documentDescriptor = Object.getOwnPropertyDescriptor(globalThis, "document")
-  let removed = false
-  let focusRestored = false
-  const textArea = {
-    value: "",
-    readOnly: false,
-    style: {} as CSSStyleDeclaration,
-    focus() {},
-    select() {},
-    remove() { removed = true },
-  }
-  const activeElement = { focus() { focusRestored = true } }
-  const documentMock = {
-    activeElement,
-    createElement: () => textArea,
-    body: { appendChild() {} },
-    execCommand,
-  }
-
-  Object.defineProperty(globalThis, "navigator", { configurable: true, value: {} })
-  Object.defineProperty(globalThis, "document", { configurable: true, value: documentMock })
 
-  return {
-    textArea,
-    removed: () => removed,
-    focusRestored: () => focusRestored,
-    restore() {
-      restoreGlobal("navigator", navigatorDescriptor)
-      restoreGlobal("document", documentDescriptor)
-    },
-  }
-}
+  it("checks authority after fallback focus handlers before dispatching execCommand", async () => {
+    let writes = 0
+    const state = installClipboardFallbackDom(() => { writes++; return true })
+    const controller = new AbortController()
+    state.textArea.focus = () => controller.abort()
+    try {
+      assert.equal(await copyToClipboard("obsolete", { signal: controller.signal }), false)
+      assert.equal(writes, 0)
+      assert.equal(state.removed(), true)
+    } finally { state.restore() }
+  })
 
-function restoreGlobal(name: "navigator" | "document", descriptor?: PropertyDescriptor) {
-  if (descriptor) Object.defineProperty(globalThis, name, descriptor)
-  else Reflect.deleteProperty(globalThis, name)
-}
+  it("does not dispatch any strategy with an aborted signal or expired authority", async () => {
+    let writes = 0
+    const state = installClipboardFallbackDom(() => { writes++; return true }, {
+      write: async () => { writes++ }, writeText: async () => { writes++ },
+    })
+    try {
+      for (const options of [{ signal: AbortSignal.abort() }, { isCurrent: () => false }]) {
+        assert.equal(await copyTextChunksToClipboard(["obsolete"], options), false)
+        assert.equal(await copyToClipboard("obsolete", options), false)
+      }
+      assert.equal(writes, 0)
+    } finally { state.restore() }
+  })
+})
diff --git a/packages/ui/src/lib/clipboard.ts b/packages/ui/src/lib/clipboard.ts
index 61defe99c..0fe043d3e 100644
--- a/packages/ui/src/lib/clipboard.ts
+++ b/packages/ui/src/lib/clipboard.ts
@@ -8,23 +8,36 @@ import { getLogger } from "./logger"
 
 const log = getLogger("actions")
 
+export interface ClipboardCopyOptions {
+  signal?: AbortSignal
+  isCurrent?: () => boolean
+}
+
+function canCopy(options?: ClipboardCopyOptions): boolean {
+  return !options?.signal?.aborted && options?.isCurrent?.() !== false
+}
+
 /**
  * Copy text to clipboard with fallback for non-secure contexts
  * @param text - The text to copy
  * @returns Promise<boolean> - true if successful, false if failed
  */
-export async function copyToClipboard(text: string): Promise<boolean> {
+export async function copyToClipboard(text: string, options?: ClipboardCopyOptions): Promise<boolean> {
+  if (!canCopy(options)) return false
   try {
     // Try modern Clipboard API first (requires secure context)
     if (typeof navigator !== "undefined" && navigator.clipboard && navigator.clipboard.writeText) {
+      if (!canCopy(options)) return false
       await navigator.clipboard.writeText(text)
       log.info("Copied text using Clipboard API")
       return true
     }
   } catch (error) {
+    if (!canCopy(options)) return false
     log.warn("Clipboard API failed, trying fallback:", error)
   }
 
+  if (!canCopy(options)) return false
   // Fallback for non-secure contexts (HTTP) using document.execCommand
   let textArea: HTMLTextAreaElement | undefined
   const activeElement = typeof document !== "undefined" ? document.activeElement as HTMLElement | null : null
@@ -47,6 +60,8 @@ export async function copyToClipboard(text: string): Promise<boolean> {
     textArea.focus()
     textArea.select()
 
+    // Focus/selection handlers can invalidate the owner synchronously too.
+    if (!canCopy(options)) return false
     const success = document.execCommand("copy")
     if (success) {
       log.info("Copied text using execCommand fallback")
@@ -71,3 +86,21 @@ export async function copyToClipboard(text: string): Promise<boolean> {
     }
   }
 }
+
+export async function copyTextChunksToClipboard(chunks: readonly string[], options?: ClipboardCopyOptions): Promise<boolean> {
+  if (!canCopy(options)) return false
+  try {
+    if (typeof navigator !== "undefined" && navigator.clipboard?.write && typeof ClipboardItem !== "undefined") {
+      const item = new ClipboardItem({ "text/plain": new Blob([...chunks], { type: "text/plain" }) })
+      if (!canCopy(options)) return false
+      await navigator.clipboard.write([item])
+      log.info("Copied text chunks using Clipboard API")
+      return true
+    }
+  } catch (error) {
+    if (!canCopy(options)) return false
+    log.warn("Clipboard chunk write failed, trying text fallback:", error)
+  }
+  if (!canCopy(options)) return false
+  return copyToClipboard(chunks.join(""), options)
+}
diff --git a/packages/ui/src/lib/global-cache.test.ts b/packages/ui/src/lib/global-cache.test.ts
new file mode 100644
index 000000000..70c2b5e1d
--- /dev/null
+++ b/packages/ui/src/lib/global-cache.test.ts
@@ -0,0 +1,41 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { captureCacheAuthority, clearCacheForInstance, clearCacheForSession, getCacheEntry, onCacheSessionChanged, setCacheEntry } from "./global-cache.ts"
+
+test("rejects stale writes and evicts the globally oldest cache entries", () => {
+  const entry = { instanceId: "cache", sessionId: "stale", scope: "render", cacheId: "value", version: "1" }
+  const authority = captureCacheAuthority(entry)
+  const changed: string[] = []
+  const stop = onCacheSessionChanged((instanceId, sessionId) => changed.push(`${instanceId}/${sessionId}`))
+  try {
+    clearCacheForSession(entry.instanceId, entry.sessionId)
+    setCacheEntry(entry, "stale", authority)
+    assert.equal(getCacheEntry(entry), undefined)
+
+    for (let index = 0; index < 11; index += 1) {
+      setCacheEntry({ ...entry, sessionId: `session-${index}` }, "x".repeat(1_500_000))
+    }
+    changed.length = 0
+    setCacheEntry({ ...entry, sessionId: "trigger" }, "x".repeat(1_500_000))
+    assert.ok(changed.includes("cache/session-0"))
+    assert.equal(getCacheEntry({ ...entry, sessionId: "session-0" }), undefined)
+    assert.notEqual(getCacheEntry({ ...entry, sessionId: "session-10" }), undefined)
+  } finally {
+    stop()
+    clearCacheForInstance(entry.instanceId)
+  }
+})
+
+test("does not double-subtract an entry while replacing it", () => {
+  const entry = { instanceId: "replace", scope: "render", cacheId: "value", version: "1" }
+  try {
+    for (let index = 0; index < 15; index += 1) {
+      setCacheEntry({ ...entry, sessionId: `session-${index}` }, "x".repeat(1_060_000))
+    }
+    setCacheEntry({ ...entry, sessionId: "session-0" }, "x".repeat(2_000_000))
+    assert.equal(getCacheEntry({ ...entry, sessionId: "session-1" }), undefined)
+  } finally {
+    clearCacheForInstance(entry.instanceId)
+  }
+})
diff --git a/packages/ui/src/lib/global-cache.ts b/packages/ui/src/lib/global-cache.ts
index 1a5cb2575..fbdaf0627 100644
--- a/packages/ui/src/lib/global-cache.ts
+++ b/packages/ui/src/lib/global-cache.ts
@@ -1,3 +1,5 @@
+import { estimateRetainedBytes } from "./retained-size"
+
 export interface CacheEntryBaseParams {
   instanceId?: string
   sessionId?: string
@@ -9,9 +11,22 @@ export interface CacheEntryParams extends CacheEntryBaseParams {
   version: string
 }
 
+export interface CacheAuthority {
+  instanceKey: string
+  sessionKey: string
+  scope: string
+  cacheId: string
+  version: string
+  generation: number
+  writeToken: number
+}
+
 type VersionedCacheEntry = {
   version: string
   value: unknown
+  byteSize: number
+  keyBytes: number
+  accessedAt: number
 }
 
 type CacheValueMap = Map<string, VersionedCacheEntry>
@@ -19,12 +34,105 @@ type CacheScopeMap = Map<string, CacheValueMap>
 type CacheSessionMap = Map<string, CacheScopeMap>
 
 const GLOBAL_KEY = "GLOBAL"
+const MAX_SCOPE_CACHE_ENTRIES = 64
+const MAX_CACHE_ENTRY_BYTES = 4 * 1024 * 1024
+const MAX_GLOBAL_CACHE_BYTES = 32 * 1024 * 1024
+const MAX_GLOBAL_CACHE_ENTRIES = 4_096
 const cacheStore = new Map<string, CacheSessionMap>()
+let cacheGeneration = 0
+let writeSequence = 0
+const pendingWrites = new Map<string, number>()
+const pendingAuthorityByParams = new WeakMap<CacheEntryParams, CacheAuthority>()
+const cacheSessionChangeHandlers = new Set<(instanceId: string, sessionId: string) => void>()
+let retainedBytes = 0
+let retainedEntries = 0
+let accessSequence = 0
+
+function recalculateRetainedSize(): void {
+  retainedBytes = 0
+  retainedEntries = 0
+  for (const sessionMap of cacheStore.values()) {
+    for (const scopeMap of sessionMap.values()) {
+      for (const valueMap of scopeMap.values()) {
+        for (const entry of valueMap.values()) {
+          retainedBytes += entry.byteSize
+          retainedEntries += 1
+        }
+      }
+    }
+  }
+}
 
 function resolveKey(value?: string) {
   return value && value.length > 0 ? value : GLOBAL_KEY
 }
 
+function writeKey(instanceKey: string, sessionKey: string, scope: string, cacheId: string): string {
+  return `${instanceKey}\u0000${sessionKey}\u0000${scope}\u0000${cacheId}`
+}
+
+function invalidateAllPendingWrites(): void {
+  cacheGeneration += 1
+  pendingWrites.clear()
+}
+
+function invalidatePendingWrite(instanceKey: string, sessionKey: string, scope: string, cacheId: string): void {
+  pendingWrites.delete(writeKey(instanceKey, sessionKey, scope, cacheId))
+}
+
+function notifyCacheSessionChanged(params: CacheEntryBaseParams): void {
+  if (!params.instanceId || !params.sessionId) return
+  for (const handler of cacheSessionChangeHandlers) handler(params.instanceId, params.sessionId)
+}
+
+export function onCacheSessionChanged(handler: (instanceId: string, sessionId: string) => void): () => void {
+  cacheSessionChangeHandlers.add(handler)
+  return () => cacheSessionChangeHandlers.delete(handler)
+}
+
+export function* getCacheRetainedEntriesForSession(instanceId: string, sessionId: string): Generator<{ value: unknown; keyBytes: number }> {
+  const scopeMap = cacheStore.get(resolveKey(instanceId))?.get(resolveKey(sessionId))
+  if (!scopeMap) return
+  for (const valueMap of scopeMap.values()) {
+    for (const entry of valueMap.values()) yield { value: entry.value, keyBytes: entry.keyBytes }
+  }
+}
+
+export function captureCacheAuthority(params: CacheEntryParams): CacheAuthority {
+  const instanceKey = resolveKey(params.instanceId)
+  const sessionKey = resolveKey(params.sessionId)
+  const scopePrefix = `${instanceKey}\u0000${sessionKey}\u0000${params.scope}\u0000`
+  const currentKey = writeKey(instanceKey, sessionKey, params.scope, params.cacheId)
+  const scopeWrites = [...pendingWrites.keys()].filter((key) => key.startsWith(scopePrefix) && key !== currentKey)
+  if (scopeWrites.length >= MAX_SCOPE_CACHE_ENTRIES) pendingWrites.delete(scopeWrites[0]!)
+  if (pendingWrites.size >= MAX_GLOBAL_CACHE_ENTRIES && !pendingWrites.has(currentKey)) invalidateAllPendingWrites()
+  const writeToken = ++writeSequence
+  pendingWrites.set(currentKey, writeToken)
+  const authority = {
+    instanceKey,
+    sessionKey,
+    scope: params.scope,
+    cacheId: params.cacheId,
+    version: params.version,
+    generation: cacheGeneration,
+    writeToken,
+  }
+  pendingAuthorityByParams.set(params, authority)
+  return authority
+}
+
+function hasCacheAuthority(params: CacheEntryParams, authority: CacheAuthority): boolean {
+  const instanceKey = resolveKey(params.instanceId)
+  const sessionKey = resolveKey(params.sessionId)
+  return instanceKey === authority.instanceKey
+    && sessionKey === authority.sessionKey
+    && params.scope === authority.scope
+    && params.cacheId === authority.cacheId
+    && params.version === authority.version
+    && cacheGeneration === authority.generation
+    && pendingWrites.get(writeKey(instanceKey, sessionKey, params.scope, params.cacheId)) === authority.writeToken
+}
+
 function getScopeValueMap(params: CacheEntryParams, create: boolean): CacheValueMap | undefined {
   const instanceKey = resolveKey(params.instanceId)
   const sessionKey = resolveKey(params.sessionId)
@@ -83,54 +191,127 @@ function cleanupHierarchy(instanceKey: string, sessionKey: string, scopeKey?: st
   }
 }
 
-export function setCacheEntry<T>(params: CacheEntryParams, value: T | undefined): void {
+function evictOldestCacheEntry(): boolean {
+  let oldest: { instanceKey: string; sessionKey: string; scope: string; cacheId: string; entry: VersionedCacheEntry } | undefined
+  for (const [instanceKey, sessionMap] of cacheStore) {
+    for (const [sessionKey, scopeMap] of sessionMap) {
+      for (const [scope, valueMap] of scopeMap) {
+        for (const [cacheId, entry] of valueMap) {
+          if (!oldest || entry.accessedAt < oldest.entry.accessedAt) oldest = { instanceKey, sessionKey, scope, cacheId, entry }
+        }
+      }
+    }
+  }
+  if (!oldest) return false
+  cacheStore.get(oldest.instanceKey)?.get(oldest.sessionKey)?.get(oldest.scope)?.delete(oldest.cacheId)
+  retainedBytes -= oldest.entry.byteSize
+  retainedEntries -= 1
+  invalidatePendingWrite(oldest.instanceKey, oldest.sessionKey, oldest.scope, oldest.cacheId)
+  cleanupHierarchy(oldest.instanceKey, oldest.sessionKey, oldest.scope)
+  if (oldest.instanceKey !== GLOBAL_KEY && oldest.sessionKey !== GLOBAL_KEY) {
+    notifyCacheSessionChanged({ instanceId: oldest.instanceKey, sessionId: oldest.sessionKey, scope: oldest.scope })
+  }
+  return true
+}
+
+export function setCacheEntry<T>(params: CacheEntryParams, value: T | undefined, authority?: CacheAuthority): void {
   const instanceKey = resolveKey(params.instanceId)
   const sessionKey = resolveKey(params.sessionId)
+  const resolvedAuthority = authority ?? pendingAuthorityByParams.get(params)
+  pendingAuthorityByParams.delete(params)
+  if (resolvedAuthority && !hasCacheAuthority(params, resolvedAuthority)) return
+  invalidatePendingWrite(instanceKey, sessionKey, params.scope, params.cacheId)
 
   if (value === undefined) {
     const existingMap = getScopeValueMap(params, false)
+    const existing = existingMap?.get(params.cacheId)
+    retainedBytes -= existing?.byteSize ?? 0
+    if (existing) retainedEntries -= 1
     existingMap?.delete(params.cacheId)
     cleanupHierarchy(instanceKey, sessionKey, params.scope)
+    if (existing) notifyCacheSessionChanged(params)
     return
   }
 
-  const scopeEntries = getScopeValueMap(params, true)
-  scopeEntries?.set(params.cacheId, { version: params.version, value })
+  const scopeEntries = getScopeValueMap(params, false)
+  const existing = scopeEntries?.get(params.cacheId)
+  retainedBytes -= existing?.byteSize ?? 0
+  if (existing) retainedEntries -= 1
+  scopeEntries?.delete(params.cacheId)
+  const keyBytes = [params.instanceId, params.sessionId, params.scope, params.cacheId, params.version]
+    .reduce((total, part) => total + (part?.length ?? 0) * 2 + 16, 0)
+  const byteSize = estimateRetainedBytes(value, MAX_CACHE_ENTRY_BYTES) + keyBytes
+  if (byteSize > MAX_CACHE_ENTRY_BYTES) {
+    scopeEntries?.delete(params.cacheId)
+    cleanupHierarchy(instanceKey, sessionKey, params.scope)
+    if (existing) notifyCacheSessionChanged(params)
+    return
+  }
+  while (retainedBytes + byteSize > MAX_GLOBAL_CACHE_BYTES || retainedEntries >= MAX_GLOBAL_CACHE_ENTRIES) {
+    if (!evictOldestCacheEntry()) break
+  }
+  const target = getScopeValueMap(params, true)
+  if (!target) return
+  target.delete(params.cacheId)
+  target.set(params.cacheId, { version: params.version, value, byteSize, keyBytes, accessedAt: ++accessSequence })
+  retainedBytes += byteSize
+  retainedEntries += 1
+  while (target.size > MAX_SCOPE_CACHE_ENTRIES) {
+    const oldest = target.keys().next().value
+    if (oldest === undefined) break
+    retainedBytes -= target.get(oldest)?.byteSize ?? 0
+    target.delete(oldest)
+    retainedEntries -= 1
+    invalidatePendingWrite(instanceKey, sessionKey, params.scope, oldest)
+  }
+  notifyCacheSessionChanged(params)
 }
 
 export function getCacheEntry<T>(params: CacheEntryParams): T | undefined {
   const scopeEntries = getScopeValueMap(params, false)
   const entry = scopeEntries?.get(params.cacheId)
   if (!entry || entry.version !== params.version) {
+    captureCacheAuthority(params)
     return undefined
   }
+  invalidatePendingWrite(resolveKey(params.instanceId), resolveKey(params.sessionId), params.scope, params.cacheId)
+  scopeEntries!.delete(params.cacheId)
+  entry.accessedAt = ++accessSequence
+  scopeEntries!.set(params.cacheId, entry)
+  captureCacheAuthority(params)
   return entry.value as T
 }
 
 export function clearCacheScope(params: CacheEntryBaseParams): void {
   const instanceKey = resolveKey(params.instanceId)
   const sessionKey = resolveKey(params.sessionId)
+  invalidateAllPendingWrites()
   const sessionMap = cacheStore.get(instanceKey)
   if (!sessionMap) return
   const scopeMap = sessionMap.get(sessionKey)
   if (!scopeMap) return
   scopeMap.delete(params.scope)
   cleanupHierarchy(instanceKey, sessionKey)
+  recalculateRetainedSize()
 }
 
 export function clearCacheForSession(instanceId?: string, sessionId?: string): void {
   const instanceKey = resolveKey(instanceId)
   const sessionKey = resolveKey(sessionId)
+  invalidateAllPendingWrites()
   const sessionMap = cacheStore.get(instanceKey)
   if (!sessionMap) return
   sessionMap.delete(sessionKey)
   if (sessionMap.size === 0) {
     cacheStore.delete(instanceKey)
   }
+  recalculateRetainedSize()
 }
 
 export function clearCacheForInstance(instanceId?: string): void {
   const instanceKey = resolveKey(instanceId)
+  invalidateAllPendingWrites()
   cacheStore.delete(instanceKey)
+  recalculateRetainedSize()
 }
 
diff --git a/packages/ui/src/lib/hooks/use-active-session-message-load.test.ts b/packages/ui/src/lib/hooks/use-active-session-message-load.test.ts
index c0afc2f7f..b24e3ee52 100644
--- a/packages/ui/src/lib/hooks/use-active-session-message-load.test.ts
+++ b/packages/ui/src/lib/hooks/use-active-session-message-load.test.ts
@@ -169,4 +169,5 @@ describe("useActiveSessionMessageLoad", () => {
       dispose()
     }
   })
+
 })
diff --git a/packages/ui/src/lib/hooks/use-active-session-message-load.ts b/packages/ui/src/lib/hooks/use-active-session-message-load.ts
index d91a27f99..d821be065 100644
--- a/packages/ui/src/lib/hooks/use-active-session-message-load.ts
+++ b/packages/ui/src/lib/hooks/use-active-session-message-load.ts
@@ -1,4 +1,4 @@
-import { createEffect, createMemo, onCleanup } from "solid-js"
+import { createEffect, createMemo, createSignal, onCleanup, untrack } from "solid-js"
 
 /**
  * Dependencies for {@link useActiveSessionMessageLoad}. Everything is injected
@@ -13,11 +13,17 @@ export interface ActiveSessionMessageLoadDeps {
   instanceId: () => string
   /** The current session object (or undefined). Read reactively. */
   session: () => { id: string } | undefined
+  /** Optional reactive gate. Each false-to-true transition reloads the same session. */
+  shouldLoad?: () => boolean
   /** Loads the messages for a session. */
-  loadMessages: (instanceId: string, sessionId: string, options?: {
-    signal?: AbortSignal
-    registerInvalidation?: (invalidate: () => void) => void
-  }) => Promise<void> | void
+  loadMessages: (
+    instanceId: string,
+    sessionId: string,
+    options?: {
+      signal?: AbortSignal
+      registerInvalidation?: (invalidate: () => void) => void
+    },
+  ) => Promise<unknown> | void
   /** Resolves once the instance's workspace metadata has hydrated. */
   waitForHydration: (instanceId: string) => Promise<void>
   /** Optional error sink for a rejected load. */
@@ -41,11 +47,28 @@ export interface ActiveSessionMessageLoadDeps {
  * preserving load-on-activation and load-on-switch behavior.
  */
 export function useActiveSessionMessageLoad(deps: ActiveSessionMessageLoadDeps): void {
-  const activeSessionId = createMemo(() => (deps.isActive() ? (deps.session()?.id ?? null) : null))
+  const activeBinding = createMemo(() => {
+    const sessionId = deps.isActive() ? deps.session()?.id : undefined
+    return sessionId ? `${deps.instanceId()}\u0000${sessionId}` : null
+  })
+  const [reloadVersion, setReloadVersion] = createSignal(0)
+  let previousLoadBinding: string | null = null
+  createEffect(() => {
+    if (!deps.shouldLoad) return
+    const binding = activeBinding()
+    const loadBinding = binding && deps.shouldLoad() ? binding : null
+    if (loadBinding && loadBinding !== previousLoadBinding) setReloadVersion((value) => value + 1)
+    previousLoadBinding = loadBinding
+  })
+
   createEffect(() => {
-    const sessionId = activeSessionId()
-    if (!sessionId) return
-    const instanceId = deps.instanceId()
+    const binding = activeBinding()
+    if (deps.shouldLoad) {
+      reloadVersion()
+      if (!untrack(deps.shouldLoad)) return
+    }
+    if (!binding) return
+    const [instanceId, sessionId] = binding.split("\u0000")
     const controller = new AbortController()
     let invalidate: (() => void) | undefined
     let settled = false
@@ -59,10 +82,14 @@ export function useActiveSessionMessageLoad(deps: ActiveSessionMessageLoadDeps):
       .then(() => {
         // Re-check after the async gate: the user may have switched away or to
         // a different session while metadata was hydrating.
-        if (controller.signal.aborted || !deps.isActive() || deps.session()?.id !== sessionId) return
-        return deps.loadMessages(instanceId, sessionId, {
+        if (controller.signal.aborted
+          || !deps.isActive()
+          || deps.instanceId() !== instanceId
+          || deps.session()?.id !== sessionId
+          || (deps.shouldLoad && !untrack(deps.shouldLoad))) return
+        return Promise.resolve(deps.loadMessages(instanceId, sessionId, {
           signal: controller.signal, registerInvalidation: callback => { invalidate = callback },
-        })
+        }))
       })
       .catch((error) => { if (!controller.signal.aborted) deps.onError?.(error) })
       .finally(() => { settled = true })
diff --git a/packages/ui/src/lib/hooks/use-commands.ts b/packages/ui/src/lib/hooks/use-commands.ts
index 606cdd357..95d70409b 100644
--- a/packages/ui/src/lib/hooks/use-commands.ts
+++ b/packages/ui/src/lib/hooks/use-commands.ts
@@ -22,7 +22,7 @@ import { tGlobal } from "../i18n"
 import { registerBehaviorCommands } from "../settings/behavior-registry"
 import { canOpenWorkspacePaths, openWorkspacePath, type WorkspaceEditor, type WorkspaceOpenTarget } from "../workspace-open"
 import { getDefaultWorktreeSlug, getWorktreeSlugForSession } from "../../stores/worktrees"
-import { executeSessionTechnicalPartDeletion, planSessionTechnicalPartDeletion, stageSessionRevert } from "../../stores/session-actions"
+import { compactSession, executeSessionTechnicalPartDeletion, planSessionTechnicalPartDeletion, stageSessionRevert } from "../../stores/session-actions"
 import { beginSessionCleanup } from "../../stores/session-cleanup-progress"
 
 const log = getLogger("actions")
@@ -328,7 +328,7 @@ export function useCommands(options: UseCommandsOptions) {
         if (!session) return
 
         try {
-          await instance.client.session.compact({ sessionID: sessionId })
+          await compactSession(instance.id, sessionId)
         } catch (error) {
           log.error("Failed to compact session", error)
           const message = error instanceof Error ? error.message : tGlobal("commands.compactSession.errorFallback")
diff --git a/packages/ui/src/lib/hooks/use-global-cache.ts b/packages/ui/src/lib/hooks/use-global-cache.ts
index b3ba1aae4..fe9eebbf8 100644
--- a/packages/ui/src/lib/hooks/use-global-cache.ts
+++ b/packages/ui/src/lib/hooks/use-global-cache.ts
@@ -1,6 +1,8 @@
 import { type Accessor, createMemo } from "solid-js"
 import {
+  type CacheAuthority,
   type CacheEntryParams,
+  captureCacheAuthority,
   getCacheEntry,
   setCacheEntry,
   clearCacheScope,
@@ -14,6 +16,7 @@ import {
  * automatically fall back to the global buckets.
  */
 export function useGlobalCache(params: UseGlobalCacheParams): GlobalCacheHandle {
+  let pendingAuthority: CacheAuthority | undefined
   const resolvedEntry = createMemo<CacheEntryParams>(() => {
     const instanceId = normalizeId(resolveValue(params.instanceId))
     const sessionId = normalizeId(resolveValue(params.sessionId))
@@ -35,10 +38,12 @@ export function useGlobalCache(params: UseGlobalCacheParams): GlobalCacheHandle
 
   return {
     get<T>() {
-      return getCacheEntry<T>(resolvedEntry())
+      const entry = resolvedEntry()
+      return getCacheEntry<T>(entry)
     },
-    set<T>(value: T | undefined) {
-      setCacheEntry(resolvedEntry(), value)
+    set<T>(value: T | undefined, authority?: CacheAuthority) {
+      setCacheEntry(resolvedEntry(), value, authority ?? pendingAuthority)
+      pendingAuthority = undefined
     },
     clearScope() {
       clearCacheScope(scopeParams())
@@ -54,6 +59,9 @@ export function useGlobalCache(params: UseGlobalCacheParams): GlobalCacheHandle
     params() {
       return resolvedEntry()
     },
+    authority() {
+      return pendingAuthority = captureCacheAuthority(resolvedEntry())
+    },
   }
 }
 
@@ -80,9 +88,10 @@ interface UseGlobalCacheParams {
 
 interface GlobalCacheHandle {
   get<T>(): T | undefined
-  set<T>(value: T | undefined): void
+  set<T>(value: T | undefined, authority?: CacheAuthority): void
   clearScope(): void
   clearSession(): void
   clearInstance(): void
   params(): CacheEntryParams
+  authority(): CacheAuthority
 }
diff --git a/packages/ui/src/lib/i18n/messages/de/toolCall.ts b/packages/ui/src/lib/i18n/messages/de/toolCall.ts
index 33e42ec6f..60abe9331 100644
--- a/packages/ui/src/lib/i18n/messages/de/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/de/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "Verzeichnis wird aufgelistet...",
 
   "toolCall.renderer.bash.title.timeout": "Zeitüberschreitung: {timeout}",
+  "toolCall.output.truncated": "[Ausgabe für die Darstellung gekürzt; kopieren Sie sie für die vollständige Ausgabe]",
+  "toolCall.output.tooLarge": "Die strukturierte Ausgabe wird nicht dargestellt, da sie zu groß ist.",
+  "toolCall.task.steps.truncated": "Die neuesten {count} Schritte werden angezeigt; ältere Schritte wurden ausgelassen.",
   "toolCall.renderer.read.detail.offset": "Offset: {offset}",
   "toolCall.renderer.read.detail.limit": "Limit: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} Datei)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} Dateien)",
   "toolCall.applyPatch.fileFallback": "Datei {number}",
+  "toolCall.permission.diff.previous": "Vorherige Diff-Seite",
+  "toolCall.permission.diff.next": "Nächste Diff-Seite",
+  "toolCall.permission.diff.page": "Seite {page} von {total}",
+  "toolCall.permission.diff.reviewRequired": "Prüfen Sie jede Seite oder kopieren Sie den vollständigen Patch, um die Genehmigung zu ermöglichen.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/en/toolCall.ts b/packages/ui/src/lib/i18n/messages/en/toolCall.ts
index 3bb657c01..3d9e18b1a 100644
--- a/packages/ui/src/lib/i18n/messages/en/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/en/toolCall.ts
@@ -29,6 +29,10 @@ export const toolCallMessages = {
   "toolCall.diff.enableWordWrap": "Enable word wrap",
   "toolCall.diff.disableWordWrap": "Disable word wrap",
   "toolCall.diff.copyPatch": "Copy patch",
+  "toolCall.permission.diff.previous": "Previous diff page",
+  "toolCall.permission.diff.next": "Next diff page",
+  "toolCall.permission.diff.page": "Page {page} of {total}",
+  "toolCall.permission.diff.reviewRequired": "Review every page or copy the complete patch to enable approval.",
 
   "toolCall.diagnostics.title": "Diagnostics",
   "toolCall.diagnostics.ariaLabel": "Diagnostics",
@@ -56,6 +60,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "Listing directory...",
 
   "toolCall.renderer.bash.title.timeout": "Timeout: {timeout}",
+  "toolCall.output.truncated": "[Output truncated for rendering; copy to access the full output]",
+  "toolCall.output.tooLarge": "Structured output omitted from rendering because it is too large.",
+  "toolCall.task.steps.truncated": "Showing the most recent {count} steps; older steps are omitted.",
   "toolCall.renderer.read.detail.offset": "Offset: {offset}",
   "toolCall.renderer.read.detail.limit": "Limit: {limit}",
 
diff --git a/packages/ui/src/lib/i18n/messages/es/toolCall.ts b/packages/ui/src/lib/i18n/messages/es/toolCall.ts
index a04eb7b10..9319e1a86 100644
--- a/packages/ui/src/lib/i18n/messages/es/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/es/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "Listando directorio...",
 
   "toolCall.renderer.bash.title.timeout": "Tiempo de espera: {timeout}",
+  "toolCall.output.truncated": "[Salida truncada para la visualización; cópiala para acceder a la salida completa]",
+  "toolCall.output.tooLarge": "La salida estructurada no se muestra porque es demasiado grande.",
+  "toolCall.task.steps.truncated": "Se muestran los {count} pasos más recientes; se omiten los anteriores.",
   "toolCall.renderer.read.detail.offset": "Desplazamiento: {offset}",
   "toolCall.renderer.read.detail.limit": "Límite: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} archivo)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} archivos)",
   "toolCall.applyPatch.fileFallback": "Archivo {number}",
+  "toolCall.permission.diff.previous": "Página anterior del diff",
+  "toolCall.permission.diff.next": "Página siguiente del diff",
+  "toolCall.permission.diff.page": "Página {page} de {total}",
+  "toolCall.permission.diff.reviewRequired": "Revise todas las páginas o copie el parche completo para habilitar la aprobación.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/fr/toolCall.ts b/packages/ui/src/lib/i18n/messages/fr/toolCall.ts
index 3e8ff28c9..399025c43 100644
--- a/packages/ui/src/lib/i18n/messages/fr/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "Liste du répertoire...",
 
   "toolCall.renderer.bash.title.timeout": "Délai : {timeout}",
+  "toolCall.output.truncated": "[Sortie tronquée pour l’affichage ; copiez-la pour accéder à la sortie complète]",
+  "toolCall.output.tooLarge": "Sortie structurée omise de l’affichage car elle est trop volumineuse.",
+  "toolCall.task.steps.truncated": "Affichage des {count} étapes les plus récentes ; les étapes antérieures sont omises.",
   "toolCall.renderer.read.detail.offset": "Décalage : {offset}",
   "toolCall.renderer.read.detail.limit": "Limite : {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} fichier)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} fichiers)",
   "toolCall.applyPatch.fileFallback": "Fichier {number}",
+  "toolCall.permission.diff.previous": "Page précédente du diff",
+  "toolCall.permission.diff.next": "Page suivante du diff",
+  "toolCall.permission.diff.page": "Page {page} sur {total}",
+  "toolCall.permission.diff.reviewRequired": "Consultez chaque page ou copiez le correctif complet pour activer l’approbation.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/he/toolCall.ts b/packages/ui/src/lib/i18n/messages/he/toolCall.ts
index f282f619f..fad29d236 100644
--- a/packages/ui/src/lib/i18n/messages/he/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/he/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "מפרט ספרייה...",
 
   "toolCall.renderer.bash.title.timeout": "פסק זמן: {timeout}",
+  "toolCall.output.truncated": "[הפלט קוצר לצורך תצוגה; יש להעתיק כדי לגשת לפלט המלא]",
+  "toolCall.output.tooLarge": "הפלט המובנה לא מוצג מכיוון שהוא גדול מדי.",
+  "toolCall.task.steps.truncated": "מוצגים {count} השלבים האחרונים; שלבים קודמים הושמטו.",
   "toolCall.renderer.read.detail.offset": "היסט: {offset}",
   "toolCall.renderer.read.detail.limit": "מגבלה: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} קובץ)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} קבצים)",
   "toolCall.applyPatch.fileFallback": "קובץ {number}",
+  "toolCall.permission.diff.previous": "עמוד ההבדלים הקודם",
+  "toolCall.permission.diff.next": "עמוד ההבדלים הבא",
+  "toolCall.permission.diff.page": "עמוד {page} מתוך {total}",
+  "toolCall.permission.diff.reviewRequired": "יש לעיין בכל העמודים או להעתיק את התיקון המלא כדי לאפשר אישור.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/ja/toolCall.ts b/packages/ui/src/lib/i18n/messages/ja/toolCall.ts
index 2bcc9c078..0e4424555 100644
--- a/packages/ui/src/lib/i18n/messages/ja/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "ディレクトリ一覧を取得中...",
 
   "toolCall.renderer.bash.title.timeout": "タイムアウト: {timeout}",
+  "toolCall.output.truncated": "[表示用に出力を省略しました。完全な出力にアクセスするにはコピーしてください]",
+  "toolCall.output.tooLarge": "構造化出力が大きすぎるため表示を省略しました。",
+  "toolCall.task.steps.truncated": "最新の{count}件の手順を表示しています。以前の手順は省略されています。",
   "toolCall.renderer.read.detail.offset": "オフセット: {offset}",
   "toolCall.renderer.read.detail.limit": "上限: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} 件のファイル)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} 件のファイル)",
   "toolCall.applyPatch.fileFallback": "ファイル {number}",
+  "toolCall.permission.diff.previous": "差分の前のページ",
+  "toolCall.permission.diff.next": "差分の次のページ",
+  "toolCall.permission.diff.page": "{total} ページ中 {page} ページ",
+  "toolCall.permission.diff.reviewRequired": "すべてのページを確認するか、パッチ全体をコピーすると承認できます。",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/ne/toolCall.ts b/packages/ui/src/lib/i18n/messages/ne/toolCall.ts
index 2d6089fe2..ee7170466 100644
--- a/packages/ui/src/lib/i18n/messages/ne/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/ne/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "डाइरेक्टरी सूचीबद्ध गर्दै...",
 
   "toolCall.renderer.bash.title.timeout": "समय समाप्त: {timeout}",
+  "toolCall.output.truncated": "[प्रदर्शनका लागि आउटपुट छोट्याइएको छ; पूर्ण आउटपुटका लागि प्रतिलिपि गर्नुहोस्]",
+  "toolCall.output.tooLarge": "संरचित आउटपुट धेरै ठूलो भएकाले प्रदर्शन गरिएको छैन।",
+  "toolCall.task.steps.truncated": "पछिल्ला {count} चरणहरू देखाइँदैछन्; पुराना चरणहरू हटाइएका छन्।",
   "toolCall.renderer.read.detail.offset": "अफसेट: {offset}",
   "toolCall.renderer.read.detail.limit": "सीमा: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} फाइल)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} फाइलहरू)",
   "toolCall.applyPatch.fileFallback": "फाइल {number}",
+  "toolCall.permission.diff.previous": "भिन्नताको अघिल्लो पृष्ठ",
+  "toolCall.permission.diff.next": "भिन्नताको अर्को पृष्ठ",
+  "toolCall.permission.diff.page": "{total} मध्ये पृष्ठ {page}",
+  "toolCall.permission.diff.reviewRequired": "स्वीकृति सक्षम गर्न हरेक पृष्ठ समीक्षा गर्नुहोस् वा सम्पूर्ण प्याच प्रतिलिपि गर्नुहोस्।",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/ru/toolCall.ts b/packages/ui/src/lib/i18n/messages/ru/toolCall.ts
index ddf2ddd06..30e193e0a 100644
--- a/packages/ui/src/lib/i18n/messages/ru/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "Просмотр каталога…",
 
   "toolCall.renderer.bash.title.timeout": "Таймаут: {timeout}",
+  "toolCall.output.truncated": "[Вывод сокращён для отображения; скопируйте его для доступа к полному выводу]",
+  "toolCall.output.tooLarge": "Структурированный вывод не отображается, поскольку он слишком большой.",
+  "toolCall.task.steps.truncated": "Показаны последние {count} шагов; более ранние шаги опущены.",
   "toolCall.renderer.read.detail.offset": "Смещение: {offset}",
   "toolCall.renderer.read.detail.limit": "Лимит: {limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool} ({count} файл)",
   "toolCall.applyPatch.title.withFileCount.other": "{tool} ({count} файлов)",
   "toolCall.applyPatch.fileFallback": "Файл {number}",
+  "toolCall.permission.diff.previous": "Предыдущая страница изменений",
+  "toolCall.permission.diff.next": "Следующая страница изменений",
+  "toolCall.permission.diff.page": "Страница {page} из {total}",
+  "toolCall.permission.diff.reviewRequired": "Просмотрите все страницы или скопируйте полный патч, чтобы разрешить одобрение.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/tr/toolCall.ts b/packages/ui/src/lib/i18n/messages/tr/toolCall.ts
index 8f9aa546f..5aa82a5f4 100644
--- a/packages/ui/src/lib/i18n/messages/tr/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/tr/toolCall.ts
@@ -136,4 +136,8 @@ export const toolCallMessages = {
   "formRequest.cancel": "İptal",
   "formRequest.openExternal": "Harici formu aç",
   "formRequest.selectPlaceholder": "Bir seçenek seçin",
+  "toolCall.permission.diff.previous": "Önceki fark sayfası",
+  "toolCall.permission.diff.next": "Sonraki fark sayfası",
+  "toolCall.permission.diff.page": "Sayfa {page} / {total}",
+  "toolCall.permission.diff.reviewRequired": "Onayı etkinleştirmek için her sayfayı inceleyin veya yamanın tamamını kopyalayın.",
 } as const
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/toolCall.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/toolCall.ts
index 166ee30d9..4a384ad62 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/toolCall.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/toolCall.ts
@@ -56,6 +56,9 @@ export const toolCallMessages = {
   "toolCall.renderer.action.listingDirectory": "正在列出目录...",
 
   "toolCall.renderer.bash.title.timeout": "超时：{timeout}",
+  "toolCall.output.truncated": "[输出已截断以便显示；复制即可访问完整输出]",
+  "toolCall.output.tooLarge": "结构化输出过大，已省略显示。",
+  "toolCall.task.steps.truncated": "正在显示最近的 {count} 个步骤；更早的步骤已省略。",
   "toolCall.renderer.read.detail.offset": "偏移：{offset}",
   "toolCall.renderer.read.detail.limit": "限制：{limit}",
 
@@ -151,4 +154,8 @@ export const toolCallMessages = {
   "toolCall.applyPatch.title.withFileCount.one": "{tool}（{count} 个文件）",
   "toolCall.applyPatch.title.withFileCount.other": "{tool}（{count} 个文件）",
   "toolCall.applyPatch.fileFallback": "文件 {number}",
+  "toolCall.permission.diff.previous": "上一页差异",
+  "toolCall.permission.diff.next": "下一页差异",
+  "toolCall.permission.diff.page": "第 {page} 页，共 {total} 页",
+  "toolCall.permission.diff.reviewRequired": "查看每一页或复制完整补丁后即可批准。",
 } as const
diff --git a/packages/ui/src/lib/message-render-cache.ts b/packages/ui/src/lib/message-render-cache.ts
new file mode 100644
index 000000000..a33303874
--- /dev/null
+++ b/packages/ui/src/lib/message-render-cache.ts
@@ -0,0 +1,130 @@
+interface MessageCacheItem {
+  messageId: string
+}
+
+export interface MessageRenderCache {
+  messageItems: Map<string, MessageCacheItem>
+  toolItems: Map<string, MessageCacheItem>
+  messageBlocks: Map<string, unknown>
+}
+
+const renderCaches = new Map<string, MessageRenderCache>()
+
+export const REASONING_RENDER_CHARACTER_LIMIT = 10_000
+export const REASONING_RENDER_NODE_LIMIT = 1_000
+export const REASONING_TITLE_CHARACTER_LIMIT = 384
+
+interface TraversalCursor {
+  array: unknown[]
+  index: number
+}
+
+function isTraversalCursor(item: unknown): item is TraversalCursor {
+  if (!item || typeof item !== "object") return false
+  const cursor = item as Partial<TraversalCursor>
+  return Array.isArray(cursor.array) && typeof cursor.index === "number"
+}
+
+function extractReasoningSource(source: unknown, characterLimit: number, nodeLimit: number): string {
+  const pieces: string[] = []
+  const stack: unknown[] = [source]
+  const seen = new WeakSet<object>()
+  let characters = 0
+  let visited = 0
+
+  while (stack.length > 0 && characters < characterLimit && visited < nodeLimit) {
+    const item = stack.pop()
+    visited += 1
+
+    if (isTraversalCursor(item)) {
+      if (item.index >= item.array.length) continue
+      stack.push({ array: item.array, index: item.index + 1 }, item.array[item.index])
+      continue
+    }
+
+    if (typeof item === "string") {
+      const separatorLength = pieces.length > 0 ? 1 : 0
+      const available = characterLimit - characters - separatorLength
+      if (available <= 0) break
+      const candidate = item.slice(0, available)
+      if (/\S/.test(candidate)) {
+        pieces.push(candidate)
+        characters += candidate.length + separatorLength
+      }
+      if (candidate.length < item.length) break
+      continue
+    }
+
+    if (!item || typeof item !== "object" || seen.has(item)) continue
+    seen.add(item)
+
+    if (Array.isArray(item)) {
+      stack.push({ array: item, index: 0 })
+      continue
+    }
+
+    const segment = item as { text?: unknown; value?: unknown; content?: unknown }
+    stack.push(segment.content, segment.value, segment.text)
+  }
+
+  return pieces.join("\n")
+}
+
+function extractReasoningText(part: unknown, characterLimit: number, nodeLimit: number): string {
+  const reasoning = part as { text?: unknown; content?: unknown } | null
+  if (!reasoning || typeof reasoning !== "object") return ""
+  const text = extractReasoningSource(reasoning.text, characterLimit, nodeLimit)
+  return text || extractReasoningSource(reasoning.content, characterLimit, nodeLimit)
+}
+
+export function extractReasoningTextForRender(part: unknown): string {
+  return extractReasoningText(part, REASONING_RENDER_CHARACTER_LIMIT, REASONING_RENDER_NODE_LIMIT)
+}
+
+export function extractReasoningTextForCopy(part: unknown): string {
+  return extractReasoningText(part, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)
+}
+
+export function extractReasoningTitleForRender(text: string): string {
+  const bounded = text.slice(0, REASONING_TITLE_CHARACTER_LIMIT)
+  const firstLine = bounded.split(/\r?\n/).find((line) => line.trim().length > 0)?.trim() ?? ""
+  return firstLine.match(/^\*\*([^*]+)\*\*/)?.[1]?.trim() ?? ""
+}
+
+function makeSessionCacheKey(instanceId: string, sessionId: string) {
+  return `${instanceId}:${sessionId}`
+}
+
+export function getSessionMessageRenderCache(instanceId: string, sessionId: string): MessageRenderCache {
+  const key = makeSessionCacheKey(instanceId, sessionId)
+  let cache = renderCaches.get(key)
+  if (!cache) {
+    cache = { messageItems: new Map(), toolItems: new Map(), messageBlocks: new Map() }
+    renderCaches.set(key, cache)
+  }
+  return cache
+}
+
+export function peekSessionMessageRenderCache(instanceId: string, sessionId: string): MessageRenderCache | undefined {
+  return renderCaches.get(makeSessionCacheKey(instanceId, sessionId))
+}
+
+export function clearSessionMessageRenderCache(instanceId: string, sessionId: string): void {
+  renderCaches.delete(makeSessionCacheKey(instanceId, sessionId))
+}
+
+export function clearInstanceMessageRenderCaches(instanceId: string): void {
+  const prefix = `${instanceId}:`
+  for (const key of renderCaches.keys()) if (key.startsWith(prefix)) renderCaches.delete(key)
+}
+
+export function purgeMessageRenderCache(cache: MessageRenderCache, messageIds: readonly string[]): void {
+  const removed = new Set(messageIds)
+  for (const messageId of removed) cache.messageBlocks.delete(messageId)
+  for (const [key, item] of cache.messageItems) {
+    if (removed.has(item.messageId)) cache.messageItems.delete(key)
+  }
+  for (const [key, item] of cache.toolItems) {
+    if (removed.has(item.messageId)) cache.toolItems.delete(key)
+  }
+}
diff --git a/packages/ui/src/lib/retained-size.test.ts b/packages/ui/src/lib/retained-size.test.ts
new file mode 100644
index 000000000..6acb06a4b
--- /dev/null
+++ b/packages/ui/src/lib/retained-size.test.ts
@@ -0,0 +1,20 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { estimateRetainedBytes, estimateRetainedBytesIncrementally } from "./retained-size.ts"
+
+test("handles shared buffers and aborts before traversing a lazy tail", async () => {
+  const buffer = new ArrayBuffer(64)
+  const references = [buffer, new Uint8Array(buffer), new DataView(buffer)]
+  assert.equal(estimateRetainedBytes(references), estimateRetainedBytes([null, null, null]) + buffer.byteLength)
+
+  let accessed = false
+  Object.defineProperty(references, 3, { enumerable: true, get: () => { accessed = true; return "tail" } })
+  references.length = 4
+  const controller = new AbortController()
+  const measurement = estimateRetainedBytesIncrementally(references, { signal: controller.signal, yieldEvery: 1 })
+  await Promise.resolve()
+  assert.equal(accessed, false)
+  controller.abort()
+  await assert.rejects(measurement, { name: "AbortError" })
+})
diff --git a/packages/ui/src/lib/retained-size.ts b/packages/ui/src/lib/retained-size.ts
new file mode 100644
index 000000000..a7bb9f010
--- /dev/null
+++ b/packages/ui/src/lib/retained-size.ts
@@ -0,0 +1,158 @@
+const arrayBufferByteLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get
+const arrayBufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get
+const MAP_ENTRY_BYTES = 24
+const SET_ENTRY_BYTES = 16
+
+type RetainedChild = { value: unknown; keyBytes: number }
+
+function bufferSize(value: object): { bytes: number; growable: boolean } | undefined {
+  try {
+    return { bytes: arrayBufferByteLength?.call(value) as number, growable: Boolean(arrayBufferResizable?.call(value)) }
+  } catch {
+    return undefined
+  }
+}
+
+export function estimateRetainedBytes(value: unknown, limit = Number.POSITIVE_INFINITY): number {
+  const seen = new WeakSet<object>()
+  const pending: unknown[] = [value]
+  const children: Iterator<RetainedChild>[] = []
+  let total = 0
+  while ((pending.length > 0 || children.length > 0) && total <= limit) {
+    if (pending.length === 0) {
+      const child = children[children.length - 1]!.next()
+      if (child.done) {
+        children.pop()
+        continue
+      }
+      total += child.value.keyBytes
+      if (total > limit) break
+      pending.push(child.value.value)
+    }
+    const current = pending.pop()
+    if (typeof current === "string") total += current.length * 2 + 16
+    else if (typeof current === "number" || typeof current === "bigint") total += 8
+    else if (typeof current === "boolean") total += 4
+    else if (current && typeof current === "object") {
+      if (ArrayBuffer.isView(current)) {
+        if (seen.has(current.buffer)) continue
+        seen.add(current.buffer)
+        const backing = bufferSize(current.buffer as object)
+        total += backing?.growable ? limit + 1 : backing?.bytes ?? current.byteLength
+        continue
+      }
+      if (seen.has(current)) continue
+      seen.add(current)
+      const bytes = bufferSize(current)
+      if (bytes !== undefined) {
+        total += bytes.growable ? limit + 1 : bytes.bytes
+        continue
+      }
+      total += Array.isArray(current)
+        ? 24 + current.length * 8
+        : current instanceof Map
+          ? 32 + current.size * MAP_ENTRY_BYTES
+          : current instanceof Set
+            ? 32 + current.size * SET_ENTRY_BYTES
+            : 32
+      if (total <= limit) children.push(objectChildren(current))
+    }
+  }
+  return total
+}
+
+export function exceedsRetainedByteLimit(value: unknown, limit: number): boolean {
+  return estimateRetainedBytes(value, limit) > limit
+}
+
+export async function estimateRetainedBytesIncrementally(
+  value: unknown,
+  options: {
+    signal?: AbortSignal
+    yieldEvery?: number
+    rootIterable?: boolean
+    maxBytes?: number
+    maxNodes?: number
+  } = {},
+): Promise<number> {
+  const seen = new WeakSet<object>()
+  const pending: unknown[] = []
+  const children: Iterator<RetainedChild>[] = []
+  const roots = options.rootIterable ? (value as Iterable<unknown>)[Symbol.iterator]() : undefined
+  if (!roots) pending.push(value)
+  const yieldEvery = Math.max(1, options.yieldEvery ?? 500)
+  const maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY
+  const maxNodes = options.maxNodes ?? Number.POSITIVE_INFINITY
+  let processed = 0
+  let total = 0
+
+  while (pending.length > 0 || children.length > 0 || roots) {
+    options.signal?.throwIfAborted()
+    if (pending.length === 0) {
+      const child = children[children.length - 1]?.next()
+      if (child && !child.done) {
+        total += child.value.keyBytes
+        if (total > maxBytes) return Number.POSITIVE_INFINITY
+        pending.push(child.value.value)
+      } else if (child) {
+        children.pop()
+        continue
+      } else {
+        const next = roots!.next()
+        if (next.done) break
+        pending.push(next.value)
+      }
+    }
+    if (++processed > maxNodes) return Number.POSITIVE_INFINITY
+    if (processed % yieldEvery === 0) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 0))
+      options.signal?.throwIfAborted()
+    }
+    const current = pending.pop()
+    if (typeof current === "string") total += current.length * 2 + 16
+    else if (typeof current === "number" || typeof current === "bigint") total += 8
+    else if (typeof current === "boolean") total += 4
+    else if (current && typeof current === "object") {
+      if (ArrayBuffer.isView(current)) {
+        if (seen.has(current.buffer)) continue
+        seen.add(current.buffer)
+        const backing = bufferSize(current.buffer as object)
+        total += backing?.growable ? Number.POSITIVE_INFINITY : backing?.bytes ?? current.byteLength
+        continue
+      }
+      if (seen.has(current)) continue
+      seen.add(current)
+      const bytes = bufferSize(current)
+      if (bytes !== undefined) {
+        total += bytes.growable ? Number.POSITIVE_INFINITY : bytes.bytes
+        continue
+      }
+      total += Array.isArray(current)
+        ? 24 + current.length * 8
+        : current instanceof Map
+          ? 32 + current.size * MAP_ENTRY_BYTES
+          : current instanceof Set
+            ? 32 + current.size * SET_ENTRY_BYTES
+            : 32
+      children.push(objectChildren(current))
+    }
+    if (total > maxBytes) return Number.POSITIVE_INFINITY
+  }
+  options.signal?.throwIfAborted()
+  return total
+}
+
+function* objectChildren(current: object): Generator<RetainedChild> {
+  if (current instanceof Map) {
+    for (const [key, entry] of current) {
+      yield { value: key, keyBytes: 0 }
+      yield { value: entry, keyBytes: 0 }
+    }
+  } else if (current instanceof Set) {
+    for (const entry of current) yield { value: entry, keyBytes: 0 }
+  }
+  for (const key in current) {
+    if (!Object.prototype.hasOwnProperty.call(current, key)) continue
+    yield { value: (current as Record<string, unknown>)[key], keyBytes: key.length * 2 + 8 }
+  }
+}
diff --git a/packages/ui/src/lib/session-transcript-lru.test.ts b/packages/ui/src/lib/session-transcript-lru.test.ts
new file mode 100644
index 000000000..0ca2d8dc0
--- /dev/null
+++ b/packages/ui/src/lib/session-transcript-lru.test.ts
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { SessionTranscriptMeasurementQueue } from "./session-transcript-measurement.ts"
+import { isSessionTranscriptProtected, SessionTranscriptLru, selectTranscriptEvictions, type TranscriptLruEntry } from "./session-transcript-lru.ts"
+
+const entry = (sessionId: string, bytes: number, lastUsed: number): TranscriptLruEntry => ({
+  instanceId: "instance", sessionId, bytes, lastUsed,
+})
+
+test("measures, accounts, touches, and enforces transcript LRU order", async (context) => {
+  context.mock.timers.enable({ apis: ["setTimeout"] })
+  const evicted: string[] = []
+  const lru = new SessionTranscriptLru({
+    byteBudget: 12,
+    isProtected: () => false,
+    evict: (_instanceId, sessionId) => evicted.push(sessionId),
+  })
+  const queue = new SessionTranscriptMeasurementQueue({
+    delayMs: 1,
+    measure: async () => 6,
+    account: (instanceId, sessionId, bytes) => lru.account(instanceId, sessionId, bytes),
+    onError: () => {},
+  })
+
+  for (const sessionId of ["old", "new"]) {
+    lru.touch("instance", sessionId)
+    queue.schedule("instance", sessionId)
+    context.mock.timers.tick(1)
+    await Promise.resolve()
+  }
+  lru.touch("instance", "old")
+  queue.schedule("instance", "latest")
+  context.mock.timers.tick(1)
+  await Promise.resolve()
+  lru.enforce()
+
+  assert.deepEqual(evicted, ["new"])
+})
+
+test("protects visible, live, and form-blocked transcripts despite temporary budget overage", () => {
+  const entries = [entry("visible", 4, 1), entry("live", 4, 2), entry("form", 4, 3), entry("inactive", 4, 4)]
+  assert.deepEqual(selectTranscriptEvictions(entries, 1, ({ sessionId }) => isSessionTranscriptProtected(
+    sessionId === "visible" ? { visible: true } : sessionId === "live" ? { liveMessages: true } : sessionId === "form" ? { questionBlocked: true } : {},
+  )).map(({ sessionId }) => sessionId), ["inactive"])
+})
diff --git a/packages/ui/src/lib/session-transcript-lru.ts b/packages/ui/src/lib/session-transcript-lru.ts
new file mode 100644
index 000000000..0f04e7f25
--- /dev/null
+++ b/packages/ui/src/lib/session-transcript-lru.ts
@@ -0,0 +1,130 @@
+export interface TranscriptLruEntry {
+  instanceId: string
+  sessionId: string
+  bytes: number
+  lastUsed: number
+}
+
+export interface TranscriptProtectionState {
+  visible?: boolean
+  loading?: boolean
+  status?: "idle" | "working" | "compacting"
+  generationPending?: boolean
+  liveMessages?: boolean
+  permissionBlocked?: boolean
+  questionBlocked?: boolean
+}
+
+export function isSessionTranscriptProtected(state: TranscriptProtectionState): boolean {
+  return Boolean(
+    state.visible
+    || state.loading
+    || state.status === "working"
+    || state.status === "compacting"
+    || state.generationPending
+    || state.liveMessages
+    || state.permissionBlocked
+    || state.questionBlocked,
+  )
+}
+
+export function selectTranscriptEvictions(
+  entries: readonly TranscriptLruEntry[],
+  byteBudget: number,
+  isProtected: (entry: TranscriptLruEntry) => boolean,
+): TranscriptLruEntry[] {
+  let retainedBytes = 0
+  let unboundedEntries = 0
+  for (const entry of entries) {
+    if (Number.isFinite(entry.bytes)) retainedBytes += entry.bytes
+    else unboundedEntries += 1
+  }
+  if (unboundedEntries === 0 && retainedBytes <= byteBudget) return []
+
+  const selected: TranscriptLruEntry[] = []
+  for (const entry of [...entries].sort((left, right) => left.lastUsed - right.lastUsed)) {
+    if (isProtected(entry)) continue
+    selected.push(entry)
+    if (Number.isFinite(entry.bytes)) retainedBytes -= entry.bytes
+    else unboundedEntries -= 1
+    if (unboundedEntries === 0 && retainedBytes <= byteBudget) break
+  }
+  return selected
+}
+
+interface SessionTranscriptLruOptions {
+  byteBudget: number
+  isProtected: (instanceId: string, sessionId: string) => boolean
+  evict: (instanceId: string, sessionId: string) => void
+}
+
+export class SessionTranscriptLru {
+  private entries = new Map<string, TranscriptLruEntry>()
+  private pendingTouches = new Map<string, number>()
+  private sequence = 0
+
+  constructor(private options: SessionTranscriptLruOptions) {}
+
+  account(instanceId: string, sessionId: string, bytes: number): void {
+    const key = this.key(instanceId, sessionId)
+    if (bytes <= 0) {
+      this.entries.delete(key)
+      this.pendingTouches.delete(key)
+      return
+    }
+    const current = this.entries.get(key)
+    const lastUsed = current?.lastUsed ?? this.pendingTouches.get(key) ?? ++this.sequence
+    this.pendingTouches.delete(key)
+    this.entries.set(key, {
+      instanceId,
+      sessionId,
+      bytes,
+      lastUsed,
+    })
+    this.enforce()
+  }
+
+  touch(instanceId: string, sessionId: string): boolean {
+    const key = this.key(instanceId, sessionId)
+    const lastUsed = ++this.sequence
+    const entry = this.entries.get(key)
+    if (entry) {
+      entry.lastUsed = lastUsed
+      return false
+    }
+    const needsAccounting = !this.pendingTouches.has(key)
+    this.pendingTouches.set(key, lastUsed)
+    return needsAccounting
+  }
+
+  forget(instanceId: string, sessionId: string): void {
+    const key = this.key(instanceId, sessionId)
+    this.entries.delete(key)
+    this.pendingTouches.delete(key)
+  }
+
+  forgetInstance(instanceId: string): void {
+    for (const [key, entry] of this.entries) {
+      if (entry.instanceId === instanceId) this.entries.delete(key)
+    }
+    for (const key of this.pendingTouches.keys()) {
+      if (key.startsWith(`${instanceId}\u0000`)) this.pendingTouches.delete(key)
+    }
+  }
+
+  enforce(): void {
+    const evictions = selectTranscriptEvictions(
+      [...this.entries.values()],
+      this.options.byteBudget,
+      (entry) => this.options.isProtected(entry.instanceId, entry.sessionId),
+    )
+    for (const entry of evictions) {
+      this.entries.delete(this.key(entry.instanceId, entry.sessionId))
+      this.options.evict(entry.instanceId, entry.sessionId)
+    }
+  }
+
+  private key(instanceId: string, sessionId: string): string {
+    return `${instanceId}\u0000${sessionId}`
+  }
+}
diff --git a/packages/ui/src/lib/session-transcript-measurement.ts b/packages/ui/src/lib/session-transcript-measurement.ts
new file mode 100644
index 000000000..993e562cb
--- /dev/null
+++ b/packages/ui/src/lib/session-transcript-measurement.ts
@@ -0,0 +1,97 @@
+type PendingMeasurement = {
+  revision: number
+  timer?: ReturnType<typeof setTimeout>
+  controller?: AbortController
+}
+
+type SessionTranscriptMeasurementOptions = {
+  delayMs: number
+  measure: (instanceId: string, sessionId: string, signal: AbortSignal) => Promise<number>
+  account: (instanceId: string, sessionId: string, bytes: number) => void
+  onError: (instanceId: string, sessionId: string, error: unknown) => void
+}
+
+export class SessionTranscriptMeasurementQueue {
+  private pending = new Map<string, PendingMeasurement>()
+
+  constructor(private options: SessionTranscriptMeasurementOptions) {}
+
+  schedule(instanceId: string, sessionId: string): void {
+    const entryKey = this.key(instanceId, sessionId)
+    const current = this.pending.get(entryKey)
+    if (current) {
+      if (current.controller) {
+        current.controller.abort()
+        const replacement = { revision: current.revision + 1 }
+        this.pending.set(entryKey, replacement)
+        this.arm(instanceId, sessionId, replacement)
+        return
+      }
+      current.revision += 1
+      return
+    }
+
+    const pending = { revision: 1 }
+    this.pending.set(entryKey, pending)
+    this.arm(instanceId, sessionId, pending)
+  }
+
+  cancel(instanceId: string, sessionId: string): void {
+    const entryKey = this.key(instanceId, sessionId)
+    const pending = this.pending.get(entryKey)
+    if (!pending) return
+    if (pending.timer !== undefined) clearTimeout(pending.timer)
+    pending.controller?.abort()
+    this.pending.delete(entryKey)
+  }
+
+  cancelInstance(instanceId: string): void {
+    for (const [entryKey, pending] of this.pending) {
+      if (!entryKey.startsWith(`${instanceId}\u0000`)) continue
+      if (pending.timer !== undefined) clearTimeout(pending.timer)
+      pending.controller?.abort()
+      this.pending.delete(entryKey)
+    }
+  }
+
+  private arm(instanceId: string, sessionId: string, pending: PendingMeasurement): void {
+    pending.timer = setTimeout(() => {
+      pending.timer = undefined
+      void this.measure(instanceId, sessionId, pending)
+    }, this.options.delayMs)
+  }
+
+  private async measure(instanceId: string, sessionId: string, pending: PendingMeasurement): Promise<void> {
+    const entryKey = this.key(instanceId, sessionId)
+    const measuredRevision = pending.revision
+    const controller = new AbortController()
+    pending.controller = controller
+    try {
+      const bytes = await this.options.measure(instanceId, sessionId, controller.signal)
+      if (controller.signal.aborted || this.pending.get(entryKey) !== pending) return
+      if (pending.revision === measuredRevision) {
+        this.pending.delete(entryKey)
+        this.options.account(instanceId, sessionId, bytes)
+        return
+      }
+    } catch (error) {
+      if (!controller.signal.aborted && this.pending.get(entryKey) === pending && pending.revision === measuredRevision) {
+        this.options.account(instanceId, sessionId, Number.POSITIVE_INFINITY)
+        try {
+          this.options.onError(instanceId, sessionId, error)
+        } catch {
+          // Accounting is authoritative; error reporting must not undo it.
+        }
+      }
+    } finally {
+      if (this.pending.get(entryKey) !== pending) return
+      pending.controller = undefined
+      if (pending.revision !== measuredRevision) this.arm(instanceId, sessionId, pending)
+      else this.pending.delete(entryKey)
+    }
+  }
+
+  private key(instanceId: string, sessionId: string): string {
+    return `${instanceId}\u0000${sessionId}`
+  }
+}
diff --git a/packages/ui/src/stores/client-state-codec.test.ts b/packages/ui/src/stores/client-state-codec.test.ts
index 1cbb3693f..6153b71bb 100644
--- a/packages/ui/src/stores/client-state-codec.test.ts
+++ b/packages/ui/src/stores/client-state-codec.test.ts
@@ -47,7 +47,7 @@ describe("client state codec", () => {
         tabs: [workspace({
           type: "instance", kind: undefined, folder: "C:/work/project", occurrence: 1, projectName: "Project",
           drafts: { session1: "unfinished prompt" },
-          scrollSnapshots: { session1: { scrollTop: 120, scrollRatio: 0.5, atBottom: false, updatedAt: 1200 } },
+          scrollSnapshots: { session1: { scrollTop: 120, scrollRatio: 0.5, atBottom: false, updatedAt: 1200, windowCursor: "older", newerCursors: [null, "newer"] } },
           unseenIdleSince: { session1: 1100, malformed: -1 },
           generationRecovery: { session1: "working", session2: "interrupted", malformed: "idle" },
           expandedSessionIds: ["session1", "session1", 42],
@@ -65,7 +65,7 @@ describe("client state codec", () => {
     assert.deepEqual({ ...tab.unseenIdleSince }, { session1: 1100 })
     assert.deepEqual({ ...tab.generationRecovery }, { session1: "working", session2: "interrupted" })
     assert.deepEqual(tab.expandedSessionIds, ["session1"])
-    assert.deepEqual(tab.scrollSnapshots.session1, { scrollTop: 120, scrollRatio: 0.5, atBottom: false, updatedAt: 1200 })
+    assert.deepEqual(tab.scrollSnapshots.session1, { scrollTop: 120, scrollRatio: 0.5, atBottom: false, updatedAt: 1200, windowCursor: "older", newerCursors: [null, "newer"] })
     assert.deepEqual(decoded?.session?.tabs[1], { kind: "sidecar", sidecarId: "docs" })
   })
 
diff --git a/packages/ui/src/stores/instances.ts b/packages/ui/src/stores/instances.ts
index b2059cca5..c7e7bb39e 100644
--- a/packages/ui/src/stores/instances.ts
+++ b/packages/ui/src/stores/instances.ts
@@ -48,8 +48,8 @@ import {
 } from "./session-state"
 import { setHasInstances } from "./ui"
 import { messageStoreBus } from "./message-v2/bus"
+import { applyOpenCodeDataEvent, destroyOpenCodeData, finishOpenCodeDataEvent, projectOpenCodeMessages, syncOpenCodeSessionInbox } from "./opencode-data"
 import { updateSessionInfo } from "./message-v2/session-info"
-import { applyOpenCodeDataEvent, destroyOpenCodeData, projectOpenCodeMessages, syncOpenCodeSessionInbox } from "./opencode-data"
 import { isLatestWindow } from "./message-v2/message-window"
 import { upsertPermissionV2, removePermissionV2, removeMessageV2 } from "./message-v2/bridge"
 import {
@@ -2026,6 +2026,7 @@ function handleInstanceInvalidation(instanceId: string, event: Parameters<NonNul
       removePendingForm(instanceId, event.data.id)
     }
   }
+  finishOpenCodeDataEvent(instanceId, event)
   const targets = getInstanceRefreshTargets(event.type)
   if (targets.length) void refreshVolatileInstanceState(instanceId, targets)
 }
diff --git a/packages/ui/src/stores/message-prompt-display.ts b/packages/ui/src/stores/message-prompt-display.ts
index 01cfe26e3..b72758fa2 100644
--- a/packages/ui/src/stores/message-prompt-display.ts
+++ b/packages/ui/src/stores/message-prompt-display.ts
@@ -1,10 +1,16 @@
 import type { PromptDisplayMetadata } from "../lib/prompt-display-metadata"
+import { estimateRetainedBytes } from "../lib/retained-size"
 
 const STORAGE_KEY = "codenomad:prompt-display:v3"
 const LEGACY_STORAGE_KEY = "codenomad:prompt-display:v2"
+const ENTRY_LIMIT = 512
+const BYTE_LIMIT = 1024 * 1024
+const ENTRY_BYTE_LIMIT = 64 * 1024
 
 let loaded = false
 const promptDisplayOverrides = new Map<string, PromptDisplayMetadata>()
+const promptDisplayOverrideBytes = new Map<string, number>()
+let retainedBytes = 0
 
 function storageKey(): string {
   const windowId = typeof window === "undefined" ? "" : window.__CODENOMAD_WINDOW_ID__?.trim()
@@ -67,15 +73,39 @@ function ensureLoaded(): void {
     if (legacyV2Raw) storage.removeItem(LEGACY_STORAGE_KEY)
   } catch {
     promptDisplayOverrides.clear()
+    promptDisplayOverrideBytes.clear()
+    retainedBytes = 0
   }
 }
 
 function loadStoredEntries(parsed: Record<string, PromptDisplayMetadata>, migrateLegacyKeys: boolean): void {
   for (const [key, value] of Object.entries(parsed)) {
-    if (isPromptDisplayMetadata(value)) {
-      promptDisplayOverrides.set(migrateLegacyKeys ? migrateStoredKey(key) : key, value)
-    }
+    if (isPromptDisplayMetadata(value)) setEntry(migrateLegacyKeys ? migrateStoredKey(key) : key, value)
+  }
+}
+
+function deleteEntry(key: string): boolean {
+  const bytes = promptDisplayOverrideBytes.get(key)
+  if (bytes === undefined) return false
+  retainedBytes -= bytes
+  promptDisplayOverrideBytes.delete(key)
+  promptDisplayOverrides.delete(key)
+  return true
+}
+
+function setEntry(key: string, value: PromptDisplayMetadata): boolean {
+  const bytes = key.length * 2 + estimateRetainedBytes(value, ENTRY_BYTE_LIMIT)
+  if (bytes > ENTRY_BYTE_LIMIT) return false
+  deleteEntry(key)
+  promptDisplayOverrides.set(key, value)
+  promptDisplayOverrideBytes.set(key, bytes)
+  retainedBytes += bytes
+  while (promptDisplayOverrides.size > ENTRY_LIMIT || retainedBytes > BYTE_LIMIT) {
+    const oldest = promptDisplayOverrides.keys().next().value
+    if (oldest === undefined) break
+    deleteEntry(oldest)
   }
+  return promptDisplayOverrides.has(key)
 }
 
 function persist(): boolean {
@@ -111,7 +141,13 @@ export function getPromptDisplayOverride(
   messageId: string,
 ): PromptDisplayMetadata | undefined {
   ensureLoaded()
-  return promptDisplayOverrides.get(makeKey(instanceId, sessionId, messageId))
+  const key = makeKey(instanceId, sessionId, messageId)
+  const value = promptDisplayOverrides.get(key)
+  if (value) {
+    promptDisplayOverrides.delete(key)
+    promptDisplayOverrides.set(key, value)
+  }
+  return value
 }
 
 export function setPromptDisplayOverride(
@@ -126,10 +162,9 @@ export function setPromptDisplayOverride(
   if (displayMetadata && isPromptDisplayMetadata(displayMetadata)) {
     const serialized = JSON.stringify(displayMetadata)
     if (previous && JSON.stringify(previous) === serialized) return
-    promptDisplayOverrides.set(key, displayMetadata)
+    if (!setEntry(key, displayMetadata)) return
   } else {
-    if (!promptDisplayOverrides.has(key)) return
-    promptDisplayOverrides.delete(key)
+    if (!deleteEntry(key)) return
   }
   persist()
 }
@@ -142,14 +177,14 @@ export function movePromptDisplayOverride(instanceId: string, sessionId: string,
 
   const newKey = makeKey(instanceId, sessionId, newMessageId)
   if (oldKey === newKey) return
-  promptDisplayOverrides.delete(oldKey)
-  promptDisplayOverrides.set(newKey, nextValue)
+  if (!setEntry(newKey, nextValue)) return
+  deleteEntry(oldKey)
   persist()
 }
 
 export function clearPromptDisplayOverride(instanceId: string, sessionId: string, messageId: string): void {
   ensureLoaded()
-  if (!promptDisplayOverrides.delete(makeKey(instanceId, sessionId, messageId))) {
+  if (!deleteEntry(makeKey(instanceId, sessionId, messageId))) {
     return
   }
   persist()
@@ -162,7 +197,7 @@ export function clearPromptDisplayOverridesForSession(instanceId: string, sessio
   let changed = false
   for (const key of promptDisplayOverrides.keys()) {
     if (key.startsWith(stablePrefix) || key.startsWith(legacyPrefix)) {
-      promptDisplayOverrides.delete(key)
+      deleteEntry(key)
       changed = true
     }
   }
@@ -177,7 +212,7 @@ export function clearPromptDisplayOverridesForInstance(instanceId: string, sessi
     const shouldDeleteStableKey = sessionIds.some((sessionId) => key.startsWith(`${sessionId}:`))
     const shouldDeleteLegacyKey = key.startsWith(`${instanceId}:`)
     if (shouldDeleteStableKey || shouldDeleteLegacyKey) {
-      promptDisplayOverrides.delete(key)
+      deleteEntry(key)
       changed = true
     }
   }
@@ -188,4 +223,6 @@ export function clearPromptDisplayOverridesForInstance(instanceId: string, sessi
 export function resetPromptDisplayOverrideStateForTests(): void {
   loaded = false
   promptDisplayOverrides.clear()
+  promptDisplayOverrideBytes.clear()
+  retainedBytes = 0
 }
diff --git a/packages/ui/src/stores/message-v2/bus.test.ts b/packages/ui/src/stores/message-v2/bus.test.ts
index abfd5cf3d..d8c97c63c 100644
--- a/packages/ui/src/stores/message-v2/bus.test.ts
+++ b/packages/ui/src/stores/message-v2/bus.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict"
 import { describe, it } from "node:test"
 
 import { messageStoreBus } from "./bus.ts"
-import { invalidateSessionMessageLoad, messagesLoaded, setMessagesLoaded } from "../session-state.ts"
+import { messagesLoaded, setMessagesLoaded } from "../session-state.ts"
 
 describe("message store scroll snapshots", () => {
   it("seeds an unregistered instance without claiming runtime authority", () => {
@@ -67,8 +67,7 @@ describe("message store scroll snapshots", () => {
     setMessagesLoaded((prev) => new Map(prev).set(instanceId, new Set(["session-1"])))
     try {
       store.restoreScrollSnapshot("session-1", "message-stream", snapshot)
-      invalidateSessionMessageLoad(instanceId, "session-1")
-      store.clearSession("session-1", { preserveScroll: true, notify: false })
+      store.clearSession("session-1", { preserveScroll: true })
       assert.deepEqual(store.getScrollSnapshot("session-1", "message-stream"), snapshot)
       assert.equal(messagesLoaded().get(instanceId)?.has("session-1") ?? false, false)
     } finally {
diff --git a/packages/ui/src/stores/message-v2/bus.ts b/packages/ui/src/stores/message-v2/bus.ts
index 86900cd9f..baefccc7b 100644
--- a/packages/ui/src/stores/message-v2/bus.ts
+++ b/packages/ui/src/stores/message-v2/bus.ts
@@ -1,6 +1,6 @@
 import { createInstanceMessageStore } from "./instance-store"
 import type { InstanceMessageStore } from "./instance-store"
-import { clearCacheForInstance } from "../../lib/global-cache"
+import { clearCacheForInstance, clearCacheForSession } from "../../lib/global-cache"
 import { getLogger } from "../../lib/logger"
 import type { ScrollSnapshot } from "./types"
 
@@ -16,6 +16,8 @@ class MessageStoreBus {
   private stores = new Map<string, InstanceMessageStore>()
   private teardownHandlers = new Set<(instanceId: string) => void>()
   private sessionClearHandlers = new Set<(instanceId: string, sessionId: string) => void>()
+  private sessionChangeHandlers = new Set<(instanceId: string, sessionId: string) => void>()
+  private messageRemovalHandlers = new Set<(instanceId: string, sessionId: string, messageIds: readonly string[]) => void>()
   private scrollSnapshotHandlers = new Set<
     (instanceId: string, sessionId: string, scope: string, snapshot: ScrollSnapshot) => void
   >()
@@ -30,6 +32,8 @@ class MessageStoreBus {
       store ??
       createInstanceMessageStore(instanceId, {
         onSessionCleared: (id, sessionId) => this.notifySessionCleared(id, sessionId),
+        onSessionChanged: (id, sessionId) => this.notifySessionChanged(id, sessionId),
+        onMessagesRemoved: (id, sessionId, messageIds) => this.notifyMessagesRemoved(id, sessionId, messageIds),
         onScrollSnapshotChanged: (id, sessionId, scope, snapshot) =>
           this.notifyScrollSnapshotChanged(id, sessionId, scope, snapshot),
       })
@@ -52,6 +56,7 @@ class MessageStoreBus {
   }
 
   private notifySessionCleared(instanceId: string, sessionId: string) {
+    clearCacheForSession(instanceId, sessionId)
     for (const handler of this.sessionClearHandlers) {
       try {
         handler(instanceId, sessionId)
@@ -61,6 +66,37 @@ class MessageStoreBus {
     }
   }
 
+  onSessionChanged(handler: (instanceId: string, sessionId: string) => void): () => void {
+    this.sessionChangeHandlers.add(handler)
+    return () => this.sessionChangeHandlers.delete(handler)
+  }
+
+  private notifySessionChanged(instanceId: string, sessionId: string) {
+    for (const handler of this.sessionChangeHandlers) {
+      try {
+        handler(instanceId, sessionId)
+      } catch (error) {
+        log.error("Failed to run session change handler", error)
+      }
+    }
+  }
+
+  onMessagesRemoved(handler: (instanceId: string, sessionId: string, messageIds: readonly string[]) => void): () => void {
+    this.messageRemovalHandlers.add(handler)
+    return () => this.messageRemovalHandlers.delete(handler)
+  }
+
+  private notifyMessagesRemoved(instanceId: string, sessionId: string, messageIds: readonly string[]) {
+    clearCacheForSession(instanceId, sessionId)
+    for (const handler of this.messageRemovalHandlers) {
+      try {
+        handler(instanceId, sessionId, messageIds)
+      } catch (error) {
+        log.error("Failed to run message removal handler", error)
+      }
+    }
+  }
+
   onScrollSnapshotChanged(
     handler: (instanceId: string, sessionId: string, scope: string, snapshot: ScrollSnapshot) => void,
   ): () => void {
diff --git a/packages/ui/src/stores/message-v2/instance-store.test.ts b/packages/ui/src/stores/message-v2/instance-store.test.ts
index 65f8e237d..9f4fdbbeb 100644
--- a/packages/ui/src/stores/message-v2/instance-store.test.ts
+++ b/packages/ui/src/stores/message-v2/instance-store.test.ts
@@ -3,10 +3,34 @@ import { readFileSync } from "node:fs"
 import { describe, it } from "node:test"
 
 import { createInstanceMessageStore } from "./instance-store.ts"
-import { buildRecordDisplayData } from "./record-display-cache.ts"
+import { buildRecordDisplayData, getRecordDisplayPartIds, MESSAGE_PART_DISPLAY_LIMIT } from "./record-display-cache.ts"
+import { getSessionMessageRenderCache, purgeMessageRenderCache } from "../../lib/message-render-cache.ts"
 import type { MessageInfo } from "../../types/message"
 import { emptyLatestWindow, toWindowSnapshot, windowFromSnapshot } from "./message-window"
 
+it("keeps the beginning and final response when bounding message parts", () => {
+  const partIds = Array.from({ length: MESSAGE_PART_DISPLAY_LIMIT + 2 }, (_, index) => `part-${index}`)
+  const data = buildRecordDisplayData("bounded-parts", {
+    id: "message", sessionId: "session", role: "assistant", status: "complete",
+    createdAt: 1, updatedAt: 1, revision: 1, partIds,
+    parts: Object.fromEntries(partIds.map((id) => [id, { id, revision: 1, data: { id, type: "text", text: id } }])),
+  })
+
+  assert.equal(data.orderedParts.length, MESSAGE_PART_DISPLAY_LIMIT)
+  assert.equal(data.orderedParts[0]?.id, "part-0")
+  assert.equal(data.orderedParts.at(-1)?.id, `part-${MESSAGE_PART_DISPLAY_LIMIT + 1}`)
+  assert.equal(data.truncated, true)
+
+  const displayPartIds = getRecordDisplayPartIds({
+    id: "message", sessionId: "session", role: "assistant", status: "complete",
+    createdAt: 1, updatedAt: 1, revision: 1, partIds,
+    parts: {},
+  })
+  assert.equal(displayPartIds.length, MESSAGE_PART_DISPLAY_LIMIT)
+  assert.equal(displayPartIds[0], "part-0")
+  assert.equal(displayPartIds.at(-1), `part-${MESSAGE_PART_DISPLAY_LIMIT + 1}`)
+})
+
 describe("message window replacement authority", () => {
   it("retires an older resume cursor when returning to latest before cold restoration", () => {
     const store = createInstanceMessageStore("window-replacement")
@@ -147,6 +171,38 @@ describe("message-v2 todo state", () => {
 })
 
 describe("message-v2 hydrateMessages vs pending optimistic sends", () => {
+  it("trims to 200 messages and purges removed render-cache entries", () => {
+    const instanceId = "window-trim", sessionId = "session"
+    const cache = getSessionMessageRenderCache(instanceId, sessionId)
+    const store = createInstanceMessageStore(instanceId, {
+      onMessagesRemoved: (_instanceId, _sessionId, messageIds) => purgeMessageRenderCache(cache, messageIds),
+    })
+    store.hydrateMessages(sessionId, Array.from({ length: 201 }, (_, index) => ({
+      id: `message-${index}`, sessionId, role: "assistant" as const, status: "complete" as const,
+    })))
+    cache.messageBlocks.set("message-0", {})
+    cache.messageBlocks.set("message-200", {})
+
+    store.trimSessionMessages(sessionId, 200)
+
+    assert.equal(store.getSessionMessageIds(sessionId).length, 200)
+    assert.equal(store.getSessionMessageIds(sessionId).includes("message-0"), false)
+    assert.deepEqual([...cache.messageBlocks.keys()], ["message-200"])
+    store.clearInstance()
+  })
+
+  it("clears pending parts omitted by authoritative hydration", () => {
+    const store = createInstanceMessageStore("pending-cleanup")
+    store.hydrateMessages("session-1", [{ id: "old", sessionId: "session-1", role: "assistant", status: "complete" }])
+    store.bufferPendingPart({ messageId: "old", sessionId: "session-1", part: { type: "text", text: "pending" } as any, receivedAt: 1 })
+
+    store.hydrateMessages("session-1", [{ id: "current", sessionId: "session-1", role: "user", status: "complete" }])
+
+    assert.equal(store.state.pendingParts.old, undefined)
+    assert.deepEqual(store.getSessionMessageIds("session-1"), ["current"])
+    store.clearInstance()
+  })
+
   it("keeps an in-flight pending 'sending' message visible when a force reload snapshot doesn't include it yet", () => {
     const store = createInstanceMessageStore("instance-1")
     store.addOrUpdateSession({ id: "session-1" })
diff --git a/packages/ui/src/stores/message-v2/instance-store.ts b/packages/ui/src/stores/message-v2/instance-store.ts
index 7f9b12f6c..17f0d4f4b 100644
--- a/packages/ui/src/stores/message-v2/instance-store.ts
+++ b/packages/ui/src/stores/message-v2/instance-store.ts
@@ -2,6 +2,7 @@ import { batch } from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
 import type { SetStoreFunction } from "solid-js/store"
 import { getLogger } from "../../lib/logger"
+import { getCacheRetainedEntriesForSession } from "../../lib/global-cache"
 import {
   clearPromptDisplayOverride,
   clearPromptDisplayOverridesForInstance,
@@ -12,7 +13,10 @@ import {
 } from "../message-prompt-display"
 import type { ClientPart, MessageInfo } from "../../types/message"
 import { mergePermissionRequest } from "../../types/permission"
-import { clearRecordDisplayCacheForMessages } from "./record-display-cache"
+import { clearRecordDisplayCacheForInstance, clearRecordDisplayCacheForMessages, getRecordDisplayCacheEntries } from "./record-display-cache"
+import { estimateRetainedBytes, estimateRetainedBytesIncrementally } from "../../lib/retained-size"
+import { clearInstanceMessageRenderCaches, clearSessionMessageRenderCache, peekSessionMessageRenderCache } from "../../lib/message-render-cache"
+import type { MessageWindowState } from "./message-window"
 import { shouldSkipPendingRequestUpsert } from "./pending-request-dedupe"
 import type {
   InstanceMessageState,
@@ -29,12 +33,13 @@ import type {
   SessionUsageState,
   UsageEntry,
 } from "./types"
-import type { MessageWindowState } from "./message-window"
 
 const storeLog = getLogger("session")
 
 interface MessageStoreHooks {
   onSessionCleared?: (instanceId: string, sessionId: string) => void
+  onSessionChanged?: (instanceId: string, sessionId: string) => void
+  onMessagesRemoved?: (instanceId: string, sessionId: string, messageIds: readonly string[]) => void
   onScrollSnapshotChanged?: (instanceId: string, sessionId: string, scope: string, snapshot: ScrollSnapshot) => void
 }
 
@@ -74,6 +79,51 @@ function ensurePartId(messageId: string, part: ClientPart, index: number): strin
 }
 
 const PENDING_PART_MAX_AGE_MS = 30_000
+const PENDING_PARTS_PER_MESSAGE_LIMIT = 100
+const PENDING_PARTS_PER_SESSION_LIMIT = 100
+const PENDING_PARTS_GLOBAL_LIMIT = 500
+const PENDING_PART_MAX_RETAINED_BYTES = 1024 * 1024
+const PENDING_PARTS_PER_SESSION_BYTE_LIMIT = 4 * 1024 * 1024
+const PENDING_PARTS_GLOBAL_BYTE_LIMIT = 8 * 1024 * 1024
+const DROPPED_PENDING_MESSAGE_LIMIT = 500
+const MAX_TRANSCRIPT_MEASUREMENT_BYTES = 64 * 1024 * 1024
+const MAX_TRANSCRIPT_MEASUREMENT_NODES = 500_000
+const pendingPartRetainedBytes = Symbol("pendingPartRetainedBytes")
+const pendingPartBudgetId = Symbol("pendingPartBudgetId")
+let nextPendingPartBudgetId = 0
+const pendingPartBudgetEntries = new Map<number, {
+  instanceId: string
+  bytes: number
+  receivedAt: number
+  isRetained: () => boolean
+  remove: () => void
+}>()
+type SizedPendingPartEntry = PendingPartEntry & { [pendingPartRetainedBytes]?: number; [pendingPartBudgetId]?: number }
+
+function getPendingPartRetainedBytes(entry: PendingPartEntry): number {
+  return (entry as SizedPendingPartEntry)[pendingPartRetainedBytes]
+    ?? estimateRetainedBytes(entry, PENDING_PART_MAX_RETAINED_BYTES)
+}
+
+function forgetPendingPartBudgetEntry(entry: PendingPartEntry): void {
+  const id = (entry as SizedPendingPartEntry)[pendingPartBudgetId]
+  if (id !== undefined) pendingPartBudgetEntries.delete(id)
+}
+
+function enforceGlobalPendingPartBudget(): void {
+  for (const [id, entry] of pendingPartBudgetEntries) if (!entry.isRetained()) pendingPartBudgetEntries.delete(id)
+  let bytes = 0
+  for (const entry of pendingPartBudgetEntries.values()) bytes += entry.bytes
+  if (bytes <= PENDING_PARTS_GLOBAL_BYTE_LIMIT) return
+  const oldest = [...pendingPartBudgetEntries.entries()].sort((left, right) =>
+    left[1].receivedAt - right[1].receivedAt || left[0] - right[0])
+  for (const [id, entry] of oldest) {
+    if (bytes <= PENDING_PARTS_GLOBAL_BYTE_LIMIT) break
+    pendingPartBudgetEntries.delete(id)
+    bytes -= entry.bytes
+    entry.remove()
+  }
+}
 
 function clonePart(part: ClientPart): ClientPart {
   // Cloning is intentionally disabled; message parts
@@ -256,7 +306,12 @@ export interface InstanceMessageStore {
   getLastCompactionMessageIndex: (sessionId: string) => number
   getMessage: (messageId: string) => MessageRecord | undefined
   getLatestTodoSnapshot: (sessionId: string) => LatestTodoSnapshot | undefined
-  clearSession: (sessionId: string, options?: { preserveScroll?: boolean; notify?: boolean }) => void
+  hasPendingSends: (sessionId: string) => boolean
+  trimSessionMessages: (sessionId: string, limit: number) => void
+  estimateSessionRetainedBytes: (sessionId: string, signal?: AbortSignal) => Promise<number>
+  hasLiveSessionMessages: (sessionId: string) => boolean
+  evictSessionTranscript: (sessionId: string) => void
+  clearSession: (sessionId: string, options?: { preserveScroll?: boolean; preservePromptDisplayOverrides?: boolean; notify?: boolean }) => void
   clearScrollSnapshots: () => void
   clearInstance: () => void
 }
@@ -270,6 +325,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
 
   // Requests awaiting same-ID persistence confirmation.
   const pendingSendIds = new Set<string>()
+  const droppedPendingMessageIds = new Set<string>()
   const optimisticPartIdsByMessage = new Map<string, Set<string>>()
 
   function forgetPendingSend(messageId: string): void {
@@ -369,6 +425,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
   function bumpSessionRevision(sessionId: string) {
     if (!sessionId) return
     setState("sessionRevisions", sessionId, (value = 0) => value + 1)
+    hooks?.onSessionChanged?.(instanceId, sessionId)
   }
 
   function getSessionRevisionValue(sessionId: string) {
@@ -414,6 +471,68 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     return state.usage[sessionId]
   }
 
+  function hasLiveSessionMessages(sessionId: string): boolean {
+    for (const messageId of state.sessions[sessionId]?.messageIds ?? []) {
+      const message = state.messages[messageId]
+      if (pendingSendIds.has(messageId) || message?.status === "sending" || message?.status === "streaming") return true
+    }
+    return false
+  }
+
+  function hasPendingSends(sessionId: string): boolean {
+    for (const messageId of pendingSendIds) {
+      if (state.messages[messageId]?.sessionId === sessionId) return true
+    }
+    return false
+  }
+
+  function estimateSessionRetainedBytes(sessionId: string, signal?: AbortSignal): Promise<number> {
+    const session = state.sessions[sessionId]
+    const renderCache = peekSessionMessageRenderCache(instanceId, sessionId)
+    const globalCacheEntries = [...getCacheRetainedEntriesForSession(instanceId, sessionId)]
+    const globalCacheKeyBytes = globalCacheEntries.reduce((total, entry) => total + entry.keyBytes, 0)
+    let hasPendingParts = false
+    for (const messageId in state.pendingParts) {
+      if (state.pendingParts[messageId]?.some((entry) => entry.sessionId === sessionId)) {
+        hasPendingParts = true
+        break
+      }
+    }
+    if ((!session || (session.messageIds.length === 0 && !session.revert)) && !renderCache && !hasPendingParts && globalCacheEntries.length === 0) {
+      return Promise.resolve(0)
+    }
+    function* retainedValues(): Generator<unknown> {
+      if (session) yield session
+      for (const messageId of session?.messageIds ?? []) {
+        yield state.messages[messageId]
+        yield messageInfoCache.get(messageId)
+        yield state.messageInfoVersion[messageId]
+        yield state.pendingParts[messageId]
+      }
+      for (const messageId in state.pendingParts) {
+        const entries = state.pendingParts[messageId]
+        if (entries?.some((entry) => entry.sessionId === sessionId) && !state.messages[messageId]) yield entries
+      }
+      for (const entry of state.permissions.queue) if (entry.permission.sessionID === sessionId) yield entry
+      if (session) {
+        yield state.usage[sessionId]
+        yield state.sessionRevisions[sessionId]
+        yield state.lastAssistantMessageIds[sessionId]
+        yield state.latestTodos[sessionId]
+      }
+      yield renderCache
+      if (session) yield* getRecordDisplayCacheEntries(instanceId, session.messageIds)
+      for (const entry of globalCacheEntries) yield entry.value
+    }
+    if (globalCacheKeyBytes > MAX_TRANSCRIPT_MEASUREMENT_BYTES) return Promise.resolve(Number.POSITIVE_INFINITY)
+    return estimateRetainedBytesIncrementally(retainedValues(), {
+      signal,
+      rootIterable: true,
+      maxBytes: MAX_TRANSCRIPT_MEASUREMENT_BYTES - globalCacheKeyBytes,
+      maxNodes: MAX_TRANSCRIPT_MEASUREMENT_NODES,
+    }).then((bytes) => Number.isFinite(bytes) ? bytes + globalCacheKeyBytes : bytes)
+  }
+
   function ensureSessionEntry(sessionId: string): SessionRecord {
     const existing = state.sessions[sessionId]
     if (existing) {
@@ -514,6 +633,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
       seenInputIds.add(input.id)
       return true
     })
+    for (const input of dedupedInputs) droppedPendingMessageIds.delete(input.id)
 
     const serverIds = dedupedInputs.map((item) => item.id)
     const serverIdSet = new Set(serverIds)
@@ -604,12 +724,14 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
         messageInfoCache.delete(id)
         forgetPendingSend(id)
         clearPromptDisplayOverride(instanceId, sessionId, id)
+        nextPendingParts[id]?.forEach(forgetPendingPartBudgetEntry)
         delete nextMessages[id]
         delete nextMessageInfoVersion[id]
         delete nextPendingParts[id]
         delete nextPermissionsByMessage[id]
       })
       clearRecordDisplayCacheForMessages(instanceId, omittedIds)
+      hooks?.onMessagesRemoved?.(instanceId, sessionId, omittedIds)
     }
 
     // Inbox admission can render before the message endpoint projects the
@@ -773,6 +895,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     pendingSendIds.delete(messageId)
     if (options?.clearOptimisticParts) optimisticPartIdsByMessage.delete(messageId)
     const record = state.messages[messageId]
+    if (record) hooks?.onSessionChanged?.(instanceId, record.sessionId)
     if (!record) return
     const optimisticPartIds = options?.clearOptimisticParts && record.role === "user"
       ? record.partIds.filter((id) => clientPartIds?.has(id))
@@ -815,10 +938,15 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
   }
 
   function retirePendingSends(sessionId: string) {
+    let changed = false
     for (const messageId of Array.from(pendingSendIds)) {
       const record = state.messages[messageId]
-      if (record?.sessionId === sessionId && record.status === "sent") pendingSendIds.delete(messageId)
+      if (record?.sessionId === sessionId && record.status === "sent") {
+        pendingSendIds.delete(messageId)
+        changed = true
+      }
     }
+    if (changed) hooks?.onSessionChanged?.(instanceId, sessionId)
   }
 
   // Apply an AUTHORITATIVE empty snapshot (server returned zero messages for
@@ -845,8 +973,10 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
       messageInfoCache.delete(id)
       forgetPendingSend(id)
       clearPromptDisplayOverride(instanceId, sessionId, id)
+      state.pendingParts[id]?.forEach(forgetPendingPartBudgetEntry)
     })
     clearRecordDisplayCacheForMessages(instanceId, droppedIds)
+    hooks?.onMessagesRemoved?.(instanceId, sessionId, droppedIds)
 
     batch(() => {
       setState(
@@ -934,6 +1064,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
   }
 
   function upsertMessage(input: MessageUpsertInput) {
+    const pendingDropRequiresReload = droppedPendingMessageIds.delete(input.id)
     const normalizedParts = normalizeParts(input.id, input.parts)
     const shouldBump = Boolean(input.bumpRevision || normalizedParts)
     const now = Date.now()
@@ -977,21 +1108,106 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     flushPendingParts(input.id)
     recomputeLastAssistantMessageId(input.sessionId)
     bumpSessionRevision(input.sessionId)
+    if (pendingDropRequiresReload) hooks?.onSessionCleared?.(instanceId, input.sessionId)
+  }
+
+  function markPendingPartDropped(messageId: string, sessionId?: string): void {
+    if (sessionId) {
+      hooks?.onSessionCleared?.(instanceId, sessionId)
+      hooks?.onSessionChanged?.(instanceId, sessionId)
+      return
+    }
+    droppedPendingMessageIds.delete(messageId)
+    droppedPendingMessageIds.add(messageId)
+    while (droppedPendingMessageIds.size > DROPPED_PENDING_MESSAGE_LIMIT) {
+      const oldest = droppedPendingMessageIds.values().next().value
+      if (oldest === undefined) break
+      droppedPendingMessageIds.delete(oldest)
+    }
   }
 
   function bufferPendingPart(entry: PendingPartEntry) {
-    setState("pendingParts", entry.messageId, (list = []) => [...list, entry])
+    const sessionId = entry.sessionId ?? (typeof (entry.part as any).sessionID === "string" ? (entry.part as any).sessionID : undefined)
+    const nextEntry = { ...entry, sessionId } as SizedPendingPartEntry
+    const retainedBytes = estimateRetainedBytes(nextEntry, PENDING_PART_MAX_RETAINED_BYTES)
+    if (retainedBytes > PENDING_PART_MAX_RETAINED_BYTES) {
+      markPendingPartDropped(entry.messageId, sessionId)
+      return
+    }
+    const budgetId = ++nextPendingPartBudgetId
+    Object.defineProperty(nextEntry, pendingPartRetainedBytes, { value: retainedBytes })
+    Object.defineProperty(nextEntry, pendingPartBudgetId, { value: budgetId })
+    const changedSessions = new Set<string>()
+    const droppedMessages = new Map<string, string | undefined>()
+    if (sessionId) changedSessions.add(sessionId)
+    setState("pendingParts", produce((draft: Record<string, PendingPartEntry[]>) => {
+      const messageEntries = [...(draft[entry.messageId] ?? []), nextEntry]
+      for (const dropped of messageEntries.slice(0, Math.max(0, messageEntries.length - PENDING_PARTS_PER_MESSAGE_LIMIT))) {
+        droppedMessages.set(entry.messageId, dropped.sessionId)
+      }
+      draft[entry.messageId] = messageEntries.slice(-PENDING_PARTS_PER_MESSAGE_LIMIT)
+
+      const pending: { messageId: string; entry: PendingPartEntry; bytes: number }[] = []
+      for (const messageId in draft) {
+        for (const value of draft[messageId] ?? []) pending.push({ messageId, entry: value, bytes: getPendingPartRetainedBytes(value) })
+      }
+      pending.sort((left, right) => left.entry.receivedAt - right.entry.receivedAt)
+
+      const sessionEntries = pending.filter((value) => value.entry.sessionId === sessionId)
+      const remove = new Set(pending.slice(0, Math.max(0, pending.length - PENDING_PARTS_GLOBAL_LIMIT)))
+      for (const value of sessionEntries.slice(0, Math.max(0, sessionEntries.length - PENDING_PARTS_PER_SESSION_LIMIT))) remove.add(value)
+      let sessionBytes = sessionEntries.reduce((total, value) => total + value.bytes, 0)
+      for (const value of sessionEntries) {
+        if (sessionBytes <= PENDING_PARTS_PER_SESSION_BYTE_LIMIT) break
+        remove.add(value)
+        sessionBytes -= value.bytes
+      }
+      let globalBytes = pending.reduce((total, value) => total + value.bytes, 0)
+      for (const value of pending) {
+        if (globalBytes <= PENDING_PARTS_GLOBAL_BYTE_LIMIT) break
+        remove.add(value)
+        globalBytes -= value.bytes
+      }
+      for (const value of remove) {
+        forgetPendingPartBudgetEntry(value.entry)
+        droppedMessages.set(value.messageId, value.entry.sessionId)
+        if (value.entry.sessionId) changedSessions.add(value.entry.sessionId)
+        const list = draft[value.messageId]
+        const index = list?.indexOf(value.entry) ?? -1
+        if (index >= 0) list.splice(index, 1)
+        if (list?.length === 0) delete draft[value.messageId]
+      }
+    }))
+    const isRetained = () => state.pendingParts[entry.messageId]?.some((value) => (value as SizedPendingPartEntry)[pendingPartBudgetId] === budgetId) ?? false
+    if (isRetained()) {
+      pendingPartBudgetEntries.set(budgetId, {
+        instanceId,
+        bytes: retainedBytes,
+        receivedAt: entry.receivedAt,
+        isRetained,
+        remove: () => {
+          setState("pendingParts", produce((draft: Record<string, PendingPartEntry[]>) => {
+            const list = draft[entry.messageId]
+            const index = list?.findIndex((value) => (value as SizedPendingPartEntry)[pendingPartBudgetId] === budgetId) ?? -1
+            if (index >= 0) list.splice(index, 1)
+            if (list?.length === 0) delete draft[entry.messageId]
+          }))
+          markPendingPartDropped(entry.messageId, sessionId)
+        },
+      })
+      enforceGlobalPendingPartBudget()
+    }
+    for (const [messageId, droppedSessionId] of droppedMessages) markPendingPartDropped(messageId, droppedSessionId)
+    for (const changedSessionId of changedSessions) hooks?.onSessionChanged?.(instanceId, changedSessionId)
   }
 
   function clearPendingPartsForMessage(messageId: string) {
-    setState("pendingParts", (prev) => {
-      if (!prev[messageId]) {
-        return prev
-      }
-      const next = { ...prev }
-      delete next[messageId]
-      return next
-    })
+    const entries = state.pendingParts[messageId]
+    if (!entries) return
+    entries.forEach(forgetPendingPartBudgetEntry)
+    setState("pendingParts", produce((draft: Record<string, PendingPartEntry[]>) => {
+      delete draft[messageId]
+    }))
   }
 
   function rebindPermissionForPart(messageId: string, partId: string, part: ClientPart) {
@@ -1044,7 +1260,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
   function applyPartUpdate(input: PartUpdateInput) {
     const message = state.messages[input.messageId]
     if (!message) {
-      bufferPendingPart({ messageId: input.messageId, part: input.part, receivedAt: Date.now() })
+      bufferPendingPart({ messageId: input.messageId, sessionId: typeof (input.part as any).sessionID === "string" ? (input.part as any).sessionID : undefined, part: input.part, receivedAt: Date.now() })
       return
     }
 
@@ -1157,6 +1373,8 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     if (!sessionIds.size && fallbackSessionId) sessionIds.add(fallbackSessionId)
 
     clearRecordDisplayCacheForMessages(instanceId, [messageId])
+    sessionIds.forEach((sessionId) => hooks?.onMessagesRemoved?.(instanceId, sessionId, [messageId]))
+    state.pendingParts[messageId]?.forEach(forgetPendingPartBudgetEntry)
 
     batch(() => {
       sessionIds.forEach((sessionId) => {
@@ -1452,6 +1670,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
       pruneMessagesAfterRevert(sessionId, revert.messageID)
     }
     setState("sessions", sessionId, "revert", revert ?? null)
+    bumpSessionRevision(sessionId)
   }
 
   function getSessionRevert(sessionId: string) {
@@ -1493,79 +1712,77 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     return state.sessions[sessionId]?.messageWindow
   }
 
-  function clearSession(sessionId: string, options?: { preserveScroll?: boolean; notify?: boolean }) {
+  function trimSessionMessages(sessionId: string, limit: number) {
+    const ids = state.sessions[sessionId]?.messageIds ?? []
+    const overflow = ids.length - Math.max(1, Math.floor(limit))
+    for (const messageId of ids.slice(0, Math.max(0, overflow))) removeMessage(messageId, sessionId)
+  }
+
+  function clearSession(sessionId: string, options?: { preserveScroll?: boolean; preservePromptDisplayOverrides?: boolean; notify?: boolean }) {
     if (!sessionId) return
 
-    clearPromptDisplayOverridesForSession(instanceId, sessionId)
+    if (!options?.preservePromptDisplayOverrides) clearPromptDisplayOverridesForSession(instanceId, sessionId)
 
     const messageIds = Object.values(state.messages)
       .filter((record) => record.sessionId === sessionId)
       .map((record) => record.id)
+    const messageIdSet = new Set(messageIds)
+    for (const [messageId, entries] of Object.entries(state.pendingParts)) {
+      for (const entry of entries) {
+        if (messageIdSet.has(messageId) || entry.sessionId === sessionId) forgetPendingPartBudgetEntry(entry)
+      }
+    }
  
     storeLog.info("Clearing session data", { instanceId, sessionId, messageCount: messageIds.length })
     clearRecordDisplayCacheForMessages(instanceId, messageIds)
+    clearSessionMessageRenderCache(instanceId, sessionId)
     messageIds.forEach((id) => forgetPendingSend(id))
  
     batch(() => {
-      setState("messages", (prev) => {
-        const next = { ...prev }
-        messageIds.forEach((id) => delete next[id])
-        return next
-      })
+      // Store setters merge returned objects: omitted keys still retain their
+      // payloads. Delete through produce before retiring byte accounting.
+      setState("messages", produce((draft) => {
+        messageIds.forEach((id) => delete draft[id])
+      }))
 
-      setState("messageInfoVersion", (prev) => {
-        const next = { ...prev }
-        messageIds.forEach((id) => delete next[id])
-        return next
-      })
+      setState("messageInfoVersion", produce((draft) => {
+        messageIds.forEach((id) => delete draft[id])
+      }))
 
       messageIds.forEach((id) => messageInfoCache.delete(id))
 
-      setState("pendingParts", (prev) => {
-        const next = { ...prev }
-        messageIds.forEach((id) => {
-          if (next[id]) delete next[id]
-        })
-        return next
-      })
-
-      setState("permissions", "byMessage", (prev) => {
-        const next = { ...prev }
-        messageIds.forEach((id) => {
-          if (next[id]) delete next[id]
-        })
-        return next
-      })
-
-      setState("usage", (prev) => {
-        const next = { ...prev }
-        delete next[sessionId]
-        return next
-      })
+      setState("pendingParts", produce((draft: Record<string, PendingPartEntry[]>) => {
+        for (const id of messageIds) delete draft[id]
+        for (const id in draft) if (draft[id]?.some((entry) => entry.sessionId === sessionId)) delete draft[id]
+      }))
 
-      setState("sessionRevisions", (prev) => {
-        const next = { ...prev }
-        delete next[sessionId]
-        return next
-      })
+      const belongsToSession = (entry: PermissionEntry) => entry.permission.sessionID === sessionId
+        || Boolean(entry.messageId && messageIdSet.has(entry.messageId))
+      setState("permissions", produce((draft) => {
+        draft.queue = draft.queue.filter((entry) => !belongsToSession(entry))
+        draft.active = draft.queue[0] ?? null
+        for (const messageId of Object.keys(draft.byMessage)) {
+          const entries = draft.byMessage[messageId]
+          for (const partId of Object.keys(entries)) {
+            if (messageIdSet.has(messageId) || belongsToSession(entries[partId])) delete entries[partId]
+          }
+          if (Object.keys(entries).length === 0) delete draft.byMessage[messageId]
+        }
+      }))
 
-      setState("lastAssistantMessageIds", (prev) => {
-        const next = { ...prev }
-        delete next[sessionId]
-        return next
-      })
+      setState("usage", produce((draft) => { delete draft[sessionId] }))
+      setState("sessionRevisions", produce((draft) => { delete draft[sessionId] }))
+      setState("lastAssistantMessageIds", produce((draft) => { delete draft[sessionId] }))
 
       if (!options?.preserveScroll) {
-        setState("scrollState", (prev) => {
-          const next = { ...prev }
+        setState("scrollState", produce((draft) => {
           const prefix = `${sessionId}:`
-          Object.keys(next).forEach((key) => {
+          Object.keys(draft).forEach((key) => {
             if (key.startsWith(prefix)) {
-              delete next[key]
+              delete draft[key]
             }
           })
-          return next
-        })
+        }))
       }
 
       setState("sessions", sessionId, (current) => {
@@ -1573,11 +1790,7 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
         return { ...current, messageIds: [] }
       })
 
-      setState("sessions", (prev) => {
-        const next = { ...prev }
-        delete next[sessionId]
-        return next
-      })
+      setState("sessions", produce((draft) => { delete draft[sessionId] }))
 
       setState("sessionOrder", (ids) => ids.filter((id) => id !== sessionId))
     })
@@ -1587,9 +1800,17 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
     if (options?.notify !== false) hooks?.onSessionCleared?.(instanceId, sessionId)
   }
 
+  function evictSessionTranscript(sessionId: string) {
+    clearSession(sessionId, { preserveScroll: true, preservePromptDisplayOverrides: true })
+  }
+
  
    function clearInstance() {
+     for (const [id, entry] of pendingPartBudgetEntries) if (entry.instanceId === instanceId) pendingPartBudgetEntries.delete(id)
+     droppedPendingMessageIds.clear()
      clearPromptDisplayOverridesForInstance(instanceId, Object.keys(state.sessions))
+     clearRecordDisplayCacheForInstance(instanceId)
+     clearInstanceMessageRenderCaches(instanceId)
      messageInfoCache.clear()
      pendingSendIds.clear()
      optimisticPartIdsByMessage.clear()
@@ -1644,6 +1865,11 @@ export function createInstanceMessageStore(instanceId: string, hooks?: MessageSt
       getLastCompactionMessageIndex,
       getMessage: (messageId: string) => state.messages[messageId],
       getLatestTodoSnapshot,
+      hasPendingSends,
+      trimSessionMessages,
+      estimateSessionRetainedBytes,
+      hasLiveSessionMessages,
+      evictSessionTranscript,
       clearSession,
       clearScrollSnapshots,
       clearInstance,
diff --git a/packages/ui/src/stores/message-v2/message-window.test.ts b/packages/ui/src/stores/message-v2/message-window.test.ts
index 587905a24..d53767378 100644
--- a/packages/ui/src/stores/message-v2/message-window.test.ts
+++ b/packages/ui/src/stores/message-v2/message-window.test.ts
@@ -4,6 +4,7 @@ import {
   emptyLatestWindow,
   planNewerWindow,
   planOlderWindow,
+  preserveMessageWindowCursor,
   type MessageWindowState,
   windowFromSnapshot,
   withOlderCursor,
@@ -67,3 +68,17 @@ test("restore uses the saved page without inventing a newer stack", () => {
     newerCursors: [null],
   })
 })
+
+test("preserves the current window while replacing scroll coordinates", () => {
+  assert.deepEqual(preserveMessageWindowCursor(
+    { scrollTop: 20, atBottom: false },
+    { windowIsLatest: false, windowCursor: "persisted", newerCursors: [null] },
+    { kind: "history", resumeCursor: "current", newerCursors: [null, "newer"] },
+  ), {
+    scrollTop: 20,
+    atBottom: false,
+    windowIsLatest: false,
+    windowCursor: "current",
+    newerCursors: [null, "newer"],
+  })
+})
diff --git a/packages/ui/src/stores/message-v2/message-window.ts b/packages/ui/src/stores/message-v2/message-window.ts
index c0d004d98..67a7ebef6 100644
--- a/packages/ui/src/stores/message-v2/message-window.ts
+++ b/packages/ui/src/stores/message-v2/message-window.ts
@@ -1,4 +1,5 @@
 export const MESSAGE_WINDOW_PAGE_SIZE = 200
+export const SESSION_MESSAGE_WINDOW_LIMIT = MESSAGE_WINDOW_PAGE_SIZE
 export const MAX_NEWER_CURSORS = 32
 
 export type MessageWindowKind = "latest" | "history"
@@ -88,6 +89,14 @@ export function toWindowSnapshot(window: MessageWindowState): MessageWindowSnaps
   }
 }
 
+export function preserveMessageWindowCursor<T extends object>(
+  snapshot: T,
+  current: MessageWindowSnapshot | undefined,
+  window: MessageWindowState | undefined,
+): T & MessageWindowSnapshot {
+  return { ...snapshot, ...(window ? toWindowSnapshot(window) : current) }
+}
+
 function sanitizeNewerCursors(cursors: readonly NewerCursor[] | undefined): NewerCursor[] {
   if (!cursors?.length) return []
   return cursors.slice(-MAX_NEWER_CURSORS)
diff --git a/packages/ui/src/stores/message-v2/record-display-cache.ts b/packages/ui/src/stores/message-v2/record-display-cache.ts
index 9e89ee716..48fb5095e 100644
--- a/packages/ui/src/stores/message-v2/record-display-cache.ts
+++ b/packages/ui/src/stores/message-v2/record-display-cache.ts
@@ -1,10 +1,12 @@
 import type { ClientPart } from "../../types/message"
+import { extractReasoningTextForRender } from "../../lib/message-render-cache"
 import type { MessageRecord } from "./types"
 
 type ClientPartWithRevision = ClientPart & { revision?: number }
 
 export interface RecordDisplayData {
   orderedParts: ClientPartWithRevision[]
+  truncated: boolean
 }
 
 interface RecordDisplayCacheEntry {
@@ -13,11 +15,21 @@ interface RecordDisplayCacheEntry {
 }
 
 const recordDisplayCache = new Map<string, RecordDisplayCacheEntry>()
+export const MESSAGE_PART_DISPLAY_LIMIT = 200
 
 function makeCacheKey(instanceId: string, messageId: string) {
   return `${instanceId}:${messageId}`
 }
 
+export function getRecordDisplayPartIds(record: MessageRecord): readonly string[] {
+  if (record.partIds.length <= MESSAGE_PART_DISPLAY_LIMIT) return record.partIds
+  const headCount = Math.floor(MESSAGE_PART_DISPLAY_LIMIT / 2)
+  return [
+    ...record.partIds.slice(0, headCount),
+    ...record.partIds.slice(-(MESSAGE_PART_DISPLAY_LIMIT - headCount)),
+  ]
+}
+
 export function buildRecordDisplayData(instanceId: string, record: MessageRecord): RecordDisplayData {
   const cacheKey = makeCacheKey(instanceId, record.id)
   const cached = recordDisplayCache.get(cacheKey)
@@ -26,14 +38,27 @@ export function buildRecordDisplayData(instanceId: string, record: MessageRecord
   }
 
   const orderedParts: ClientPartWithRevision[] = []
+  const partIds = getRecordDisplayPartIds(record)
 
-  for (const partId of record.partIds) {
+  for (const partId of partIds) {
     const entry = record.parts[partId]
     if (!entry?.data) continue
-    orderedParts.push({ ...(entry.data as ClientPart), revision: entry.revision })
+    const part = entry.data as ClientPart
+    if (part.type === "reasoning") {
+      const time = (part as any).time
+      orderedParts.push({
+        id: part.id,
+        type: "reasoning",
+        text: extractReasoningTextForRender(part),
+        time: time ? { start: time.start, end: time.end, created: time.created } : undefined,
+        revision: entry.revision,
+      } as ClientPartWithRevision)
+      continue
+    }
+    orderedParts.push({ ...part, revision: entry.revision })
   }
 
-  const data: RecordDisplayData = { orderedParts }
+  const data: RecordDisplayData = { orderedParts, truncated: record.partIds.length > MESSAGE_PART_DISPLAY_LIMIT }
   recordDisplayCache.set(cacheKey, { revision: record.revision, data })
   return data
 }
@@ -53,3 +78,10 @@ export function clearRecordDisplayCacheForMessages(instanceId: string, messageId
     recordDisplayCache.delete(makeCacheKey(instanceId, messageId))
   }
 }
+
+export function* getRecordDisplayCacheEntries(instanceId: string, messageIds: Iterable<string>): Generator<unknown> {
+  for (const messageId of messageIds) {
+    const entry = recordDisplayCache.get(makeCacheKey(instanceId, messageId))
+    if (entry) yield entry
+  }
+}
diff --git a/packages/ui/src/stores/message-v2/transcript-eviction.test.ts b/packages/ui/src/stores/message-v2/transcript-eviction.test.ts
new file mode 100644
index 000000000..9097c5fb2
--- /dev/null
+++ b/packages/ui/src/stores/message-v2/transcript-eviction.test.ts
@@ -0,0 +1,69 @@
+import assert from "node:assert/strict"
+import { it } from "node:test"
+import { createInstanceMessageStore } from "./instance-store.ts"
+
+it("releases transcript payloads and owned indexes, preserving siblings and the restoration snapshot", async () => {
+  const cleared: string[] = []
+  const store = createInstanceMessageStore("eviction-release", {
+    onSessionCleared: (_instanceId, sessionId) => cleared.push(sessionId),
+  })
+  for (const sessionId of ["target", "sibling"]) {
+    store.upsertMessage({
+      id: sessionId, sessionId, role: "assistant", status: "complete",
+      parts: [{ id: "text", type: "text", text: "x".repeat(1024 * 1024) } as any],
+    })
+    store.setMessageInfo(sessionId, {
+      id: sessionId, sessionID: sessionId, role: "assistant", cost: 1,
+      time: { created: 1, completed: 2 },
+      tokens: { input: 1, output: 1, reasoning: 0, cache: { read: 0, write: 0 } },
+    } as any)
+    store.bufferPendingPart({
+      messageId: `pending-${sessionId}`, sessionId,
+      part: { id: "part", type: "text", text: "pending" } as any, receivedAt: Date.now(),
+    })
+    store.setScrollSnapshot(sessionId, "message-stream", {
+      scrollTop: 42, atBottom: false, windowIsLatest: false, windowCursor: "older", newerCursors: [null],
+    })
+    store.upsertPermission({
+      permission: { id: `permission-${sessionId}`, sessionID: sessionId, action: "edit", resources: [] },
+      messageId: sessionId, partId: "tool", enqueuedAt: sessionId === "target" ? 1 : 2,
+    })
+  }
+  store.upsertPermission({
+    permission: { id: "unattached", sessionID: "target", action: "edit", resources: [] }, enqueuedAt: 3,
+  })
+  const snapshot = store.getScrollSnapshot("target", "message-stream")
+  assert.ok(await store.estimateSessionRetainedBytes("target") > 1024 * 1024)
+
+  try {
+    store.evictSessionTranscript("target")
+
+    // Checking just the visible ID list hides merging-setter retention bugs.
+    assert.equal(store.getMessage("target"), undefined)
+    assert.deepEqual(Object.keys(store.state.messages), ["sibling"])
+    assert.equal(store.state.sessions.target, undefined)
+    assert.equal(store.state.messageInfoVersion.target, undefined)
+    assert.equal(store.getMessageInfo("target"), undefined)
+    assert.equal(store.state.usage.target, undefined)
+    assert.equal(store.state.sessionRevisions.target, undefined)
+    assert.equal(store.state.lastAssistantMessageIds.target, undefined)
+    assert.equal(store.state.pendingParts["pending-target"], undefined)
+    assert.equal(store.state.permissions.byMessage.target, undefined)
+    assert.equal(store.state.permissions.byMessage.__global__, undefined)
+    assert.deepEqual(store.state.permissions.queue.map(entry => entry.permission.id), ["permission-sibling"])
+    assert.equal(store.state.permissions.active?.permission.id, "permission-sibling")
+    assert.equal(store.getScrollSnapshot("target", "message-stream"), snapshot)
+    assert.equal(await store.estimateSessionRetainedBytes("target"), 0)
+    assert.ok(store.state.pendingParts["pending-sibling"])
+    assert.ok(await store.estimateSessionRetainedBytes("sibling") > 1024 * 1024)
+    assert.deepEqual(cleared, ["target"])
+
+    store.clearSession("target")
+    assert.equal(store.getScrollSnapshot("target", "message-stream"), undefined)
+    assert.ok(store.getScrollSnapshot("sibling", "message-stream"))
+    store.upsertMessage({ id: "target", sessionId: "target", role: "assistant", status: "complete" })
+    assert.deepEqual(store.getMessage("target")?.partIds, [])
+  } finally {
+    store.clearInstance()
+  }
+})
diff --git a/packages/ui/src/stores/message-v2/types.ts b/packages/ui/src/stores/message-v2/types.ts
index 5a863bdcf..b04afdfd3 100644
--- a/packages/ui/src/stores/message-v2/types.ts
+++ b/packages/ui/src/stores/message-v2/types.ts
@@ -46,6 +46,7 @@ export interface SessionRecord {
 
 export interface PendingPartEntry {
   messageId: string
+  sessionId?: string
   part: ClientPart
   receivedAt: number
 }
diff --git a/packages/ui/src/stores/opencode-data-idle.test.ts b/packages/ui/src/stores/opencode-data-idle.test.ts
new file mode 100644
index 000000000..5d916d3c6
--- /dev/null
+++ b/packages/ui/src/stores/opencode-data-idle.test.ts
@@ -0,0 +1,163 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import type { OpenCodeEvent } from "@opencode/client"
+import { sdkManager } from "../lib/sdk-manager.ts"
+import { messageStoreBus } from "./message-v2/bus.ts"
+import { getRootClient } from "./opencode-client.ts"
+import { applyOpenCodeDataEvent, destroyOpenCodeData, finishOpenCodeDataEvent, getOpenCodeMessageRevision, getOpenCodeMutationRevision, projectOpenCodeMessages } from "./opencode-data.ts"
+
+const model = { providerID: "fixture", id: "fixture" }
+const sessionId = "session"
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (error: Error) => void
+  const promise = new Promise<T>((done, fail) => { resolve = done; reject = fail })
+  return { promise, resolve, reject }
+}
+
+function fixture(instanceId: string) {
+  let sequence = 0
+  let resynced: ReturnType<typeof applyOpenCodeDataEvent> | undefined
+  const projected = deferred<void>()
+  const project = (data: ReturnType<typeof applyOpenCodeDataEvent>) => projectOpenCodeMessages(instanceId, sessionId, data)
+  const emit = (type: string, data: Record<string, unknown> = {}) => {
+    const created = ++sequence
+    const event = { id: `event-${created}`, type, created, data: { sessionID: sessionId, ...data } } as OpenCodeEvent
+    const result = applyOpenCodeDataEvent(instanceId, "/work", event, project, next => {
+      resynced = next
+      projectOpenCodeMessages(instanceId, sessionId, next, false)
+      projected.resolve()
+    })
+    project(result)
+    finishOpenCodeDataEvent(instanceId, event)
+    return result
+  }
+  return {
+    emit, projected,
+    get resynced() { return resynced },
+    store: messageStoreBus.getOrCreate(instanceId),
+    fill() {
+      for (let index = 0; index < 200; index += 1) {
+        emit("session.step.started", { assistantMessageID: `m${index}`, agent: "build", model })
+        emit("session.step.ended", { assistantMessageID: `m${index}`, finish: "stop" })
+      }
+    },
+    finalStep() {
+      const base = { assistantMessageID: "final" }
+      emit("session.step.started", { ...base, agent: "build", model })
+      emit("session.text.started", base)
+      emit("session.text.delta", { ...base, ordinal: 0, delta: "final answer" })
+      emit("session.step.ended", { ...base, finish: "stop" })
+    },
+    cleanup() {
+      destroyOpenCodeData(instanceId)
+      messageStoreBus.unregisterInstance(instanceId)
+      sdkManager.destroyClientsForInstance(instanceId)
+    },
+  }
+}
+
+function assertFinal(store: ReturnType<typeof messageStoreBus.getOrCreate>) {
+  assert.ok(store.getSessionMessageIds(sessionId).includes("final"))
+  const message = store.getMessage("final")
+  assert.equal((message?.parts["final-text-0"]?.data as any)?.text, "final answer")
+  assert.equal(message?.status, "complete")
+  assert.ok(store.getMessageInfo("final")?.time?.completed)
+  assert.ok(store.getSessionMessageIds(sessionId).length <= 200)
+}
+
+test("idle drains the queued final step before retiring a rotating reducer", async () => {
+  const f = fixture("idle-rotation-drain")
+  try {
+    f.fill()
+    f.finalStep()
+    const retiring = f.emit("session.idle")
+    assert.equal(f.store.getMessage("final"), undefined, "the final step is still queued")
+    await new Promise<void>(resolve => setImmediate(resolve))
+    assertFinal(f.store)
+    const replacement = f.emit("permission.replied", { requestID: "missing" })
+    assert.notEqual(replacement, retiring, "release the idle reducer after the final projection")
+    assert.deepEqual(replacement.session.message.list(sessionId), [])
+    assertFinal(f.store)
+  } finally { f.cleanup() }
+})
+
+test("a new execution cancels deferred idle retirement while rotation drains", async () => {
+  const f = fixture("idle-rotation-resumed")
+  try {
+    f.fill()
+    f.finalStep()
+    const retained = f.emit("session.idle")
+    f.emit("session.execution.started")
+    f.emit("session.step.started", { assistantMessageID: "resumed", agent: "build", model })
+    await new Promise<void>(resolve => setImmediate(resolve))
+    f.emit("session.text.started", { assistantMessageID: "resumed" })
+    const current = f.emit("session.text.delta", { assistantMessageID: "resumed", delta: "still running" })
+    assert.equal(current, retained)
+    assert.equal((f.store.getMessage("resumed")?.parts["resumed-text-0"]?.data as any)?.text, "still running")
+  } finally { f.cleanup() }
+})
+
+for (const phase of ["scheduled", "inflight", "retry"] as const) {
+  test(`idle preserves the final authoritative page during ${phase} overflow recovery`, { timeout: 5000 }, async () => {
+    const instanceId = `idle-resync-${phase}`
+    const f = fixture(instanceId)
+    const first = deferred<any>()
+    const started = deferred<void>()
+    const page = { data: [{
+      id: "final", type: "assistant", agent: "build", model,
+      content: [{ type: "text", text: "final answer" }], time: { created: 5000, completed: 5001 },
+    }], cursor: {} }
+    const client = getRootClient(instanceId) as any
+    let reads = 0
+    client.session.get = async () => ({ id: sessionId, location: { directory: "/work" }, time: { created: 1, updated: 5001 } })
+    client.session.active = async () => ({})
+    client.session.inbox = { list: async () => [] }
+    client.permission.list = async () => []
+    client.session.form.list = async () => []
+    client.message.list = () => {
+      reads += 1
+      started.resolve()
+      return reads === 1 && phase !== "scheduled" ? first.promise : Promise.resolve(page)
+    }
+    try {
+      f.fill()
+      for (let index = 0; index < 4096; index += 1) {
+        // Fill the queue without repeatedly normalizing the unchanged old page.
+        // Terminal delivery below uses the production apply/project/finish order.
+        applyOpenCodeDataEvent(instanceId, "/work", {
+          id: `overflow-${index}`, type: "session.step.started", created: 500 + index,
+          data: { sessionID: sessionId, assistantMessageID: `overflow-${index}`, agent: "build", model },
+        } as OpenCodeEvent)
+      }
+      if (phase !== "scheduled") await started.promise
+      f.emit("session.step.ended", { assistantMessageID: "final", finish: "stop" })
+      f.emit("session.idle")
+      assert.equal(f.store.getMessage("final"), undefined)
+      if (phase === "inflight") first.resolve({ data: [], cursor: {} })
+      if (phase === "retry") first.reject(new Error("temporary recovery failure"))
+      await f.projected.promise
+      assert.equal(reads, phase === "scheduled" ? 1 : 2)
+      assertFinal(f.store)
+      const replacement = f.emit("permission.replied", { requestID: "missing" })
+      assert.notEqual(replacement, f.resynced, "free the reconciled idle payload")
+      assert.deepEqual(replacement.session.message.list(sessionId), [])
+      assertFinal(f.store)
+    } finally { first.resolve(page); f.cleanup() }
+  })
+}
+
+test("idle payload disposal preserves monotonic message and mutation revisions", () => {
+  const instanceId = "idle-request-revisions"
+  const f = fixture(instanceId)
+  try {
+    for (let revision = 1; revision <= 3; revision += 1) {
+      const reducer = f.emit("session.inbox.cancelled", { inboxID: "removed" })
+      f.emit("session.idle")
+      assert.equal(getOpenCodeMutationRevision(instanceId, sessionId), revision)
+      assert.equal(getOpenCodeMessageRevision(instanceId, sessionId), revision)
+      assert.notEqual(f.emit("permission.replied", { requestID: "missing" }), reducer)
+    }
+  } finally { f.cleanup() }
+})
diff --git a/packages/ui/src/stores/opencode-data.test.ts b/packages/ui/src/stores/opencode-data.test.ts
index 96fdb838e..5a9da23dc 100644
--- a/packages/ui/src/stores/opencode-data.test.ts
+++ b/packages/ui/src/stores/opencode-data.test.ts
@@ -4,7 +4,7 @@ import { createEffect, createRoot } from "solid-js"
 import { messageStoreBus } from "./message-v2/bus.ts"
 import { seedSessionMessagesV2 } from "./message-v2/bridge.ts"
 import { normalizeSessionMessage } from "./message-v2/normalizers.ts"
-import { applyOpenCodeDataEvent, destroyOpenCodeData, getOpenCodeMessageRevision, getOpenCodeMutationRevision, getOpenCodeSessionInbox, projectOpenCodeMessages } from "./opencode-data.ts"
+import { applyOpenCodeDataEvent, destroyOpenCodeData, finishOpenCodeDataEvent, getOpenCodeMessageRevision, getOpenCodeMutationRevision, getOpenCodeSessionInbox, projectOpenCodeMessages } from "./opencode-data.ts"
 import { emptyLatestWindow } from "./message-v2/message-window.ts"
 import { getRootClient } from "./opencode-client.ts"
 import { sdkManager } from "../lib/sdk-manager.ts"
@@ -1129,6 +1129,29 @@ describe("OpenCode data projection", () => {
     }
   })
 
+  it("keeps another session's live reducer after a terminal event", () => {
+    const instanceId = "opencode-data-session-isolation"
+    const event = (sessionID: string, type: string, data: Record<string, unknown> = {}) => ({
+      id: `${sessionID}-${type}`, type, created: 1,
+      data: { sessionID, assistantMessageID: `${sessionID}-assistant`, ...data },
+    } as any)
+    try {
+      applyOpenCodeDataEvent(instanceId, "/work", event("active", "session.step.started", {
+        agent: "build", model: { providerID: "provider", id: "model" },
+      }))
+      const idle = event("idle", "session.idle")
+      applyOpenCodeDataEvent(instanceId, "/work", idle)
+      finishOpenCodeDataEvent(instanceId, idle)
+      applyOpenCodeDataEvent(instanceId, "/work", event("active", "session.text.started"))
+      const data = applyOpenCodeDataEvent(instanceId, "/work", event("active", "session.text.delta", { ordinal: 0, delta: "kept" }))
+      projectOpenCodeMessages(instanceId, "active", data)
+      assert.equal((messageStoreBus.getOrCreate(instanceId).getMessage("active-assistant")?.parts["active-assistant-text-0"]?.data as any)?.text, "kept")
+    } finally {
+      destroyOpenCodeData(instanceId)
+      if (messageStoreBus.getInstance(instanceId)) messageStoreBus.unregisterInstance(instanceId)
+    }
+  })
+
   it("does not project live events into a historical window", () => {
     const instanceId = "opencode-data-history-window"
     const sessionId = "session"
diff --git a/packages/ui/src/stores/opencode-data.ts b/packages/ui/src/stores/opencode-data.ts
index e1ab17028..95d4aa627 100644
--- a/packages/ui/src/stores/opencode-data.ts
+++ b/packages/ui/src/stores/opencode-data.ts
@@ -37,6 +37,7 @@ type TranscriptEntry = {
   freshEntry?: DataEntry
   retryCount: number
   retryTimer?: ReturnType<typeof setTimeout>
+  retireWhenDrained: boolean
   queue: QueuedTranscriptEvent[]
   onResynced?: (data: Data) => void
 }
@@ -227,6 +228,7 @@ function ensureTranscript(instanceId: string, sessionId: string, directory: stri
     resyncing: false,
     resyncGeneration: 0,
     retryCount: 0,
+    retireWhenDrained: false,
     queue: [],
   }
   transcriptEntries.set(key, transcript)
@@ -444,6 +446,7 @@ async function resyncAuthoritativeTranscript(
 
     transcript.onResynced?.(fresh.data)
     if (transcript.entry === fresh && !transcript.needsAuthoritativeResync) transcript.preserveNativePageOnResync = false
+    retireDrainedTranscript(instanceId, sessionId, transcript)
   } catch {
     if (!isResyncCurrent(instanceId, sessionId, transcript, generation, fresh)) return
     transcript.resyncing = false
@@ -534,6 +537,7 @@ async function rotateTranscript(
   } finally {
     if (transcript.rotationGeneration === generation) transcript.rotating = false
     if (!isTranscriptCurrent(instanceId, sessionId, transcript) || transcript.entry !== entry) entry.dispose()
+    retireDrainedTranscript(instanceId, sessionId, transcript)
   }
 }
 
@@ -596,6 +600,8 @@ export function applyOpenCodeDataEvent(
     : undefined
   const entry = transcript?.entry ?? primary
   if (transcript && typeof sessionId === "string") {
+    // A new execution must not inherit a preceding idle event's deferred cleanup.
+    if (event.type === "session.execution.started" || eventMayAppendMessage(event)) transcript.retireWhenDrained = false
     const key = messageRevisionKey(instanceId, sessionId)
     fullDataRevisions.set(key, (fullDataRevisions.get(key) ?? 0) + 1)
     if (eventAffectsMessages(event)) messageRevisions.set(key, (messageRevisions.get(key) ?? 0) + 1)
@@ -692,7 +698,42 @@ export function projectOpenCodeMessages(
   }
 }
 
-export function destroyOpenCodeData(instanceId: string): void {
+function retireDrainedTranscript(instanceId: string, sessionId: string, transcript: TranscriptEntry): void {
+  if (!transcript.retireWhenDrained || !isTranscriptCurrent(instanceId, sessionId, transcript)
+    || transcript.rotating || transcript.resyncing || transcript.needsAuthoritativeResync
+    || transcript.retryTimer || transcript.queue.length) return
+  destroyOpenCodeData(instanceId, sessionId)
+}
+
+export function finishOpenCodeDataEvent(instanceId: string, event: OpenCodeEvent): void {
+  const sessionId = eventSessionId(event)
+  if (sessionId === undefined) return
+  if (event.type === "session.deleted") destroyOpenCodeData(instanceId, sessionId)
+  if (event.type !== "session.idle") return
+  const transcript = transcriptEntries.get(messageRevisionKey(instanceId, sessionId))
+  if (!transcript) return
+  // The caller has projected the synchronous page. Queued terminal updates and
+  // overflow recovery must publish their final page before releasing its reducer.
+  transcript.retireWhenDrained = true
+  retireDrainedTranscript(instanceId, sessionId, transcript)
+}
+
+export function destroyOpenCodeData(instanceId: string, sessionId?: string): void {
+  if (sessionId !== undefined) {
+    const key = messageRevisionKey(instanceId, sessionId)
+    const transcript = transcriptEntries.get(key)
+    if (transcript) {
+      invalidateTranscript(transcript)
+      transcript.entry.dispose()
+      transcriptEntries.delete(key)
+    }
+    // Payload lifetime is shorter than request authority: a pending native page
+    // must never see a pre-mutation revision again after idle/eviction. These
+    // scalar fences are released on deletion or a fenced instance-generation reset.
+    fullDataRevisions.delete(key)
+    instanceDataRevision(instanceId)[1]((current) => current + 1)
+    return
+  }
   instanceGenerations.set(instanceId, ++nextInstanceGeneration)
   entries.get(instanceId)?.dispose()
   entries.delete(instanceId)
diff --git a/packages/ui/src/stores/session-actions.test.ts b/packages/ui/src/stores/session-actions.test.ts
index 338cacadf..9c63baec1 100644
--- a/packages/ui/src/stores/session-actions.test.ts
+++ b/packages/ui/src/stores/session-actions.test.ts
@@ -7,6 +7,7 @@ import type { Session } from "../types/session.ts"
 import { addInstance, removeInstance, updateInstance } from "./instances.ts"
 import {
   abortSession,
+  compactSession,
   deleteMessagePart,
   deleteMessageTechnicalParts,
   deleteTechnicalPartGroup,
@@ -742,6 +743,33 @@ describe("native session selection persistence", () => {
 })
 
 describe("native prompt serialization", () => {
+  it("admits compaction after an in-flight prompt", async () => {
+    const admissions: string[] = []
+    let releasePrompt!: () => void
+    const promptPending = new Promise<void>((resolve) => { releasePrompt = resolve })
+    seed({ session: {
+      instructions: { entry: { put: async () => {}, remove: async () => {} } },
+      switchAgent: async () => {},
+      switchModel: async () => {},
+      prompt: async (input: any) => {
+        admissions.push("prompt")
+        await promptPending
+        return { id: input.id }
+      },
+      compact: async () => { admissions.push("compact") },
+    } })
+
+    const prompt = sendMessage(instanceId, sessionId, "first")
+    await new Promise((resolve) => setImmediate(resolve))
+    const compact = compactSession(instanceId, sessionId)
+    await new Promise((resolve) => setImmediate(resolve))
+    assert.deepEqual(admissions, ["prompt"])
+
+    releasePrompt()
+    await Promise.all([prompt, compact])
+    assert.deepEqual(admissions, ["prompt", "compact"])
+  })
+
   it("admits concurrent prompts in submission order", async () => {
     const prompts: string[] = []
     let releaseFirst!: () => void
diff --git a/packages/ui/src/stores/session-actions.ts b/packages/ui/src/stores/session-actions.ts
index dd30020f4..b79802734 100644
--- a/packages/ui/src/stores/session-actions.ts
+++ b/packages/ui/src/stores/session-actions.ts
@@ -17,6 +17,7 @@ import { isSessionBusy } from "./session-status"
 import { getDefaultModel, isModelValid } from "./session-models"
 import { updateSessionInfo } from "./message-v2/session-info"
 import { messageStoreBus } from "./message-v2/bus"
+import { MESSAGE_WINDOW_PAGE_SIZE } from "./message-v2/message-window"
 import { normalizeSessionMessage } from "./message-v2/normalizers"
 import { getLogger } from "../lib/logger"
 import { clearConversationPlaybackForSession } from "./conversation-speech"
@@ -292,6 +293,7 @@ async function sendMessage(
       isEphemeral: true,
       clientPromptDisplayMetadata: preparedPrompt.displayMetadata,
     })
+    store.trimSessionMessages(sessionId, MESSAGE_WINDOW_PAGE_SIZE)
     store.markSendPending(messageId)
   }
 
@@ -545,7 +547,11 @@ async function renameSession(instanceId: string, sessionId: string, nextTitle: s
 }
 
 async function compactSession(instanceId: string, sessionId: string): Promise<void> {
-  await getRootClient(instanceId).session.compact({ sessionID: sessionId })
+  await admitSessionAction(instanceId, sessionId, async () => {
+    if (!instances().get(instanceId)?.client) throw new Error("Instance not ready")
+    if (!sessions().get(instanceId)?.has(sessionId)) throw new Error("Session not found")
+    await getRootClient(instanceId).session.compact({ sessionID: sessionId })
+  })
 }
 
 function applyUpdatedMessage(instanceId: string, sessionId: string, source: SessionMessageInfo): void {
diff --git a/packages/ui/src/stores/session-api.ts b/packages/ui/src/stores/session-api.ts
index 7869e109a..61b290af9 100644
--- a/packages/ui/src/stores/session-api.ts
+++ b/packages/ui/src/stores/session-api.ts
@@ -31,6 +31,9 @@ import {
   setAgents,
   setMessagesLoaded,
   advanceMessageLoadEpoch,
+  finishMessageLoad,
+  getMessageLoadSignal,
+  supersedeSessionMessageLoad,
   invalidateSessionMessageLoad,
   isCurrentMessageLoad,
   setSessionMessagesLoadError,
@@ -65,16 +68,6 @@ import { normalizeSessionMessage } from "./message-v2/normalizers"
 import { updateSessionInfo } from "./message-v2/session-info"
 import { seedSessionMessagesV2, reconcilePendingPermissionsV2 } from "./message-v2/bridge"
 import { messageStoreBus } from "./message-v2/bus"
-import {
-  emptyLatestWindow,
-  isLatestWindow,
-  planNewerWindow,
-  planOlderWindow,
-  toWindowSnapshot,
-  windowFromSnapshot,
-  withOlderCursor,
-  type MessageWindowState,
-} from "./message-v2/message-window"
 import { clearCacheForSession } from "../lib/global-cache"
 import { getLogger } from "../lib/logger"
 import { getOpencodeErrorMessage } from "../lib/opencode-api"
@@ -88,6 +81,18 @@ import {
 const MAX_SESSION_LIST_PAGES = 1_000
 import { getInstanceMetadata } from "./instance-metadata"
 import { mergeFetchedSessionRuntimeState, resolveAuthoritativeGenerationRecovery } from "./session-generation-recovery"
+import { listMessageWindow } from "./session-message-pages"
+import {
+  MESSAGE_WINDOW_PAGE_SIZE,
+  emptyLatestWindow,
+  isLatestWindow,
+  planNewerWindow,
+  planOlderWindow,
+  toWindowSnapshot,
+  windowFromSnapshot,
+  withOlderCursor,
+  type MessageWindowState,
+} from "./message-v2/message-window"
 import { fetchCommands } from "./commands"
 import { locationAuthorityKey, requestLocationOptions, toRequestLocation } from "./request-locations"
 import { getOpenCodeInstanceGeneration, getOpenCodeMessageRevision, getOpenCodeMutationRevision } from "./opencode-data"
@@ -106,11 +111,13 @@ const sessionPageTraversals = new Map<string, { cursors: Set<string>; pages: num
 interface MessagePageRequest {
   controller: AbortController
   consumers: Set<symbol>
-  request: Promise<void>
+  request: Promise<boolean>
 }
 
 const messagePageRequests = new Map<string, MessagePageRequest>()
 const messageHistoryAuthorities = new Map<string, object>()
+const createSessionAuthorities = new Map<string, object>()
+const deleteSessionAuthorities = new Map<string, object>()
 const MESSAGE_STREAM_SCOPE = "message-stream"
 const MAX_LATEST_WINDOW_REVISION_RETRIES = 3
 const LATEST_WINDOW_RETRY_DELAY_MS = 50
@@ -126,28 +133,30 @@ function messagePageKey(instanceId: string, sessionId: string): string {
 
 function captureInstanceRequestAuthority(instanceId: string): () => boolean {
   const generation = getOpenCodeInstanceGeneration(instanceId)
+  const client = instances().get(instanceId)?.client
   return () => getOpenCodeInstanceGeneration(instanceId) === generation
+    && instances().get(instanceId)?.client === client
 }
 
 function beginMessageHistoryTraversal(instanceId: string, sessionId: string): () => void {
   const key = messagePageKey(instanceId, sessionId)
   const authority = {}
   messageHistoryAuthorities.set(key, authority)
-  invalidateSessionMessageLoad(instanceId, sessionId)
+  supersedeSessionMessageLoad(instanceId, sessionId)
   for (const requestKey of messagePageRequests.keys()) {
     if (requestKey.startsWith(`${key}\0`)) messagePageRequests.delete(requestKey)
   }
   return () => {
     if (messageHistoryAuthorities.get(key) !== authority) return
     messageHistoryAuthorities.delete(key)
-    invalidateSessionMessageLoad(instanceId, sessionId)
+    supersedeSessionMessageLoad(instanceId, sessionId)
   }
 }
 
 function invalidateMessageHistoryTraversal(instanceId: string, sessionId: string): void {
   const key = messagePageKey(instanceId, sessionId)
   messageHistoryAuthorities.delete(key)
-  invalidateSessionMessageLoad(instanceId, sessionId)
+  supersedeSessionMessageLoad(instanceId, sessionId)
   for (const requestKey of messagePageRequests.keys()) {
     if (requestKey.startsWith(`${key}\0`)) messagePageRequests.delete(requestKey)
   }
@@ -1024,7 +1033,6 @@ async function createSession(instanceId: string, agent?: string): Promise<Sessio
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
   }
-
   const activeId = activeSessionId().get(instanceId)
   const activeLocation = activeId && activeId !== "info"
     ? sessions().get(instanceId)?.get(activeId)?.location
@@ -1049,6 +1057,8 @@ async function createSession(instanceId: string, agent?: string): Promise<Sessio
     next.creatingSession.set(instanceId, true)
     return next
   })
+  const loadingAuthority = {}
+  createSessionAuthorities.set(instanceId, loadingAuthority)
 
   try {
     log.info(`[HTTP] POST /session.create for instance ${instanceId}`)
@@ -1118,11 +1128,14 @@ async function createSession(instanceId: string, agent?: string): Promise<Sessio
     log.error("Failed to create session:", error)
     throw error
   } finally {
-    setLoading((prev) => {
-      const next = { ...prev }
-      next.creatingSession.set(instanceId, false)
-      return next
-    })
+    if (createSessionAuthorities.get(instanceId) === loadingAuthority) {
+      createSessionAuthorities.delete(instanceId)
+      setLoading((prev) => {
+        const next = { ...prev }
+        next.creatingSession.set(instanceId, false)
+        return next
+      })
+    }
   }
 }
 
@@ -1135,7 +1148,6 @@ async function forkSession(
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
   }
-
   const client = getRootClient(instanceId)
   const generationCurrent = captureInstanceRequestAuthority(instanceId)
 
@@ -1198,9 +1210,11 @@ async function deleteSession(instanceId: string, sessionId: string): Promise<voi
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
   }
-
   const client = getRootClient(instanceId)
   const generationCurrent = captureInstanceRequestAuthority(instanceId)
+  const loadingKey = messagePageKey(instanceId, sessionId)
+  const loadingAuthority = {}
+  deleteSessionAuthorities.set(loadingKey, loadingAuthority)
 
   setLoading((prev) => {
     const next = { ...prev }
@@ -1221,14 +1235,17 @@ async function deleteSession(instanceId: string, sessionId: string): Promise<voi
     log.error("Failed to delete session:", error)
     throw error
   } finally {
-    setLoading((prev) => {
-      const next = { ...prev }
-      const deleting = next.deletingSession.get(instanceId)
-      if (deleting) {
-        deleting.delete(sessionId)
-      }
-      return next
-    })
+    if (deleteSessionAuthorities.get(loadingKey) === loadingAuthority) {
+      deleteSessionAuthorities.delete(loadingKey)
+      setLoading((prev) => {
+        const next = { ...prev }
+        const deleting = next.deletingSession.get(instanceId)
+        if (deleting) {
+          deleting.delete(sessionId)
+        }
+        return next
+      })
+    }
   }
 }
 
@@ -1256,7 +1273,9 @@ function removeSessionRuntimeState(instanceId: string, sessionId: string, author
 
   // Drop normalized message state and caches for this session.
   const pageKey = messagePageKey(instanceId, sessionId)
-  messagePageRequests.delete(pageKey)
+  for (const requestKey of messagePageRequests.keys()) {
+    if (requestKey.startsWith(`${pageKey}\0`)) messagePageRequests.delete(requestKey)
+  }
   messageHistoryAuthorities.delete(pageKey)
   messageStoreBus.getOrCreate(instanceId).clearSession(sessionId)
   clearCacheForSession(instanceId, sessionId)
@@ -1316,7 +1335,6 @@ async function loadAgents(instanceId: string, location: LocationRef): Promise<bo
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
   }
-
   const rootClient = getRootClient(instanceId)
   const generationCurrent = captureInstanceRequestAuthority(instanceId)
   const requestKey = `${instanceId}\0${catalogLocationKey(location)}`
@@ -1390,7 +1408,6 @@ async function loadProviders(instanceId: string, location: LocationRef): Promise
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
   }
-
   const rootClient = getRootClient(instanceId)
   const generationCurrent = captureInstanceRequestAuthority(instanceId)
   const requestKey = `${instanceId}\0${catalogLocationKey(location)}`
@@ -1451,10 +1468,9 @@ function planMessageWindowLoad(
   if (intent === "oldest") {
     return { order: "asc", next: { kind: "history", newerCursors: [] } }
   }
-  return {
-    cursor: current.kind === "history" ? current.resumeCursor : undefined,
-    next: current.kind === "history" ? { ...current } : emptyLatestWindow(),
-  }
+  if (current.kind !== "history") return { next: emptyLatestWindow() }
+  const forward = !current.newerCursors.includes(null)
+  return { cursor: current.resumeCursor, next: { ...current }, ...(forward ? { forward: true } : {}) }
 }
 
 function commitMessageWindow(
@@ -1504,30 +1520,31 @@ async function loadMessages(
   instanceId: string,
   sessionId: string,
   options?: MessageLoadOptions,
-): Promise<void> {
+): Promise<boolean> {
   const force = options?.force ?? false
   const intent = options?.intent ?? "open"
   const revisionRetry = options?.revisionRetry ?? 0
   const store = messageStoreBus.getOrCreate(instanceId)
   const storedWindow = store.getMessageWindow(sessionId)
-  const scrollSnapshot = store.getScrollSnapshot(sessionId, MESSAGE_STREAM_SCOPE)
-  const currentWindow = storedWindow ?? windowFromSnapshot(scrollSnapshot)
+  let expectedWindow = storedWindow
+  const snapshot = store.getScrollSnapshot(sessionId, MESSAGE_STREAM_SCOPE)
+  const currentWindow = storedWindow ?? windowFromSnapshot(snapshot)
   const planned: ReturnType<typeof planMessageWindowLoad> = options?.anchorMessageId
     ? { cursor: historyWindowCursor({ kind: "around", messageID: options.anchorMessageId }), next: currentWindow }
     : planMessageWindowLoad(currentWindow, intent)
-  if (!planned) return
+  if (!planned) return false
 
   const alreadyLoaded = messagesLoaded().get(instanceId)?.has(sessionId)
   if (alreadyLoaded && !force) {
     if (!sessionInfoByInstance().get(instanceId)?.has(sessionId)) updateSessionInfo(instanceId, sessionId)
-    return
+    return false
   }
 
   const previousError = getSessionMessagesLoadError(instanceId, sessionId)
-  if (previousError && !force) return
+  if (previousError && !force) return false
 
   const isLoading = loading().loadingMessages.get(instanceId)?.has(sessionId)
-  if (isLoading && !force) return
+  if (isLoading && !force) return false
 
   const instance = instances().get(instanceId)
   if (!instance || !instance.client) throw new Error("Instance not ready")
@@ -1538,24 +1555,31 @@ async function loadMessages(
   if (!session) throw new Error("Session not found")
 
   const loadEpoch = advanceMessageLoadEpoch(instanceId, sessionId)
+  const loadSignal = getMessageLoadSignal(instanceId, sessionId)!
+  const signal = options?.signal ? AbortSignal.any([loadSignal, options.signal]) : loadSignal
   const historyAuthority = messageHistoryAuthorities.get(messagePageKey(instanceId, sessionId))
   const generationCurrent = captureInstanceRequestAuthority(instanceId)
   const mutationRevision = getOpenCodeMutationRevision(instanceId, sessionId)
   const ownsLoadState = () => instances().get(instanceId)?.client === instanceClient
     && isCurrentMessageLoad(instanceId, sessionId, loadEpoch)
-    && sessions().get(instanceId)?.has(sessionId)
+    && sessions().get(instanceId)?.has(sessionId) === true
     && generationCurrent()
     && (!historyAuthority || messageHistoryAuthorities.get(messagePageKey(instanceId, sessionId)) === historyAuthority)
   const isCurrentLoad = () => ownsLoadState() && options?.signal?.aborted !== true
   const isCurrent = () => isCurrentLoad()
     && getOpenCodeMutationRevision(instanceId, sessionId) === mutationRevision
-    && store.getMessageWindow(sessionId) === storedWindow
+    && store.getMessageWindow(sessionId) === expectedWindow
+  const commitCurrentWindow = (window: MessageWindowState, windowIntent: MessageWindowIntent) => {
+    commitMessageWindow(instanceId, sessionId, window, windowIntent, options?.anchorMessageId)
+    expectedWindow = store.getMessageWindow(sessionId)
+  }
   options?.registerInvalidation?.(() => {
     if (isCurrentMessageLoad(instanceId, sessionId, loadEpoch)) invalidateSessionMessageLoad(instanceId, sessionId)
   })
   const messageRevision = store.getSessionRevision(sessionId)
   const liveMessageRevision = getOpenCodeMessageRevision(instanceId, sessionId)
   let retryAfterRevisionConflict = false
+  let committed = false
   const showLoading = intent === "open" || intent === "latest"
 
   if (showLoading) {
@@ -1579,7 +1603,7 @@ async function loadMessages(
     const directTarget = historyWindowTarget(planned.cursor)
       ?? (lastResident ? { kind: "after" as const, messageID: lastResident } : undefined)
     if (directTarget) {
-      const direct = await readHistoryWindow(instanceId, sessionId, directTarget, options?.signal)
+      const direct = await readHistoryWindow(instanceId, sessionId, directTarget, signal)
       response = direct.response
       directWindow = direct.window
       responseAscending = true
@@ -1590,10 +1614,10 @@ async function loadMessages(
         if (page >= MESSAGE_CURSOR_SEEK_LIMIT) throw new Error(tGlobal("messageSection.loadError.detail"))
         response = await client.message.list({
           sessionID: sessionId,
-          limit: 200,
+          limit: MESSAGE_WINDOW_PAGE_SIZE,
           ...(cursor ? { cursor } : { order: "desc" }),
-        }, options?.signal ? { signal: options.signal } : undefined)
-        if (!isCurrent()) return
+        }, { signal })
+        if (!isCurrent()) return false
         if (response.cursor?.next === planned.seekNewer) {
           resolvedNext = cursor
             ? { kind: "history", resumeCursor: cursor, newerCursors: [null, null] }
@@ -1606,30 +1630,46 @@ async function loadMessages(
         cursor = next
       }
       responseAscending = false
+    } else if (intent === "open" && snapshot && planned.order !== "asc") {
+      const page = await listMessageWindow(client, sessionId, {
+        limit: MESSAGE_WINDOW_PAGE_SIZE,
+        cursor: planned.cursor,
+        forward: planned.forward,
+        signal,
+        isAuthoritative: isCurrent,
+      })
+      if (!page) return false
+      response = {
+        data: page.messages,
+        cursor: { previous: page.olderCursor, next: page.newerCursor },
+      } as SessionMessagesResponse
+      responseAscending = true
     } else {
       response = await client.message.list({
         sessionID: sessionId,
-        limit: 200,
+        limit: MESSAGE_WINDOW_PAGE_SIZE,
         ...(planned.cursor ? { cursor: planned.cursor } : { order: planned.order ?? "desc" }),
-      }, options?.signal ? { signal: options.signal } : undefined)
+      }, { signal })
     }
     // A staged undo leaves its tail in the native transcript until commit.
     // On opening/latest, seek the latest *visible* page rather than treating
     // a page consisting entirely of that hidden tail as an empty session.
-    if (!isCurrent()) return
+    if (!isCurrent()) return false
     if (!directWindow && (intent === "open" || intent === "latest") && !planned.cursor && session.revert?.messageID) {
       const boundary = session.revert.messageID
       const seen = new Set<string>()
       while (response.data.length > 0 && response.data.every((message) => message.id >= boundary)) {
-        const cursor = response.cursor?.next
+        // Saved-window refill normalizes to ascending order; raw native seek
+        // pages retain the descending order encoded in their older cursor.
+        const cursor = responseAscending ? response.cursor?.previous : response.cursor?.next
         if (!cursor) break
         if (seen.has(cursor) || seen.size >= MESSAGE_CURSOR_SEEK_LIMIT) {
           throw new Error(tGlobal("messageSection.loadError.detail"))
         }
         seen.add(cursor)
-        response = await client.message.list({ sessionID: sessionId, limit: 200, cursor },
-          options?.signal ? { signal: options.signal } : undefined)
-        if (!isCurrent()) return
+        response = await client.message.list({ sessionID: sessionId, limit: MESSAGE_WINDOW_PAGE_SIZE, cursor }, { signal })
+        responseAscending = false
+        if (!isCurrent()) return false
       }
     }
     const olderCursor = (responseAscending ? response.cursor?.previous : response.cursor?.next) ?? undefined
@@ -1638,13 +1678,13 @@ async function loadMessages(
     if (planned.cursor && responseCursor === planned.cursor) {
       throw new Error("Repeated message cursor")
     }
-    if (!isCurrent()) return
+    if (!isCurrent()) return false
 
     const forwardPage = intent === "oldest" || planned.forward
     const nextWindow = directWindow ?? (forwardPage
       ? newerCursor
-        ? { ...resolvedNext, olderCursor: undefined, newerCursors: [newerCursor] }
-        : emptyLatestWindow()
+        ? { ...resolvedNext, olderCursor, newerCursors: [newerCursor] }
+        : withOlderCursor(emptyLatestWindow(), olderCursor)
       : withOlderCursor(resolvedNext, olderCursor))
     const hasLatestRevisionConflict = () => nextWindow.kind === "latest"
       && getOpenCodeMessageRevision(instanceId, sessionId) !== liveMessageRevision
@@ -1655,7 +1695,7 @@ async function loadMessages(
         // history request says nothing about the messages already resident.
         // Keep their window identity (including live/latest authority) and
         // scroll anchor; only retire the cursor that reached the boundary.
-        commitMessageWindow(instanceId, sessionId, withOlderCursor(currentWindow, undefined), "open")
+        commitCurrentWindow(withOlderCursor(currentWindow, undefined), "open")
       } else if (hasLatestRevisionConflict() || (intent === "open" && planned.cursor)) {
         retryAfterRevisionConflict = true
       } else if (store.getSessionRevision(sessionId) !== messageRevision) {
@@ -1666,8 +1706,9 @@ async function loadMessages(
         // page. It still carries session metadata authority: late projections
         // must retain the boundary, and a cleared boundary must not linger.
         store.setSessionRevert(sessionId, sessions().get(instanceId)?.get(sessionId)?.revert ?? null)
-        commitMessageWindow(instanceId, sessionId, nextWindow, intent, options?.anchorMessageId)
+        commitCurrentWindow(nextWindow, intent)
         markSessionMessagesLoaded(instanceId, sessionId)
+        committed = true
       }
     } else {
       const seenMessageIds = new Set<string>()
@@ -1699,7 +1740,7 @@ async function loadMessages(
 
       if (!agentName && !providerID && !modelID) {
         const defaultModel = await getDefaultModel(instanceId, session.agent)
-        if (!isCurrent()) return
+        if (!isCurrent()) return false
         agentName = session.agent
         providerID = defaultModel.providerId
         modelID = defaultModel.modelId
@@ -1724,18 +1765,20 @@ async function loadMessages(
       const sessionForV2 = sessions().get(instanceId)?.get(sessionId) ?? {
         id: sessionId, title: session?.title, parentId: session?.parentId ?? null, revert: session?.revert,
       }
-      if (!isCurrent()) return
+      if (!isCurrent()) return false
       const expectedRevision = nextWindow.kind === "latest" ? messageRevision : undefined
       if (hasLatestRevisionConflict() || !seedSessionMessagesV2(instanceId, sessionForV2, messages, messagesInfo, expectedRevision, false)) {
         retryAfterRevisionConflict = true
       } else {
-        commitMessageWindow(instanceId, sessionId, nextWindow, intent, options?.anchorMessageId)
+        store.trimSessionMessages(sessionId, MESSAGE_WINDOW_PAGE_SIZE)
+        commitCurrentWindow(nextWindow, intent)
         markSessionMessagesLoaded(instanceId, sessionId)
         reconcilePendingPermissionsV2(instanceId, sessionId)
+        committed = true
       }
     }
   } catch (error) {
-    if (options?.signal?.aborted) return
+    if (signal.aborted || !isCurrentLoad()) return false
     if (error instanceof MissingHistoryAnchorError && intent === "open" && isCurrent()) {
       // A persisted window can outlive its anchor (deletion, compaction, undo).
       // Recover once through a fresh visible latest page; its successful commit
@@ -1758,6 +1801,7 @@ async function loadMessages(
         return next
       })
     }
+    finishMessageLoad(instanceId, sessionId, loadEpoch)
   }
 
   if (retryAfterRevisionConflict && sessions().get(instanceId)?.has(sessionId)) {
@@ -1767,8 +1811,8 @@ async function loadMessages(
       throw error
     }
     await new Promise((resolve) => setTimeout(resolve, LATEST_WINDOW_RETRY_DELAY_MS * (2 ** revisionRetry)))
-    options?.signal?.throwIfAborted()
-    if (!isCurrent()) return
+    signal.throwIfAborted()
+    if (!isCurrent()) return false
     return loadMessages(instanceId, sessionId, {
       force: true,
       intent: intent === "open" && planned.cursor ? "latest" : intent,
@@ -1779,8 +1823,9 @@ async function loadMessages(
     })
   }
 
-  if (!isCurrent()) return
+  if (!isCurrent()) return false
   updateSessionInfo(instanceId, sessionId)
+  return committed
 }
 
 function enqueueMessageWindowLoad(
@@ -1788,15 +1833,18 @@ function enqueueMessageWindowLoad(
   sessionId: string,
   intent: Exclude<MessageWindowIntent, "open">,
   signal?: AbortSignal,
-): Promise<void> {
+): Promise<boolean> {
   const key = `${messagePageKey(instanceId, sessionId)}\0${intent}`
   let pending = messagePageRequests.get(key)
   if (!pending) {
     const controller = new AbortController()
-    pending = { controller, consumers: new Set(), request: undefined as unknown as Promise<void> }
+    pending = { controller, consumers: new Set(), request: undefined as unknown as Promise<boolean> }
     const entry = pending
     entry.request = loadMessages(instanceId, sessionId, { force: true, intent, signal: controller.signal }).then(
-      () => { if (messagePageRequests.get(key) === entry) messagePageRequests.delete(key) },
+      (committed) => {
+        if (messagePageRequests.get(key) === entry) messagePageRequests.delete(key)
+        return committed
+      },
       (error) => {
         if (messagePageRequests.get(key) === entry) messagePageRequests.delete(key)
         throw error
@@ -1813,22 +1861,22 @@ function enqueueMessageWindowLoad(
       if (messagePageRequests.get(key) === pending) messagePageRequests.delete(key)
       pending.controller.abort()
     }
-    return Promise.resolve()
+    return Promise.resolve(false)
   }
 
   const entry = pending
-  return new Promise<void>((resolve, reject) => {
+  return new Promise<boolean>((resolve, reject) => {
     let finished = false
-    const finish = (error?: unknown) => {
+    const finish = (committed: boolean, error?: unknown) => {
       if (finished) return
       finished = true
       signal?.removeEventListener("abort", handleAbort)
       entry.consumers.delete(consumer)
-      if (error === undefined) resolve()
+      if (error === undefined) resolve(committed)
       else reject(error)
     }
     const handleAbort = () => {
-      finish()
+      finish(false)
       if (entry.consumers.size === 0) {
         if (messagePageRequests.get(key) === entry) messagePageRequests.delete(key)
         entry.controller.abort()
@@ -1836,36 +1884,36 @@ function enqueueMessageWindowLoad(
     }
     signal?.addEventListener("abort", handleAbort, { once: true })
     entry.request.then(
-      () => finish(),
+      (committed) => finish(committed),
       (error) => {
-        if (signal?.aborted) finish()
-        else finish(error)
+        if (signal?.aborted) finish(false)
+        else finish(false, error)
       },
     )
   })
 }
 
-function loadMoreMessages(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<void> {
+function loadMoreMessages(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<boolean> {
   return enqueueMessageWindowLoad(instanceId, sessionId, "older", signal)
 }
 
-function loadOlderMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<void> {
+function loadOlderMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<boolean> {
   return enqueueMessageWindowLoad(instanceId, sessionId, "older", signal)
 }
 
-function loadNewerMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<void> {
+function loadNewerMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<boolean> {
   return enqueueMessageWindowLoad(instanceId, sessionId, "newer", signal)
 }
 
-function loadLatestMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<void> {
+function loadLatestMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<boolean> {
   return enqueueMessageWindowLoad(instanceId, sessionId, "latest", signal)
 }
 
-function loadOldestMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<void> {
+function loadOldestMessageWindow(instanceId: string, sessionId: string, signal?: AbortSignal): Promise<boolean> {
   return enqueueMessageWindowLoad(instanceId, sessionId, "oldest", signal)
 }
 
-function loadMessageAnchor(instanceId: string, sessionId: string, messageId: string, signal?: AbortSignal): Promise<void> {
+function loadMessageAnchor(instanceId: string, sessionId: string, messageId: string, signal?: AbortSignal): Promise<boolean> {
   return loadMessages(instanceId, sessionId, { force: true, intent: "around", anchorMessageId: messageId, signal })
 }
 
diff --git a/packages/ui/src/stores/session-message-pages.ts b/packages/ui/src/stores/session-message-pages.ts
new file mode 100644
index 000000000..0ada6bd5b
--- /dev/null
+++ b/packages/ui/src/stores/session-message-pages.ts
@@ -0,0 +1,53 @@
+import type { SessionMessageInfo as SDKMessage } from "@opencode/client"
+import type { OpenCodeClient } from "./opencode-client"
+
+export interface MessageWindowPage {
+  messages: SDKMessage[]
+  olderCursor?: string
+  newerCursor?: string
+}
+
+const MAX_WINDOW_PAGES = 1_000
+
+async function listMessageWindow(
+  client: OpenCodeClient,
+  sessionId: string,
+  options: { limit: number; cursor?: string; forward?: boolean; signal?: AbortSignal; isAuthoritative?: () => boolean },
+): Promise<MessageWindowPage | null> {
+  const isAuthoritative = options.isAuthoritative ?? (() => true)
+  const messages: SDKMessage[] = []
+  const seenCursors = new Set(options.cursor ? [options.cursor] : [])
+  let cursor = options.cursor
+  let olderCursor: string | undefined
+  let newerCursor: string | undefined
+
+  for (let page = 0; page < MAX_WINDOW_PAGES && messages.length < options.limit; page += 1) {
+    options.signal?.throwIfAborted()
+    if (!isAuthoritative()) return null
+    const remaining = options.limit - messages.length
+    const response = await client.message.list(cursor
+      ? { sessionID: sessionId, limit: remaining, cursor }
+      : { sessionID: sessionId, limit: remaining, order: options.forward ? "asc" : "desc" }, { signal: options.signal })
+    if (!isAuthoritative()) return null
+    if (options.forward) {
+      if (page === 0) olderCursor = response.cursor?.previous ?? undefined
+      messages.push(...response.data.slice(0, remaining))
+      newerCursor = response.cursor?.next ?? undefined
+    } else {
+      if (page === 0) newerCursor = response.cursor?.previous ?? undefined
+      messages.unshift(...response.data.slice(0, remaining).reverse())
+      olderCursor = response.cursor?.next ?? undefined
+    }
+
+    const nextCursor = options.forward ? newerCursor : olderCursor
+    if (!nextCursor) return { messages, olderCursor, newerCursor }
+    if (seenCursors.has(nextCursor)) throw new Error(`Repeated message cursor for session ${sessionId}`)
+    seenCursors.add(nextCursor)
+    cursor = nextCursor
+  }
+
+  if (messages.length >= options.limit) return { messages, olderCursor, newerCursor }
+  throw new Error(`Message window pagination exceeded ${MAX_WINDOW_PAGES} pages for session ${sessionId}`)
+}
+
+export { listMessageWindow }
diff --git a/packages/ui/src/stores/session-request-authority.test.ts b/packages/ui/src/stores/session-request-authority.test.ts
index a6d1f8c7a..56d9608a6 100644
--- a/packages/ui/src/stores/session-request-authority.test.ts
+++ b/packages/ui/src/stores/session-request-authority.test.ts
@@ -7,11 +7,11 @@ import type { Session } from "../types/session.ts"
 import { addInstance, instances, refreshVolatileInstanceState, removeInstance, updateInstance } from "./instances.ts"
 import { messageStoreBus } from "./message-v2/bus.ts"
 import { fetchCommands, getCommands } from "./commands.ts"
-import { beginMessageHistoryTraversal, fetchAgents, fetchProviders, fetchSessions, forkSession, hasMoreMessages, hydrateRestoredSessionChain, invalidateMessageHistoryTraversal, isLatestMessageWindow, loadAllSessions, loadLatestMessageWindow, loadMessages, loadMoreMessages, loadMoreSessions, loadNewerMessageWindow, loadOldestMessageWindow, removeSessionRuntimeState, searchSessions } from "./session-api.ts"
+import { beginMessageHistoryTraversal, deleteSession, fetchAgents, fetchProviders, fetchSessions, forkSession, hasMoreMessages, hydrateRestoredSessionChain, invalidateMessageHistoryTraversal, isLatestMessageWindow, loadAllSessions, loadLatestMessageWindow, loadMessages, loadMoreMessages, loadMoreSessions, loadNewerMessageWindow, loadOldestMessageWindow, removeSessionRuntimeState, searchSessions } from "./session-api.ts"
 import { handleNativeSessionEvent, handleSessionUpdate } from "./session-events.ts"
 import { getInstanceMetadata, setInstanceMetadata } from "./instance-metadata.ts"
 import { loadInstanceMetadata } from "../lib/hooks/use-instance-metadata.ts"
-import { applyOpenCodeDataEvent, destroyOpenCodeData, getOpenCodeMessageRevision, projectOpenCodeMessages } from "./opencode-data.ts"
+import { applyOpenCodeDataEvent, destroyOpenCodeData, finishOpenCodeDataEvent, getOpenCodeMessageRevision, getOpenCodeMutationRevision, projectOpenCodeMessages } from "./opencode-data.ts"
 import {
   clearInstanceDeletedSessionAuthority,
   agents,
@@ -270,6 +270,95 @@ describe("session request authority", () => {
     } finally { cleanup() }
   })
 
+  it("reopens a saved latest snapshot past multiple undone pages in chronological order", async () => {
+    const instanceId = "revert-saved-latest-pages", sessionId = "session"
+    const { client, cleanup } = setup(instanceId)
+    const revert = { messageID: "msg_0200" }
+    setSessions(previous => new Map(previous).set(instanceId, new Map([[sessionId, { ...session(instanceId, sessionId), revert }]])))
+    const store = messageStoreBus.getOrCreate(instanceId)
+    store.setScrollSnapshot(sessionId, "message-stream", { scrollTop: 0, atBottom: true, windowIsLatest: true })
+    const requests: Array<string | undefined> = []
+    client.message = { list: async ({ cursor }: { cursor?: string }) => {
+      requests.push(cursor)
+      if (!cursor) return {
+        data: Array.from({ length: 200 }, (_, index) => apiMessage(`msg_${String(600 - index).padStart(4, "0")}`)),
+        cursor: { next: "hidden" },
+      }
+      if (cursor === "hidden") return {
+        data: [apiMessage("msg_0400"), apiMessage("msg_0300")],
+        cursor: { previous: "newest", next: "visible" },
+      }
+      if (cursor === "visible") return {
+        data: [apiMessage("msg_0200"), apiMessage("msg_0199"), apiMessage("msg_0198")],
+        cursor: { previous: "hidden", next: "older" },
+      }
+      if (cursor === "older") return { data: [apiMessage("msg_0197"), apiMessage("msg_0196")], cursor: {} }
+      throw new Error(`Unexpected cursor: ${cursor}`)
+    } }
+    try {
+      assert.equal(await loadMessages(instanceId, sessionId), true)
+      assert.deepEqual(requests, [undefined, "hidden", "visible"])
+      assert.deepEqual(store.getSessionMessageIds(sessionId), ["msg_0198", "msg_0199"])
+      assert.deepEqual(store.getSessionRevert(sessionId), revert)
+      assert.equal(store.getMessage("msg_0200"), undefined)
+      assert.equal(isLatestMessageWindow(instanceId, sessionId), true)
+      assert.equal(store.getMessageWindow(sessionId)?.olderCursor, "older")
+      assert.equal(store.getScrollSnapshot(sessionId, "message-stream")?.atBottom, true)
+      assert.equal(await loadMoreMessages(instanceId, sessionId), true)
+      assert.deepEqual(requests, [undefined, "hidden", "visible", "older"])
+      assert.deepEqual(store.getSessionMessageIds(sessionId), ["msg_0196", "msg_0197"])
+    } finally { cleanup() }
+  })
+
+  for (const outcome of ["failure", "abort"] as const) {
+    it(`preserves the prior window on saved latest undo-tail seek ${outcome}`, async () => {
+      const instanceId = `revert-saved-seek-${outcome}`, sessionId = "session"
+      const { client, cleanup } = setup(instanceId)
+      setSessions(previous => new Map(previous).set(instanceId, new Map([[sessionId, {
+        ...session(instanceId, sessionId), revert: { messageID: "msg_0200" },
+      }]])))
+      client.message = { list: async () => ({ data: [apiMessage("msg_0199"), apiMessage("msg_0198")], cursor: {} }) }
+      const controller = new AbortController()
+      const seek = deferred<any>()
+      const requests: Array<string | undefined> = []
+      try {
+        await loadMessages(instanceId, sessionId)
+        const store = messageStoreBus.getOrCreate(instanceId)
+        const window = store.getMessageWindow(sessionId)
+        const snapshot = store.getScrollSnapshot(sessionId, "message-stream")
+        client.message.list = async ({ cursor }: { cursor?: string }, options: { signal: AbortSignal }) => {
+          requests.push(cursor)
+          assert.equal(options.signal.aborted, false)
+          if (cursor) {
+            assert.equal(cursor, "visible")
+            if (outcome === "failure") throw new Error("undo-tail seek failed")
+            return seek.promise
+          }
+          return {
+            data: Array.from({ length: 200 }, (_, index) => apiMessage(`msg_${String(400 - index).padStart(4, "0")}`)),
+            cursor: { next: "visible" },
+          }
+        }
+        const request = loadMessages(instanceId, sessionId, { force: true, signal: controller.signal })
+        if (outcome === "failure") {
+          await assert.rejects(request, /undo-tail seek failed/)
+          assert.match(getSessionMessagesLoadError(instanceId, sessionId)!, /undo-tail seek failed/)
+        } else {
+          await new Promise<void>(resolve => setImmediate(resolve))
+          controller.abort()
+          seek.resolve({ data: [apiMessage("msg_0197")], cursor: {} })
+          assert.equal(await request, false)
+          assert.equal(getSessionMessagesLoadError(instanceId, sessionId), undefined)
+        }
+        assert.deepEqual(requests, [undefined, "visible"])
+        assert.deepEqual(store.getSessionMessageIds(sessionId), ["msg_0198", "msg_0199"])
+        assert.equal(store.getMessageWindow(sessionId), window)
+        assert.deepEqual(store.getScrollSnapshot(sessionId, "message-stream"), snapshot)
+        assert.equal(loading().loadingMessages.get(instanceId)?.has(sessionId), false)
+      } finally { controller.abort(); seek.resolve({ data: [], cursor: {} }); cleanup() }
+    })
+  }
+
   it("retains undo authority when seeking past the entire staged transcript reaches an empty page", async () => {
     const instanceId = "revert-entire-transcript", sessionId = "session"
     const { client, cleanup } = setup(instanceId)
@@ -632,13 +721,15 @@ describe("session request authority", () => {
     try {
       await loadMessages(instanceId, sessionId)
       const store = messageStoreBus.getOrCreate(instanceId)
-      const oldestInfo = store.getMessageInfo("message-1")
-      assert.equal(store.getSessionMessageIds(sessionId).length, 400)
+      const retainedInfo = store.getMessageInfo("message-201")
+      assert.deepEqual(store.getSessionMessageIds(sessionId), Array.from({ length: 200 }, (_, index) => `message-${index + 201}`))
+      assert.equal(store.getMessageInfo("message-1"), undefined)
+      assert.equal(store.getSessionUsage(sessionId)?.totalCost, 200)
       refresh = true
       await loadMessages(instanceId, sessionId, { force: true })
       assert.deepEqual(store.getSessionMessageIds(sessionId), Array.from({ length: 200 }, (_, index) => `message-${index + 201}`))
       assert.equal(store.getMessageInfo("message-1"), undefined)
-      assert.notStrictEqual(store.getMessageInfo("message-201"), oldestInfo)
+      assert.notStrictEqual(store.getMessageInfo("message-201"), retainedInfo)
       assert.equal(store.getSessionUsage(sessionId)?.totalCost, 200)
       assert.equal(hasMoreMessages(instanceId, sessionId), true)
 
@@ -655,6 +746,58 @@ describe("session request authority", () => {
     }
   })
 
+  it("clears deletion loading when reconnect supersedes the request", async () => {
+    const instanceId = "delete-reconnect", sessionId = "session"
+    const { client, cleanup } = setup(instanceId)
+    const response = deferred<void>()
+    ;(client.session as any).remove = () => response.promise
+    setSessions((previous) => new Map(previous).set(instanceId, new Map([[sessionId, session(instanceId, sessionId)]])))
+
+    try {
+      const request = deleteSession(instanceId, sessionId)
+      updateInstance(instanceId, { client: { session: { active: async () => ({}) } } as any })
+      response.resolve()
+
+      await assert.rejects(request, /superseded by reconnect/)
+      assert.equal(loading().deletingSession.get(instanceId)?.has(sessionId) ?? false, false)
+    } finally {
+      cleanup()
+    }
+  })
+
+  it("reloads an evicted transcript through a complete bounded cursor window", async () => {
+    const instanceId = "evicted-complete-window", sessionId = "session"
+    const { client, cleanup } = setup(instanceId)
+    let reloading = false
+    const requests: any[] = []
+    ;(client as any).message = { list: async (input: any) => {
+      requests.push(input)
+      if (!reloading) return { data: [apiMessage("initial")], cursor: {} }
+      const start = input.cursor ? 200 : 300
+      return {
+        data: Array.from({ length: 100 }, (_, index) => apiMessage(`message-${start - index}`)),
+        cursor: input.cursor ? {} : { next: "older-half" },
+      }
+    } }
+    setSessions((previous) => new Map(previous).set(instanceId, new Map([[sessionId, session(instanceId, sessionId)]])))
+
+    try {
+      await loadMessages(instanceId, sessionId)
+      const store = messageStoreBus.getOrCreate(instanceId)
+      store.evictSessionTranscript(sessionId)
+      reloading = true
+
+      await loadMessages(instanceId, sessionId)
+
+      assert.deepEqual(store.getSessionMessageIds(sessionId), Array.from({ length: 200 }, (_, index) => `message-${index + 101}`))
+      assert.deepEqual(requests.slice(-2).map((request) => request.cursor), [undefined, "older-half"])
+      assert.deepEqual(requests.slice(-2).map((request) => request.limit), [200, 100])
+      assert.equal(hasMoreMessages(instanceId, sessionId), false)
+    } finally {
+      cleanup()
+    }
+  })
+
   it("hydrates normally after a non-authoritative remove reuses an instance and session id", async () => {
     const instanceId = "reused-loaded-session", sessionId = "session"
     const old = setup(instanceId)
@@ -733,7 +876,7 @@ describe("session request authority", () => {
       failOlder = false
       await loadMoreMessages(instanceId, sessionId)
       assert.deepEqual(messageStoreBus.getOrCreate(instanceId).getSessionMessageIds(sessionId), ["old-1", "old-2"])
-      await loadNewerMessageWindow(instanceId, sessionId)
+      assert.equal(await loadNewerMessageWindow(instanceId, sessionId), true)
       assert.deepEqual(messageStoreBus.getOrCreate(instanceId).getSessionMessageIds(sessionId), ["new-1", "new-2"])
       await loadLatestMessageWindow(instanceId, sessionId)
       assert.deepEqual(messageStoreBus.getOrCreate(instanceId).getSessionMessageIds(sessionId), ["new-1", "new-2"])
@@ -1034,9 +1177,12 @@ describe("session request authority", () => {
     setSessions((previous) => new Map(previous).set(instanceId, new Map([[sessionId, session(instanceId, sessionId)]])))
     try {
       await loadMessages(instanceId, sessionId)
+      assert.equal(messagesLoaded().get(instanceId)?.has(sessionId), true)
       const endTraversal = beginMessageHistoryTraversal(instanceId, sessionId)
+      assert.equal(messagesLoaded().get(instanceId)?.has(sessionId), true)
       const request = loadOldestMessageWindow(instanceId, sessionId)
       endTraversal()
+      assert.equal(messagesLoaded().get(instanceId)?.has(sessionId), true)
       oldest.resolve({ data: [apiMessage("stale-oldest")], cursor: { next: "newer" } })
       await request
 
@@ -1191,6 +1337,46 @@ describe("session request authority", () => {
     }
   })
 
+  for (const mutation of ["cancel", "revert"] as const) {
+    it(`rejects pre-${mutation} history after idle disposes the reducer`, async () => {
+      const instanceId = `stale-${mutation}-idle-page`, sessionId = "session"
+      const { client, cleanup } = setup(instanceId)
+      const stale = deferred<any>()
+      let oldestCalls = 0
+      client.message = { list: (input: any) => {
+        if (input.order !== "asc") return Promise.resolve({ data: [apiMessage("latest")], cursor: { next: "older" } })
+        oldestCalls += 1
+        return oldestCalls === 1 ? stale.promise : Promise.resolve({ data: [apiMessage("survivor")], cursor: { next: "newer" } })
+      } }
+      setSessions(previous => new Map(previous).set(instanceId, new Map([[sessionId, session(instanceId, sessionId)]])))
+      try {
+        await loadMessages(instanceId, sessionId)
+        const request = loadOldestMessageWindow(instanceId, sessionId)
+        assert.equal(oldestCalls, 1)
+        const reducer = applyOpenCodeDataEvent(instanceId, "/work", mutation === "cancel"
+          ? { id: "mutation", type: "session.inbox.cancelled", created: 2, data: { sessionID: sessionId, inboxID: "deleted" } } as any
+          : { id: "mutation", type: "session.revert.committed", created: 2, data: { sessionID: sessionId, to: "deleted" } } as any)
+        const revision = getOpenCodeMutationRevision(instanceId, sessionId)
+        const idle = { id: "idle", type: "session.idle", created: 3, data: { sessionID: sessionId } } as any
+        const data = applyOpenCodeDataEvent(instanceId, "/work", idle)
+        projectOpenCodeMessages(instanceId, sessionId, data)
+        finishOpenCodeDataEvent(instanceId, idle)
+        assert.equal(getOpenCodeMutationRevision(instanceId, sessionId), revision)
+        const next = applyOpenCodeDataEvent(instanceId, "/work", {
+          id: "next", type: "permission.replied", created: 4, data: { sessionID: sessionId, requestID: "missing" },
+        } as any)
+        assert.notEqual(next, reducer, "the request fence survives actual reducer replacement")
+        stale.resolve({ data: [apiMessage("deleted")], cursor: { next: "newer" } })
+        assert.equal(await request, false)
+        const store = messageStoreBus.getOrCreate(instanceId)
+        assert.deepEqual(store.getSessionMessageIds(sessionId), ["latest"])
+        assert.equal(store.getMessage("deleted"), undefined)
+        assert.equal(await loadOldestMessageWindow(instanceId, sessionId), true)
+        assert.deepEqual(store.getSessionMessageIds(sessionId), ["survivor"])
+      } finally { stale.resolve({ data: [], cursor: {} }); destroyOpenCodeData(instanceId); cleanup() }
+    })
+  }
+
   it("rejects a stale page after more than 200 cancellations without tombstones", async () => {
     const instanceId = "many-cancellation-fence", sessionId = "session"
     const { client, cleanup } = setup(instanceId)
@@ -1248,10 +1434,10 @@ describe("session request authority", () => {
         data: { sessionID: sessionId, to: "removed" },
       } as any)
       staleNewer.resolve({ data: [apiMessage("removed")], cursor: {} })
-      await request
+      assert.equal(await request, false)
       assert.deepEqual(messageStoreBus.getOrCreate(instanceId).getSessionMessageIds(sessionId), ["old"])
 
-      await loadNewerMessageWindow(instanceId, sessionId)
+      assert.equal(await loadNewerMessageWindow(instanceId, sessionId), true)
       assert.deepEqual(messageStoreBus.getOrCreate(instanceId).getSessionMessageIds(sessionId), ["survivor"])
       assert.equal(isLatestMessageWindow(instanceId, sessionId), true)
     } finally {
@@ -1299,6 +1485,37 @@ describe("session request authority", () => {
     }
   })
 
+  it("restores an ascending history cursor without reversing its pages", async () => {
+    const instanceId = "ascending-window-restore", sessionId = "session"
+    const { client, cleanup } = setup(instanceId)
+    const requests: any[] = []
+    ;(client as any).message = { list: async (input: any) => {
+      requests.push(input)
+      if (input.order === "asc") return { data: [apiMessage("first")], cursor: { next: "middle" } }
+      if (input.cursor === "middle") return { data: [apiMessage("middle")], cursor: { next: "recent" } }
+      if (input.cursor === "recent") return { data: [apiMessage("recent")], cursor: { previous: "middle" } }
+      return { data: [apiMessage("latest")], cursor: { next: "older" } }
+    } }
+    setSessions((previous) => new Map(previous).set(instanceId, new Map([[sessionId, session(instanceId, sessionId)]])))
+
+    try {
+      await loadMessages(instanceId, sessionId)
+      await loadOldestMessageWindow(instanceId, sessionId)
+      await loadNewerMessageWindow(instanceId, sessionId)
+      const store = messageStoreBus.getOrCreate(instanceId)
+      store.evictSessionTranscript(sessionId)
+
+      await loadMessages(instanceId, sessionId)
+
+      assert.deepEqual(requests.slice(-2).map((request) => request.cursor), ["middle", "recent"])
+      assert.deepEqual(store.getSessionMessageIds(sessionId), ["middle", "recent"])
+      assert.equal(store.getMessageWindow(sessionId)?.kind, "latest")
+      assert.equal(store.getMessageWindow(sessionId)?.olderCursor, undefined)
+    } finally {
+      cleanup()
+    }
+  })
+
   it("reaches every newer page after backward cursor memory is capped", async () => {
     const instanceId = "bounded-complete-newer-path", sessionId = "session"
     const { client, cleanup } = setup(instanceId)
@@ -1604,7 +1821,7 @@ describe("session request authority", () => {
         return { data: [{ ...apiSession("legacy-child", "root"), projectID: "global" }], cursor: {} }
       }
       if (input.parentID === null) return {
-        data: [apiSession("root")],
+        data: [{ ...apiSession("root"), metadata: { owner: "native" } }],
         cursor: { next: "root-page-2" },
       }
       if (input.project === "project") return {
@@ -1625,6 +1842,7 @@ describe("session request authority", () => {
     try {
       await fetchSessions(instanceId)
       assert.equal(sessions().get(instanceId)?.has("root"), true)
+      assert.deepEqual(sessions().get(instanceId)?.get("root")?.metadata, { owner: "native" })
       assert.equal(sessions().get(instanceId)?.has("child"), true)
       assert.equal(sessions().get(instanceId)?.has("grandchild"), true)
       assert.equal(sessions().get(instanceId)?.has("worktree-root"), true)
diff --git a/packages/ui/src/stores/session-state.ts b/packages/ui/src/stores/session-state.ts
index 371a6eda1..e4d1b18cc 100644
--- a/packages/ui/src/stores/session-state.ts
+++ b/packages/ui/src/stores/session-state.ts
@@ -81,6 +81,7 @@ const [messagesLoaded, setMessagesLoaded] = createSignal<Map<string, Set<string>
 const [messageLoadErrors, setMessageLoadErrors] = createSignal<Map<string, Map<string, string>>>(new Map())
 const [sessionListErrors, setSessionListErrors] = createSignal<Map<string, string>>(new Map())
 const messageLoadEpochs = new Map<string, number>()
+const messageLoadControllers = new Map<string, AbortController>()
 let nextMessageLoadEpoch = 0
 const [sessionInfoByInstance, setSessionInfoByInstance] = createSignal<Map<string, Map<string, SessionInfo>>>(new Map())
 const [threadTotalsByInstance, setThreadTotalsByInstance] = createSignal<Map<string, Map<string, ThreadTotals>>>(new Map())
@@ -338,8 +339,10 @@ function clearLoadedFlag(instanceId: string, sessionId: string) {
 
 function advanceMessageLoadEpoch(instanceId: string, sessionId: string): number {
   const key = getDraftKey(instanceId, sessionId)
+  messageLoadControllers.get(key)?.abort()
   const epoch = ++nextMessageLoadEpoch
   messageLoadEpochs.set(key, epoch)
+  messageLoadControllers.set(key, new AbortController())
   return epoch
 }
 
@@ -347,6 +350,15 @@ function isCurrentMessageLoad(instanceId: string, sessionId: string, epoch: numb
   return messageLoadEpochs.get(getDraftKey(instanceId, sessionId)) === epoch
 }
 
+function getMessageLoadSignal(instanceId: string, sessionId: string): AbortSignal | undefined {
+  return messageLoadControllers.get(getDraftKey(instanceId, sessionId))?.signal
+}
+
+function finishMessageLoad(instanceId: string, sessionId: string, epoch: number): void {
+  if (!isCurrentMessageLoad(instanceId, sessionId, epoch)) return
+  messageLoadControllers.delete(getDraftKey(instanceId, sessionId))
+}
+
 function clearMessageLoadingFlag(instanceId: string, sessionId: string): void {
   setLoading((prev) => {
     const existing = prev.loadingMessages.get(instanceId)
@@ -360,16 +372,28 @@ function clearMessageLoadingFlag(instanceId: string, sessionId: string): void {
   })
 }
 
+function supersedeSessionMessageLoad(instanceId: string, sessionId: string): void {
+  const key = getDraftKey(instanceId, sessionId)
+  messageLoadControllers.get(key)?.abort()
+  messageLoadControllers.delete(key)
+  messageLoadEpochs.set(key, ++nextMessageLoadEpoch)
+  clearMessageLoadingFlag(instanceId, sessionId)
+}
+
 function invalidateSessionMessageLoad(instanceId: string, sessionId: string): void {
-  advanceMessageLoadEpoch(instanceId, sessionId)
+  supersedeSessionMessageLoad(instanceId, sessionId)
   clearLoadedFlag(instanceId, sessionId)
-  clearMessageLoadingFlag(instanceId, sessionId)
 }
 
 messageStoreBus.onSessionCleared(invalidateSessionMessageLoad)
 
 function clearInstanceMessageLoads(instanceId: string): void {
   const prefix = `${instanceId}:`
+  for (const [key, controller] of messageLoadControllers) {
+    if (!key.startsWith(prefix)) continue
+    controller.abort()
+    messageLoadControllers.delete(key)
+  }
   for (const key of messageLoadEpochs.keys()) {
     if (key.startsWith(prefix)) messageLoadEpochs.delete(key)
   }
@@ -1256,6 +1280,9 @@ export {
   setSessionListError,
   advanceMessageLoadEpoch,
   isCurrentMessageLoad,
+  getMessageLoadSignal,
+  finishMessageLoad,
+  supersedeSessionMessageLoad,
   invalidateSessionMessageLoad,
   clearInstanceMessageLoads,
   setSessionMessagesLoadError,
diff --git a/packages/ui/src/stores/session-transcript-memory.ts b/packages/ui/src/stores/session-transcript-memory.ts
new file mode 100644
index 000000000..4876ce40b
--- /dev/null
+++ b/packages/ui/src/stores/session-transcript-memory.ts
@@ -0,0 +1,94 @@
+import { createEffect, createRoot } from "solid-js"
+import { getLogger } from "../lib/logger"
+import { onCacheSessionChanged } from "../lib/global-cache"
+import { SessionTranscriptMeasurementQueue } from "../lib/session-transcript-measurement"
+import { isSessionTranscriptProtected, SessionTranscriptLru } from "../lib/session-transcript-lru"
+import { messageStoreBus } from "./message-v2/bus"
+import { loading, sessions } from "./session-state"
+import { destroyOpenCodeData } from "./opencode-data"
+
+// Inactive transcript budget. Protected active/live 200-message windows retain authoritative content and may exceed it.
+export const SESSION_TRANSCRIPT_BYTE_BUDGET = 64 * 1024 * 1024
+
+const log = getLogger("session")
+const visible = new Map<string, number>()
+const key = (instanceId: string, sessionId: string) => `${instanceId}\u0000${sessionId}`
+
+const coordinator = new SessionTranscriptLru({
+  byteBudget: SESSION_TRANSCRIPT_BYTE_BUDGET,
+  isProtected: (instanceId, sessionId) => {
+    const session = sessions().get(instanceId)?.get(sessionId)
+    return isSessionTranscriptProtected({
+      visible: visible.has(key(instanceId, sessionId)),
+      loading: loading().loadingMessages.get(instanceId)?.has(sessionId),
+      status: session?.status,
+      generationPending: session?.generationAdmissionToken !== undefined || session?.generationRecovery === "pending",
+      permissionBlocked: session?.pendingPermission,
+      questionBlocked: session?.pendingForm,
+      liveMessages: messageStoreBus.getInstance(instanceId)?.hasLiveSessionMessages(sessionId),
+    })
+  },
+  evict: (instanceId, sessionId) => {
+    log.info("Evicting inactive session transcript", { instanceId, sessionId })
+    destroyOpenCodeData(instanceId, sessionId)
+    messageStoreBus.getInstance(instanceId)?.evictSessionTranscript(sessionId)
+  },
+})
+
+const measurements = new SessionTranscriptMeasurementQueue({
+  delayMs: 100,
+  measure: async (instanceId, sessionId, signal) => {
+    return messageStoreBus.getInstance(instanceId)?.estimateSessionRetainedBytes(sessionId, signal) ?? 0
+  },
+  account: (instanceId, sessionId, bytes) => coordinator.account(instanceId, sessionId, bytes),
+  onError: (instanceId, sessionId, error) => {
+    log.warn("Failed to measure session transcript", { instanceId, sessionId, error })
+  },
+})
+
+export function accountSessionTranscript(instanceId: string, sessionId: string): void {
+  measurements.schedule(instanceId, sessionId)
+}
+
+export function touchSessionTranscript(instanceId: string, sessionId: string): void {
+  coordinator.touch(instanceId, sessionId)
+  measurements.schedule(instanceId, sessionId)
+}
+
+export function setSessionTranscriptVisible(instanceId: string, sessionId: string, value: boolean): void {
+  const entryKey = key(instanceId, sessionId)
+  if (value) {
+    visible.set(entryKey, (visible.get(entryKey) ?? 0) + 1)
+    touchSessionTranscript(instanceId, sessionId)
+  } else {
+    const count = (visible.get(entryKey) ?? 0) - 1
+    if (count > 0) visible.set(entryKey, count)
+    else visible.delete(entryKey)
+    measurements.schedule(instanceId, sessionId)
+  }
+  coordinator.enforce()
+}
+
+export function reconcileSessionTranscriptBudget(): void {
+  coordinator.enforce()
+}
+
+createRoot(() => createEffect(() => {
+  loading()
+  sessions()
+  queueMicrotask(() => coordinator.enforce())
+}))
+
+messageStoreBus.onSessionChanged(accountSessionTranscript)
+onCacheSessionChanged(accountSessionTranscript)
+messageStoreBus.onSessionCleared((instanceId, sessionId) => {
+  measurements.cancel(instanceId, sessionId)
+  coordinator.forget(instanceId, sessionId)
+})
+messageStoreBus.onInstanceDestroyed((instanceId) => {
+  coordinator.forgetInstance(instanceId)
+  for (const entryKey of visible.keys()) {
+    if (entryKey.startsWith(`${instanceId}\u0000`)) visible.delete(entryKey)
+  }
+  measurements.cancelInstance(instanceId)
+})
diff --git a/packages/ui/tests/browser/directory-browser.test.ts b/packages/ui/tests/browser/directory-browser.test.ts
index e96767b66..0f1f393a0 100644
--- a/packages/ui/tests/browser/directory-browser.test.ts
+++ b/packages/ui/tests/browser/directory-browser.test.ts
@@ -91,7 +91,7 @@ after(async () => { await browser?.close(); await server?.close() })
 
 for (const mode of ["directories", "files"] as const) {
   test(`parent is offered once in the address, not repeated in the folder list (${mode})`, async () => {
-    const page = await browser.newPage()
+    const page = await browser.newPage({ locale: "fr-FR" })
     const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home" }, `initialPath=/ws/start&mode=${mode}`)
     try {
       assert.equal(await page.getByRole("button", { name: "Up one level" }).count(), 0)
@@ -105,7 +105,7 @@ for (const mode of ["directories", "files"] as const) {
 }
 
 test("restricted browser offers parent and loaded children without the server-root shortcut", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home" }, "initialPath=/ws/start&mode=directories")
   try {
     await field(page).focus()
@@ -123,7 +123,7 @@ test("restricted browser offers parent and loaded children without the server-ro
 })
 
 test("typing filters children; arrow and Enter navigate, while Enter with no selection submits the typed path", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home" }, "initialPath=/ws/start&mode=directories")
   try {
     await field(page).fill("/ws/start/pic")
@@ -143,7 +143,7 @@ test("typing filters children; arrow and Enter navigate, while Enter with no sel
 })
 
 test("Escape restores an unsubmitted edit without dismissing the dialog", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home" }, "initialPath=/ws/start&mode=directories")
   try {
     await field(page).fill("/ws/unsubmitted")
@@ -155,7 +155,7 @@ test("Escape restores an unsubmitted edit without dismissing the dialog", async
 })
 
 test("unrestricted relative start is offered by canonical home path after navigating away", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "unrestricted", rootPath: "/srv", homePath: "/home/user" }, "initialPath=projects&mode=files")
   try {
     await page.waitForFunction(() => document.querySelector<HTMLInputElement>(".directory-browser-current-path")?.value === "/home/user/projects")
@@ -171,7 +171,7 @@ test("unrestricted relative start is offered by canonical home path after naviga
 })
 
 test("failed start falls back without offering a broken return", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home", rejectedPath: "/missing" }, "initialPath=/missing")
   try {
     await page.waitForFunction(() => document.querySelector<HTMLInputElement>(".directory-browser-current-path")?.value === "/ws")
@@ -181,7 +181,7 @@ test("failed start falls back without offering a broken return", async () => {
 })
 
 test("reopening clears the previous start destination", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page, { scope: "restricted", rootPath: "/ws", homePath: "/home" }, "initialPath=/ws/start")
   try {
     await page.evaluate(() => (window as any).directoryBrowserFixture.close())
@@ -194,7 +194,7 @@ test("reopening clears the previous start destination", async () => {
 })
 
 test("a navigation finishing after close and reopen cannot replace the new location", async () => {
-  const page = await browser.newPage()
+  const page = await browser.newPage({ locale: "fr-FR" })
   const errors = await openFixture(page,
     { scope: "restricted", rootPath: "/ws", homePath: "/home", delayedPath: "/ws/start/projects" },
     "initialPath=/ws/start")
@@ -216,7 +216,7 @@ test("a navigation finishing after close and reopen cannot replace the new locat
 for (const mode of ["directories", "files"] as const) {
   for (const width of [600, 360]) {
   test(`address dropdown stays inside the dialog and Open occupies its own row at ${width}px (${mode})`, async () => {
-    const page = await browser.newPage({ viewport: { width, height: 900 } })
+    const page = await browser.newPage({ viewport: { width, height: 900 }, locale: "fr-FR" })
     const errors = await openFixture(page, { scope: "unrestricted", rootPath: "/srv", homePath: "/home" }, `initialPath=/srv/start&mode=${mode}`)
     try {
       await field(page).focus()
diff --git a/packages/ui/tests/browser/fixtures/full-source-copy.tsx b/packages/ui/tests/browser/fixtures/full-source-copy.tsx
new file mode 100644
index 000000000..c2568899c
--- /dev/null
+++ b/packages/ui/tests/browser/fixtures/full-source-copy.tsx
@@ -0,0 +1,68 @@
+import { render } from "solid-js/web"
+import MessageSection from "../../../src/components/message-section"
+import { ConfigProvider } from "../../../src/stores/preferences"
+import { I18nProvider } from "../../../src/lib/i18n"
+import { ThemeProvider } from "../../../src/lib/theme"
+import { applyUiSettings } from "./ui-settings"
+import { sdkManager } from "../../../src/lib/sdk-manager"
+import { addInstance } from "../../../src/stores/instances"
+import { setSessions, setActiveSession } from "../../../src/stores/session-state"
+import { sseManager } from "../../../src/lib/sse-manager"
+import { loadMessages } from "../../../src/stores/session-api"
+import "../../../src/index.css"
+
+const scenario = new URLSearchParams(location.search).get("scenario")
+const instanceId = "full-source-instance", sessionId = "full-source-session", messageId = "full-source-message"
+const filePath = "/fixture/example.ts"
+const diagnostics = { [filePath]: Array.from({ length: scenario === "diagnostics-long" ? 1 : 137 }, (_, index) => ({
+  message: scenario === "diagnostics-long"
+    ? `Long diagnostic: ${"完整 diagnostic text ".repeat(250)}END-DIAGNOSTIC`
+    : `Diagnostic ${String(index).padStart(3, "0")} 完整`,
+  severity: 1, range: { start: { line: index, character: 2 } },
+})) }
+const todos = Array.from({ length: 237 }, (_, index) => ({
+  id: `todo-${index}`, content: `Task ${String(index).padStart(3, "0")} 完整`, status: "pending", priority: "medium",
+}))
+const error = `Error start: ${"Original error 完整\n".repeat(900)}END-ERROR`
+const textParts = Array.from({ length: 237 }, (_, index) => ({
+  type: "text", text: `Paragraph ${String(index).padStart(3, "0")} 完整.\n\n`,
+}))
+const input = { filePath, payload: `INPUT-START ${"Untruncated input 完整 ".repeat(1200)} INPUT-END`, nested: { retained: true } }
+const output = "Distinct output: this is not the tool input"
+const name = scenario === "todo" ? "todowrite" : scenario === "error" || scenario === "input" ? "read" : "edit"
+const tool = {
+  id: "full-source-tool", type: "tool", name, time: { created: 1, completed: 2 },
+  state: scenario === "error"
+    ? { status: "error", input: { filePath }, error: { type: "unknown", message: error } }
+    : { status: "completed", input: scenario === "input" ? input : { filePath },
+        metadata: scenario === "todo" ? { todos } : scenario === "input" ? {} : { diagnostics },
+        content: [{ type: "text", text: scenario === "input" ? output : "Tool completed" }] },
+}
+// Native API records enter through the real load/normalize/store/display path.
+const message = { id: messageId, type: "assistant", agent: "build", model: { providerID: "fixture", id: "fixture" },
+  time: { created: 1, completed: 2 }, content: scenario === "parts" ? textParts : [tool] }
+const requests: string[] = []
+const client: any = {
+  session: { active: async () => ({}), inbox: { list: async () => ({ data: [] }) },
+    get: async () => ({ id: sessionId, location: { directory: "/fixture" }, time: { created: 1, updated: 2 } }) },
+  message: { list: async () => { requests.push(sessionId); return { data: [message], cursor: {} } } },
+}
+;(sdkManager as any).clients.set(`${instanceId}:/workspaces/${instanceId}/instance`, client)
+sseManager.getStatuses = () => new Map([[instanceId, "connected"]])
+addInstance({ id: instanceId, folder: "/fixture", port: 0, pid: 0, proxyPath: "", status: "ready", client })
+setSessions(previous => new Map(previous).set(instanceId, new Map([[sessionId, {
+  id: sessionId, instanceId, parentId: null, title: "Full source copy", location: { directory: "/fixture" },
+  status: "idle", agent: "build", model: { providerId: "fixture", modelId: "fixture" }, time: { created: 1, updated: 2 },
+} as any]])))
+setActiveSession(instanceId, sessionId)
+await applyUiSettings({ showMessageTimeline: false, toolInputsVisibility: scenario === "input" ? "expanded" : "hidden", toolOutputExpansion: "expanded",
+  diagnosticsExpansion: "collapsed",
+  toolCallExpansionDefaults: { preset: "custom", thinking: "collapsed", tools: { edit: "expanded", read: "expanded", other: "expanded" } } })
+await loadMessages(instanceId, sessionId, { force: true })
+render(() => <ConfigProvider><I18nProvider><ThemeProvider>
+  <main style={{ display: "flex", height: "800px", width: "1000px" }}>
+    <MessageSection instanceId={instanceId} sessionId={sessionId} isActive={true} />
+  </main>
+</ThemeProvider></I18nProvider></ConfigProvider>, document.getElementById("root")!)
+// Expected payloads are the original inputs, never bounded renderer projections.
+;(window as any).fixture = { diagnostics, todos, error, textParts, input, output, sessionId, messageId, requests }
diff --git a/packages/ui/tests/browser/fixtures/permission-fallback-diff.tsx b/packages/ui/tests/browser/fixtures/permission-fallback-diff.tsx
new file mode 100644
index 000000000..d4b4967fb
--- /dev/null
+++ b/packages/ui/tests/browser/fixtures/permission-fallback-diff.tsx
@@ -0,0 +1,38 @@
+import { createSignal } from "solid-js"
+import { render } from "solid-js/web"
+import PermissionApprovalModal from "../../../src/components/permission-approval-modal"
+import { ConfigProvider } from "../../../src/stores/preferences"
+import { I18nProvider } from "../../../src/lib/i18n"
+import { serverApi } from "../../../src/lib/api-client"
+import { sdkManager } from "../../../src/lib/sdk-manager"
+import { addInstance, addPermissionToQueue, removePermissionFromQueue } from "../../../src/stores/instances"
+import type { PermissionRequest } from "../../../src/types/permission"
+import "../../../src/index.css"
+
+const instanceId = "permission-fallback"
+const diff = "--- a/a.ts\n+++ b/a.ts\n@@ -1 +1 @@\n-old\n+" + "first\n".repeat(1_700) + "middle\n".repeat(1_700) + "END-OF-DIFF\n"
+let current: PermissionRequest = { id: "request", sessionID: "session", action: "edit", resources: ["a.ts"], metadata: { diff, path: "a.ts" } }
+const replies: unknown[] = []
+const client: any = { permission: { reply: async (reply: unknown) => { replies.push(reply) } } }
+;(sdkManager as any).clients.set(`${instanceId}:/workspaces/${instanceId}/instance`, client)
+serverApi.fetchConfigOwner = async () => ({ settings: { locale: "en" } }) as any
+serverApi.fetchStateOwner = async () => ({}) as any
+addInstance({ id: instanceId, folder: "/repo", port: 0, pid: 0, proxyPath: `/workspaces/${instanceId}/instance`, status: "ready", client })
+addPermissionToQueue(instanceId, current)
+const [open, setOpen] = createSignal(true)
+render(() => <ConfigProvider><I18nProvider>
+  <PermissionApprovalModal instanceId={instanceId} isOpen={open()} onClose={() => setOpen(false)} />
+</I18nProvider></ConfigProvider>, document.getElementById("root")!)
+;(window as any).fixture = {
+  diff,
+  replies,
+  refresh: () => addPermissionToQueue(instanceId, { ...current, metadata: { ...current.metadata, refreshed: true } }),
+  changeDiff: () => { current = { ...current, metadata: { ...current.metadata, diff: diff + "CHANGED\n" } }; addPermissionToQueue(instanceId, current) },
+  nextRequest: () => {
+    removePermissionFromQueue(instanceId, current.id)
+    current = { ...current, id: "next-request" }
+    addPermissionToQueue(instanceId, current)
+    setOpen(true)
+  },
+  reopen: () => setOpen(true),
+}
diff --git a/packages/ui/tests/browser/fixtures/session.tsx b/packages/ui/tests/browser/fixtures/session.tsx
index 2b1eab5ef..9995e37fd 100644
--- a/packages/ui/tests/browser/fixtures/session.tsx
+++ b/packages/ui/tests/browser/fixtures/session.tsx
@@ -91,6 +91,11 @@ render(() => <ConfigProvider><I18nProvider><ThemeProvider>
     emit("session.text.started", { assistantMessageID: assistantId })
   },
   delta: (delta: string) => emit("session.text.delta", { assistantMessageID: assistantId, ordinal: 0, delta }),
+  appendTextPart: (text: string) => {
+    emit("session.text.started", { assistantMessageID: assistantId })
+    emit("session.text.delta", { assistantMessageID: assistantId, ordinal: 1, delta: text })
+    emit("session.text.ended", { assistantMessageID: assistantId, ordinal: 1, text })
+  },
   end: (text: string) => {
     nativeMessages.push({ id: assistantId, type: "assistant", agent: "build", model, time: { created: time, completed: time }, content: [{ type: "text", text }] })
     emit("session.text.ended", { assistantMessageID: assistantId, ordinal: 0, text })
diff --git a/packages/ui/tests/browser/fixtures/system-messages.tsx b/packages/ui/tests/browser/fixtures/system-messages.tsx
index 0e8585942..16cb37aee 100644
--- a/packages/ui/tests/browser/fixtures/system-messages.tsx
+++ b/packages/ui/tests/browser/fixtures/system-messages.tsx
@@ -43,6 +43,19 @@ serverApi.patchConfigOwner = async (_owner, patch: any) => {
   return config
 }
 serverApi.fetchStateOwner = async () => ({} as any)
+serverApi.querySessionHistory = async (_instanceId, input) => {
+  const query = input.query.trim().toLocaleLowerCase()
+  const hits = query ? nativeMessages.flatMap((message) => {
+    const content = message.type === "assistant"
+      ? message.content?.find((part: any) => part.type === "text")?.text
+      : message.text
+    if (typeof content !== "string" || !content.toLocaleLowerCase().includes(query)) return []
+    return [{ sessionID: sessionId, messageID: message.id, role: message.type, partIndex: 0,
+      kind: "text" as const, excerpt: content }]
+  }) : []
+  return { status: "page" as const, scanned: nativeMessages.length, tools: 0, reasoning: 0,
+    skipped: 0, hits, candidates: [], cursor: null }
+}
 ;(sdkManager as any).clients.set(`${instanceId}:/workspaces/${instanceId}/instance`, client)
 addInstance({ id: instanceId, folder: "/fixture", port: 0, pid: 0, proxyPath: "", status: "ready", client })
 setProviders(prev => new Map(prev).set(instanceId, [{ id: "fixture", name: "Fixture", models: [{ id: "fixture", name: "Fixture", providerId: "fixture", limit: { context: 10000, output: 1000 }, cost: { input: 0, output: 0 } }] }]))
diff --git a/packages/ui/tests/browser/fixtures/task-copy.tsx b/packages/ui/tests/browser/fixtures/task-copy.tsx
new file mode 100644
index 000000000..f713fc01a
--- /dev/null
+++ b/packages/ui/tests/browser/fixtures/task-copy.tsx
@@ -0,0 +1,91 @@
+import { createSignal, Show } from "solid-js"
+import { render } from "solid-js/web"
+import MessageSection from "../../../src/components/message-section"
+import { ConfigProvider } from "../../../src/stores/preferences"
+import { I18nProvider } from "../../../src/lib/i18n"
+import { ThemeProvider } from "../../../src/lib/theme"
+import { applyUiSettings } from "./ui-settings"
+import { sdkManager } from "../../../src/lib/sdk-manager"
+import { addInstance } from "../../../src/stores/instances"
+import { setSessions, setActiveSession } from "../../../src/stores/session-state"
+import { sseManager } from "../../../src/lib/sse-manager"
+import { loadMessages } from "../../../src/stores/session-api"
+import "../../../src/index.css"
+
+const instanceId = "task-copy-instance", parentId = "parent", childId = "child", grandchildId = "grandchild"
+const model = { providerID: "fixture", id: "fixture" }
+const requests: Array<{ sessionID: string; ascending: boolean; signal?: AbortSignal }> = []
+const clipboard: string[] = []
+let held = false
+const gates: Array<() => void> = []
+
+function toolMessage(sessionID: string, index: number, target?: string) {
+  const id = `${sessionID}-${String(index).padStart(4, "0")}`
+  return { id, type: "assistant", agent: "build", model, time: { created: index + 1, completed: index + 2 },
+    content: [{ id: target ? (sessionID === parentId ? "parent-task" : "nested-task") : `${id}-tool`,
+      type: "tool", name: target ? "subagent" : "read", time: { created: index + 1, completed: index + 2 },
+      state: { status: "completed", input: target ? { agent: "explore", description: `Explore ${target}` } : { filePath: `${id}.txt` },
+        metadata: target ? { sessionId: target } : {},
+        content: [{ type: "text", text: target ? "Task completed" : `Untruncated ${id}: ${"長い output\n".repeat(500)}` }] } }] }
+}
+
+const history: Record<string, ReturnType<typeof toolMessage>[]> = {
+  [parentId]: [toolMessage(parentId, 0, childId)],
+  [childId]: [...Array.from({ length: 230 }, (_, index) => toolMessage(childId, index)), toolMessage(childId, 230, grandchildId)],
+  [grandchildId]: Array.from({ length: 230 }, (_, index) => toolMessage(grandchildId, index)),
+}
+const client: any = {
+  session: { active: async () => ({}), inbox: { list: async () => ({ data: [] }) },
+    get: async ({ sessionID }: any) => ({ id: sessionID, location: { directory: "/fixture" }, time: { created: 1, updated: 1 } }) },
+  message: { list: async ({ sessionID, cursor, order, limit = 200 }: any, options?: { signal?: AbortSignal }) => {
+    const ascending = order === "asc" || cursor?.startsWith("asc:")
+    requests.push({ sessionID, ascending, signal: options?.signal })
+    // Deliberately ignore transport abort while held: the real consumer must
+    // detach immediately and fence this response when the fixture releases it.
+    if (held && ascending) await new Promise<void>(resolve => gates.push(resolve))
+    const messages = history[sessionID] ?? []
+    if (ascending) {
+      const start = cursor ? Number(cursor.slice(4)) : 0
+      const end = Math.min(messages.length, start + limit)
+      return { data: messages.slice(start, end), cursor: end < messages.length ? { next: `asc:${end}` } : {} }
+    }
+    const end = cursor ? Number(cursor) : messages.length
+    const start = Math.max(0, end - limit)
+    return { data: messages.slice(start, end).reverse(), cursor: start ? { next: String(start) } : {} }
+  } },
+}
+;(sdkManager as any).clients.set(`${instanceId}:/workspaces/${instanceId}/instance`, client)
+sseManager.getStatuses = () => new Map([[instanceId, "connected"]])
+addInstance({ id: instanceId, folder: "/fixture", port: 0, pid: 0, proxyPath: "", status: "ready", client })
+setSessions(previous => new Map(previous).set(instanceId, new Map(Object.keys(history).map(id => [id, {
+  id, instanceId, parentId: id === parentId ? null : id === childId ? parentId : childId,
+  title: id, location: { directory: "/fixture" }, status: "idle", agent: "build",
+  model: { providerId: "fixture", modelId: "fixture" }, time: { created: 1, updated: 1 },
+} as any]))))
+setActiveSession(instanceId, parentId)
+Object.defineProperty(navigator, "clipboard", { configurable: true, value: {
+  write: async (items: ClipboardItem[]) => { clipboard.push(await (await items[0].getType("text/plain")).text()) },
+  writeText: async (text: string) => { clipboard.push(text) },
+} })
+
+await applyUiSettings({ showMessageTimeline: false, toolInputsVisibility: "hidden", toolOutputExpansion: "expanded",
+  toolCallExpansionDefaults: { preset: "custom", thinking: "collapsed", tools: { task: "expanded", read: "collapsed", other: "expanded" } } })
+for (const id of Object.keys(history)) await loadMessages(instanceId, id, { force: true })
+const [activeInstance, setActiveInstance] = createSignal(true)
+const [selectedSession, setSelectedSession] = createSignal(parentId)
+const [mounted, setMounted] = createSignal(true)
+render(() => <ConfigProvider><I18nProvider><ThemeProvider><Show when={mounted()}>
+  <main style={{ display: "flex", height: "800px", width: "1000px" }}>
+    <MessageSection instanceId={instanceId} sessionId={parentId}
+      isActive={activeInstance() && selectedSession() === parentId} />
+  </main>
+</Show></ThemeProvider></I18nProvider></ConfigProvider>, document.getElementById("root")!)
+;(window as any).fixture = {
+  hold: () => { held = true },
+  release: () => { held = false; gates.splice(0).forEach(resolve => resolve()) },
+  selectSession: (id: string) => { setSelectedSession(id); setActiveSession(instanceId, id) },
+  setActiveInstance,
+  unmount: () => setMounted(false),
+  snapshot: () => ({ selectedSession: selectedSession(), activeInstance: activeInstance(), clipboard,
+    requests: requests.map(({ sessionID, ascending, signal }) => ({ sessionID, ascending, aborted: signal?.aborted ?? false })) }),
+}
diff --git a/packages/ui/tests/browser/full-source-copy.test.ts b/packages/ui/tests/browser/full-source-copy.test.ts
new file mode 100644
index 000000000..63a9cd74f
--- /dev/null
+++ b/packages/ui/tests/browser/full-source-copy.test.ts
@@ -0,0 +1,154 @@
+import assert from "node:assert/strict"
+import { after, before, test } from "node:test"
+import { fileURLToPath } from "node:url"
+import { chromium, type Browser, type Locator, type Page } from "playwright"
+import { createServer, type ViteDevServer } from "vite"
+import solid from "vite-plugin-solid"
+
+let server: ViteDevServer, browser: Browser, url: string
+before(async () => {
+  server = await createServer({ configFile: false, root: fileURLToPath(new URL("../..", import.meta.url)), logLevel: "error",
+    plugins: [solid(), { name: "full-source-copy-fixture", configureServer(s) {
+      s.middlewares.use("/fixture", async (_req, res) => {
+        res.setHeader("Content-Type", "text/html")
+        res.end(await s.transformIndexHtml("/fixture", '<html><body><div id="root"></div><script type="module" src="/tests/browser/fixtures/full-source-copy.tsx"></script></body></html>'))
+      })
+    } }], resolve: { dedupe: ["solid-js"] }, optimizeDeps: { exclude: ["lucide-solid"] },
+    server: { host: "127.0.0.1", port: 0, hmr: false, watch: null },
+  })
+  await server.listen()
+  url = `http://127.0.0.1:${(server.httpServer!.address() as { port: number }).port}/fixture`
+  browser = await chromium.launch({ executablePath: process.env.CODENOMAD_BROWSER_PATH || undefined })
+})
+after(async () => { await browser?.close(); await server?.close() })
+
+async function withFixture(scenario: string, run: (page: Page) => Promise<void>) {
+  const context = await browser.newContext({ viewport: { width: 1100, height: 900 }, locale: "en-US",
+    hasTouch: false, isMobile: false, permissions: ["clipboard-read", "clipboard-write"] })
+  const page = await context.newPage()
+  page.setDefaultTimeout(10_000)
+  const errors: string[] = []
+  page.on("pageerror", error => errors.push(error.message))
+  await page.route("**/api/**", route => route.fulfill({ contentType: "application/json", body: "{}" }))
+  try {
+    await page.goto(`${url}?scenario=${scenario}`, { waitUntil: "domcontentloaded", timeout: 30_000 })
+    await page.waitForFunction(() => Boolean((window as any).fixture))
+    assert.equal(await page.evaluate(() => matchMedia("(hover: hover) and (pointer: fine)").matches), true)
+    await page.evaluate(() => navigator.clipboard.writeText("clipboard sentinel"))
+    await run(page)
+    assert.deepEqual(errors, [])
+    assert.ok(await page.evaluate(() => (window as any).fixture.requests.length > 0))
+  } catch (error) {
+    console.error("Full-source fixture failure", scenario, errors, (await page.locator("main").textContent())?.slice(0, 2000))
+    throw error
+  } finally { await context.close() }
+}
+
+async function copyWithPointer(page: Page, button: Locator): Promise<string> {
+  await button.scrollIntoViewIfNeeded()
+  await button.hover()
+  assert.deepEqual(await button.evaluate(element => {
+    const style = getComputedStyle(element)
+    return { opacity: style.opacity, pointerEvents: style.pointerEvents }
+  }), { opacity: "1", pointerEvents: "auto" }, "Body actions must remain visible and pointer-accessible on desktop")
+  // Real hit testing: no forced click, DOM event dispatch, or CSS overrides.
+  await button.click()
+  await page.waitForFunction(async () => (await navigator.clipboard.readText()) !== "clipboard sentinel")
+  return page.evaluate(() => navigator.clipboard.readText())
+}
+
+for (const scenario of ["diagnostics-many", "diagnostics-long"]) {
+  test(`${scenario}: desktop body copy retains original diagnostics beyond the bounded preview`, { timeout: 45_000 }, async () => withFixture(scenario, async page => {
+    await page.locator(".tool-call-diagnostics-heading").click()
+    const region = page.locator(".tool-call-diagnostics")
+    const rows = region.getByRole("listitem")
+    assert.equal(await rows.count(), scenario === "diagnostics-many" ? 100 : 1)
+    const lengths = await rows.locator(".tool-call-diagnostic-message").evaluateAll(elements => elements.map(element => element.textContent!.length))
+    assert.ok(lengths.every(length => length <= 2000))
+    if (scenario === "diagnostics-long") assert.equal(lengths[0], 2000)
+    const original = await page.evaluate(() => (window as any).fixture.diagnostics)
+    const before = await region.locator("*").count()
+    const copied = await copyWithPointer(page, region.getByRole("button", { name: "Copy tool output", exact: true }))
+    assert.deepEqual(JSON.parse(copied), original)
+    assert.equal(await region.locator("*").count(), before, "Copy must not expand the preview DOM")
+    assert.ok(before < 1000)
+  }))
+}
+
+test("message-parts footer copies all original parts while only 200 parts render", { timeout: 45_000 }, async () => withFixture("parts", async page => {
+  const block = page.locator('.message-stream-block[data-message-id="full-source-message"]')
+  const footer = block.locator(":scope > .tool-call-diagnostic-message[role=status]")
+  await footer.waitFor()
+  const rendered = (await block.textContent())!.match(/Paragraph \d{3}/g) ?? []
+  assert.equal(rendered.length, 200)
+  assert.ok(rendered.includes("Paragraph 000") && rendered.includes("Paragraph 236"))
+  assert.ok(!rendered.includes("Paragraph 118"), "The omitted middle must not render")
+  const before = await block.locator("*").count()
+  const copied = JSON.parse(await copyWithPointer(page, footer.getByRole("button", { name: "Copy tool output", exact: true })))
+  const original = await page.evaluate(() => {
+    const fixture = (window as any).fixture
+    return fixture.textParts.map((part: any, index: number) => ({ ...part,
+      id: `${fixture.messageId}-text-${index}`, sessionID: fixture.sessionId, messageID: fixture.messageId }))
+  })
+  assert.deepEqual(copied, original)
+  assert.equal(copied.length, 237)
+  assert.ok(await block.locator("*").count() <= before, "Copy must not mount the omitted parts")
+  assert.equal((await block.textContent())!.match(/Paragraph \d{3}/g)?.length, 200)
+  assert.ok(before < 1500)
+}))
+
+test("tool-error body copies the complete error beyond the 10000-character preview", { timeout: 45_000 }, async () => withFixture("error", async page => {
+  const body = page.locator(".tool-call-error-content")
+  await body.waitFor()
+  const original = await page.evaluate(() => (window as any).fixture.error as string)
+  assert.ok(original.length > 10_000)
+  assert.ok((await body.textContent())!.length < 10_200)
+  assert.ok(!(await body.textContent())!.includes("END-ERROR"))
+  const before = await body.locator("*").count()
+  const copied = await copyWithPointer(page, body.getByRole("button", { name: "Copy tool output", exact: true }))
+  // Chromium's real Windows clipboard normalizes LF to CRLF on readback.
+  assert.equal(copied.replace(/\r\n/g, "\n"), original)
+  assert.equal(await body.locator("*").count(), before)
+  assert.ok(before < 20)
+}))
+
+test("todo overflow footer copies every original todo while rendering at most 200 rows", { timeout: 45_000 }, async () => withFixture("todo", async page => {
+  const region = page.locator(".tool-call-todo-region")
+  await region.waitFor()
+  assert.equal(await region.getByRole("listitem").count(), 200)
+  assert.ok(!(await region.textContent())!.includes("Task 236"))
+  const before = await region.locator("*").count()
+  const copied = await copyWithPointer(page, region.getByRole("button", { name: "Copy tool output", exact: true }))
+  assert.deepEqual(JSON.parse(copied), await page.evaluate(() => (window as any).fixture.todos))
+  assert.equal(await region.getByRole("listitem").count(), 200)
+  assert.equal(await region.locator("*").count(), before)
+  assert.ok(before < 2500)
+}))
+
+test("oversized tool input copies complete JSON from its inner IO header, independently of output", { timeout: 45_000 }, async () => withFixture("input", async page => {
+  const inputSection = page.locator(".tool-call-io-section").first()
+  await inputSection.waitFor()
+  const original = await page.evaluate(() => (window as any).fixture.input)
+  assert.ok(JSON.stringify(original).length > 20_000)
+  const preview = await inputSection.locator(".tool-call-io-body").textContent()
+  assert.ok(preview!.length < 1000, "Oversized input must render a bounded omission placeholder")
+  assert.match(preview!, /Structured output omitted from rendering/)
+  assert.ok(!preview!.includes("INPUT-END"))
+  const before = await inputSection.locator("*").count()
+  const copied = await copyWithPointer(page, inputSection.getByRole("button", { name: "Copy tool input", exact: true }))
+  assert.deepEqual(JSON.parse(copied), original)
+  assert.ok(await inputSection.locator("*").count() < 100, "Highlighting and copy must retain the bounded placeholder DOM")
+  assert.match((await inputSection.locator(".tool-call-io-body").textContent())!, /Structured output omitted from rendering/)
+  assert.ok(before < 100)
+
+  // The outer header's alternate copy route is output-only, so it cannot
+  // substitute for the input button when the arguments have been omitted.
+  await page.evaluate(() => navigator.clipboard.writeText("clipboard sentinel"))
+  const header = page.locator(".tool-call > .tool-call-header")
+  await header.hover()
+  await header.getByRole("button", { name: "Copy tool output", exact: true }).click()
+  await page.waitForFunction(async () => (await navigator.clipboard.readText()) !== "clipboard sentinel")
+  const output = await page.evaluate(() => navigator.clipboard.readText())
+  assert.equal(output, await page.evaluate(() => (window as any).fixture.output))
+  assert.notEqual(output, copied)
+}))
diff --git a/packages/ui/tests/browser/permission-fallback-diff.test.ts b/packages/ui/tests/browser/permission-fallback-diff.test.ts
new file mode 100644
index 000000000..d161d9409
--- /dev/null
+++ b/packages/ui/tests/browser/permission-fallback-diff.test.ts
@@ -0,0 +1,115 @@
+import assert from "node:assert/strict"
+import { after, before, test } from "node:test"
+import { fileURLToPath } from "node:url"
+import { chromium, type Browser, type Page } from "playwright"
+import { createServer, type ViteDevServer } from "vite"
+import solid from "vite-plugin-solid"
+
+let server: ViteDevServer, browser: Browser, url: string
+before(async () => {
+  server = await createServer({ configFile: false, root: fileURLToPath(new URL("../..", import.meta.url)), logLevel: "error",
+    plugins: [solid(), { name: "permission-fallback-fixture", configureServer(s) {
+      s.middlewares.use("/permission-fallback-fixture", async (_req, res) => {
+        res.setHeader("Content-Type", "text/html")
+        res.end(await s.transformIndexHtml("/permission-fallback-fixture", '<html><body><div id="root"></div><script type="module" src="/tests/browser/fixtures/permission-fallback-diff.tsx"></script></body></html>'))
+      })
+    } }], resolve: { dedupe: ["solid-js"] }, optimizeDeps: { exclude: ["lucide-solid"] },
+    server: { host: "127.0.0.1", port: 0, hmr: false, watch: null },
+  })
+  await server.listen()
+  url = `http://127.0.0.1:${(server.httpServer!.address() as { port: number }).port}/permission-fallback-fixture`
+  browser = await chromium.launch({ executablePath: process.env.CODENOMAD_BROWSER_PATH || undefined })
+})
+after(async () => { await browser?.close(); await server?.close() })
+
+async function openFixture(page: Page, clipboard: "success" | "failure" | "pending") {
+  const errors: string[] = []
+  page.on("pageerror", error => errors.push(error.message))
+  await page.route("**/api/**", route => route.fulfill({ contentType: "application/json", body: "{}" }))
+  // Use source text: tsx's function-name helpers are not present in the browser realm.
+  await page.addInitScript(`{
+    const mode = ${JSON.stringify(clipboard)};
+    Object.defineProperty(navigator, "clipboard", { configurable: true, value: { writeText: async (text) => {
+      window.copied = text
+      if (mode === "failure") throw new Error("Clipboard denied")
+      if (mode === "pending") await new Promise(resolve => { window.finishCopy = resolve })
+    } } })
+    document.execCommand = () => false
+  }`)
+  await page.goto(url)
+  await page.getByRole("button", { name: "Copy patch", exact: true }).waitFor()
+  await page.waitForFunction(() => Boolean((window as any).fixture))
+  assert.deepEqual(errors, [], "fixture must initialize without browser errors")
+}
+
+test("source-less modal diff is complete through bounded pages even when clipboard fails", async () => {
+  const page = await browser.newPage({ locale: "en-US" })
+  try {
+    await openFixture(page, "failure")
+    const allow = page.getByRole("button", { name: "Allow Once", exact: true })
+    const always = page.getByRole("button", { name: "Always Allow", exact: true })
+    assert.equal(await allow.isDisabled(), true)
+    assert.equal(await always.isDisabled(), true)
+    assert.equal(await page.getByRole("button", { name: "Deny", exact: true }).isEnabled(), true)
+    await page.getByRole("button", { name: "Copy patch", exact: true }).click()
+    await page.getByRole("status").filter({ hasText: "Copy failed" }).waitFor()
+    assert.equal(await allow.isDisabled(), true)
+    const chunks: string[] = []
+    const next = page.getByRole("button", { name: "Next diff page", exact: true })
+    for (;;) {
+      const chunk = await page.locator(".tool-call-diff-fallback").textContent() ?? ""
+      assert.ok(chunk.length <= 10_000)
+      chunks.push(chunk)
+      if (await next.isDisabled()) break
+      assert.equal(await allow.isDisabled(), true)
+      await next.click()
+    }
+    assert.equal(chunks.join(""), await page.evaluate(() => (window as any).fixture.diff))
+    assert.equal(await allow.isEnabled(), true)
+    assert.equal(await always.isEnabled(), true)
+    await page.evaluate(() => (window as any).fixture.refresh())
+    assert.equal(await allow.isEnabled(), true)
+    await allow.click()
+    assert.deepEqual(await page.evaluate(() => (window as any).fixture.replies), [{ sessionID: "session", requestID: "request", decision: "once" }])
+  } finally { await page.close() }
+})
+
+test("full copy unlocks both approvals only for the same request and unchanged diff", async () => {
+  const page = await browser.newPage({ locale: "en-US" })
+  try {
+    await openFixture(page, "success")
+    const allow = page.getByRole("button", { name: "Allow Once", exact: true })
+    const copy = page.getByRole("button", { name: "Copy patch", exact: true })
+    await copy.click()
+    assert.equal(await page.evaluate(() => (window as any).copied === (window as any).fixture.diff), true)
+    assert.equal(await allow.isEnabled(), true)
+    await page.evaluate(() => (window as any).fixture.refresh())
+    assert.equal(await allow.isEnabled(), true)
+    await page.evaluate(() => (window as any).fixture.changeDiff())
+    assert.equal(await allow.isDisabled(), true)
+    await copy.click()
+    assert.equal(await allow.isEnabled(), true)
+    await page.evaluate(() => (window as any).fixture.nextRequest())
+    assert.equal(await allow.isDisabled(), true)
+    await copy.click()
+    await page.getByRole("button", { name: "Always Allow", exact: true }).click()
+    assert.deepEqual(await page.evaluate(() => (window as any).fixture.replies), [{ sessionID: "session", requestID: "next-request", decision: "always" }])
+  } finally { await page.close() }
+})
+
+test("late clipboard success cannot unlock a changed diff or a dismissed view", async () => {
+  const page = await browser.newPage({ locale: "en-US" })
+  try {
+    await openFixture(page, "pending")
+    const copy = page.getByRole("button", { name: "Copy patch", exact: true })
+    await copy.click()
+    await page.evaluate(() => (window as any).fixture.changeDiff())
+    await page.evaluate(() => (window as any).finishCopy())
+    assert.equal(await page.getByRole("button", { name: "Allow Once", exact: true }).isDisabled(), true)
+    await copy.click()
+    await page.keyboard.press("Escape")
+    await page.evaluate(() => (window as any).finishCopy())
+    await page.evaluate(() => (window as any).fixture.reopen())
+    assert.equal(await page.getByRole("button", { name: "Allow Once", exact: true }).isDisabled(), true)
+  } finally { await page.close() }
+})
diff --git a/packages/ui/tests/browser/session-rendering.test.ts b/packages/ui/tests/browser/session-rendering.test.ts
index a6cd41880..3d645244e 100644
--- a/packages/ui/tests/browser/session-rendering.test.ts
+++ b/packages/ui/tests/browser/session-rendering.test.ts
@@ -79,6 +79,24 @@ test("new-session reply renders live after optimistic-send reordering, and survi
   })
 })
 
+test("a mounted response renders a newly appended consecutive text part without remounting", async () => {
+  await open("session", async page => {
+    await page.evaluate(() => {
+      const fixture = (window as any).fixture
+      fixture.start()
+      fixture.delta("First content part")
+      fixture.end("First content part")
+    })
+    const row = page.locator('.message-stream-block[data-message-id="msg_assistant"]')
+    await page.waitForFunction(() => document.querySelector(".message-stream")?.textContent?.includes("First content part"))
+    await row.evaluate(element => { (window as any).originalMessageRow = element })
+    await page.evaluate(() => (window as any).fixture.appendTextPart("Appended content part"))
+    await page.waitForFunction(() => document.querySelector(".message-stream")?.textContent?.includes("Appended content part"))
+    assert.equal(await row.evaluate(element => element === (window as any).originalMessageRow), true)
+    assert.ok((await row.textContent())?.includes("First content part"))
+  })
+})
+
 test("long list reaches its actual end, appends beyond the initial range, and stays bounded", async () => {
   await open("navigation", async page => {
     await page.evaluate(() => (window as any).fixture.bottom())
diff --git a/packages/ui/tests/browser/system-messages.test.ts b/packages/ui/tests/browser/system-messages.test.ts
index 32ef5d4aa..110441c08 100644
--- a/packages/ui/tests/browser/system-messages.test.ts
+++ b/packages/ui/tests/browser/system-messages.test.ts
@@ -35,6 +35,10 @@ async function open(run: (page: Page) => Promise<void>) {
   } finally { await page.close() }
 }
 const system = '[data-message-kind="system"]'
+async function toggleSystemDisclosure(page: Page) {
+  await page.locator(system).getByRole("button").focus()
+  await page.keyboard.press("Enter")
+}
 test("system context is hidden by default, including live instructions and reloads", async () => open(async page => {
   assert.equal(await page.locator(system).count(), 0)
   assert.equal(await page.getByText(/Today's date is now/).count(), 0)
@@ -95,7 +99,7 @@ test("visible live notices render as System and obey local and global disclosure
   assert.equal(await page.locator(`${system} pre`).count(), 0)
 }))
 
-test("search navigates system occurrences and restores highlights after disclosure changes", async () => open(async page => {
+test("search highlights system occurrences and restores highlights after disclosure changes", async () => open(async page => {
   await page.getByRole("button", { name: "Message content", exact: true }).click()
   const row = page.getByRole("group", { name: "System", exact: true })
   await row.getByRole("button", { name: "Show System", exact: true }).click()
@@ -104,14 +108,14 @@ test("search navigates system occurrences and restores highlights after disclosu
   await page.getByPlaceholder("Search current chat...").fill("system-reminder")
   await page.locator(`${system} mark.session-search-match-active`).waitFor()
   assert.equal(await page.locator(`${system} mark.session-search-match`).count(), 2)
-  await page.locator(system).getByRole("button").click()
+  await toggleSystemDisclosure(page)
   assert.equal(await page.locator(`${system} pre`).count(), 0)
-  await page.getByRole("button", { name: "Next match", exact: true }).click()
+  await toggleSystemDisclosure(page)
   await page.locator(`${system} pre`).waitFor({ timeout: 5000 })
   await page.locator(`${system} mark.session-search-match-active`).waitFor({ timeout: 5000 })
   assert.equal(await page.locator(`${system} mark.session-search-match-active`).count(), 1)
-  await page.locator(system).getByRole("button").click()
-  await page.locator(system).getByRole("button").click()
+  await toggleSystemDisclosure(page)
+  await toggleSystemDisclosure(page)
   await page.locator(`${system} mark.session-search-match-active`).waitFor({ timeout: 5000 })
 }))
 
diff --git a/packages/ui/tests/browser/task-copy.test.ts b/packages/ui/tests/browser/task-copy.test.ts
new file mode 100644
index 000000000..ccd10514e
--- /dev/null
+++ b/packages/ui/tests/browser/task-copy.test.ts
@@ -0,0 +1,94 @@
+import assert from "node:assert/strict"
+import { after, before, test } from "node:test"
+import { fileURLToPath } from "node:url"
+import { chromium, type Browser, type Page } from "playwright"
+import { createServer, type ViteDevServer } from "vite"
+import solid from "vite-plugin-solid"
+
+let server: ViteDevServer, browser: Browser, url: string
+before(async () => {
+  server = await createServer({ configFile: false, root: fileURLToPath(new URL("../..", import.meta.url)), logLevel: "error",
+    plugins: [solid(), { name: "task-copy-fixture", configureServer(s) {
+      s.middlewares.use("/fixture", async (_req, res) => {
+        res.setHeader("Content-Type", "text/html")
+        res.end(await s.transformIndexHtml("/fixture", '<html><body><div id="root"></div><script type="module" src="/tests/browser/fixtures/task-copy.tsx"></script></body></html>'))
+      })
+    } }], resolve: { dedupe: ["solid-js"] }, optimizeDeps: { exclude: ["lucide-solid"] },
+    server: { host: "127.0.0.1", port: 0, hmr: false, watch: null },
+  })
+  await server.listen()
+  url = `http://127.0.0.1:${(server.httpServer!.address() as { port: number }).port}/fixture`
+  browser = await chromium.launch({ executablePath: process.env.CODENOMAD_BROWSER_PATH || undefined })
+})
+after(async () => { await browser?.close(); await server?.close() })
+
+async function withPage(run: (page: Page) => Promise<void>) {
+  const page = await browser.newPage({ viewport: { width: 1100, height: 900 }, locale: "en-US" })
+  page.setDefaultTimeout(10_000)
+  const errors: string[] = []
+  page.on("pageerror", error => errors.push(error.message))
+  await page.route("**/api/**", route => route.fulfill({ contentType: "application/json", body: "{}" }))
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30_000 })
+    await page.waitForFunction(() => Boolean((window as any).fixture))
+    await run(page)
+    assert.deepEqual(errors, [])
+  } catch (error) {
+    console.error("Task-copy fixture failure", errors, await page.evaluate(() => ({
+      state: (window as any).fixture?.snapshot(),
+      text: document.querySelector("main")?.textContent?.slice(0, 2500),
+      tools: Array.from(document.querySelectorAll(".tool-call")).slice(0, 5).map(element => ({
+        part: element.getAttribute("data-part-id"), expanded: element.querySelector(".tool-call-header-toggle")?.getAttribute("aria-expanded"),
+      })),
+    })))
+    throw error
+  } finally { await page.close() }
+}
+
+async function copyButton(page: Page, nested: boolean) {
+  const tool = page.locator(`.tool-call[data-part-id="${nested ? "nested-task" : "parent-task"}"]`)
+  const toggle = tool.locator(":scope > .tool-call-header > .tool-call-header-toggle")
+  if (await toggle.getAttribute("aria-expanded") !== "true") await toggle.click()
+  return tool.locator(".tool-call-task-sections").first()
+    .locator(":scope > section > header .tool-call-io-actions > button").first()
+}
+
+test("nested task copies inherit the active parent conversation rather than selected child identity", { timeout: 45_000 }, async () => withPage(async page => {
+  const button = await copyButton(page, true)
+  await button.click()
+  await page.waitForFunction(() => (window as any).fixture.snapshot().clipboard.length === 1)
+  const state = await page.evaluate(() => (window as any).fixture.snapshot())
+  assert.equal(state.selectedSession, "parent")
+  const copied = JSON.parse(state.clipboard[0])
+  assert.equal(copied.length, 230)
+  assert.equal(copied[0].state.output, `Untruncated grandchild-0000: ${"長い output\n".repeat(500)}`)
+  assert.equal(copied.at(-1).id, "grandchild-0229-tool")
+  assert.equal(state.requests.filter((request: any) => request.ascending && request.sessionID === "grandchild").length, 2)
+}))
+
+for (const scenario of ["parent-session", "parent-instance", "nested-session", "nested-instance", "nested-unmount"] as const) {
+  test(`${scenario} lifecycle cancels held full-copy reads and fences late clipboard writes`, { timeout: 45_000 }, async () => withPage(async page => {
+    const nested = scenario.startsWith("nested")
+    const sessionID = nested ? "grandchild" : "child"
+    const button = await copyButton(page, nested)
+    await page.evaluate(() => (window as any).fixture.hold())
+    await button.click()
+    await page.waitForFunction(sessionID => (window as any).fixture.snapshot().requests.some((request: any) =>
+      request.ascending && request.sessionID === sessionID), sessionID)
+    assert.equal(await button.isDisabled(), true)
+    await page.evaluate(scenario => {
+      const fixture = (window as any).fixture
+      if (scenario.endsWith("instance")) fixture.setActiveInstance(false)
+      else if (scenario.endsWith("unmount")) fixture.unmount()
+      else fixture.selectSession("other")
+    }, scenario)
+    await page.waitForFunction(sessionID => (window as any).fixture.snapshot().requests.some((request: any) =>
+      request.ascending && request.sessionID === sessionID && request.aborted), sessionID)
+    await page.evaluate(() => (window as any).fixture.release())
+    // Let the deliberately late transport response and consumer finalizers run.
+    await page.evaluate(() => new Promise<void>(resolve => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))))
+    const state = await page.evaluate(() => (window as any).fixture.snapshot())
+    assert.deepEqual(state.clipboard, [])
+    assert.equal(state.requests.filter((request: any) => request.ascending && request.sessionID === sessionID).length, 1)
+  }))
+}