diff --git a/packages/ui/src/components/chat/ChatContainer.tsx b/packages/ui/src/components/chat/ChatContainer.tsx
index 5a4651a2..b598a568 100644
--- a/packages/ui/src/components/chat/ChatContainer.tsx
+++ b/packages/ui/src/components/chat/ChatContainer.tsx
@@ -35,9 +35,11 @@ import {
     useSessionMessageRecords,
     useSessions,
     useDirectorySync,
+    useSyncDirectory,
     useSessionStatus,
 } from '@/sync/sync-context';
 import { useSync } from '@/sync/use-sync';
+import { getSessionPrefetch, subscribeSessionPrefetch } from '@/sync/session-prefetch-cache';
 import { getSessionMaterializationStatus } from '@/sync/materialization';
 import { usePlanDetection } from '@/hooks/usePlanDetection';
 import { getAllSyncSessions } from '@/sync/sync-refs';
@@ -342,6 +344,7 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
 
     // Sync actions
     const sync = useSync();
+    const syncDirectory = useSyncDirectory();
     const ensureSessionRenderable = React.useCallback(
         (sessionId: string) => sync.ensureSessionRenderable(sessionId),
         [sync],
@@ -384,12 +387,25 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     // Messages from sync system
     const sessionMessageRecords = useSessionMessageRecords(currentSessionId ?? '');
     const sessionMessages = currentSessionId ? sessionMessageRecords : EMPTY_MESSAGES;
+    const sessionPrefetchInfo = React.useSyncExternalStore(
+        React.useCallback(
+            (notify) => currentSessionId
+                ? subscribeSessionPrefetch(syncDirectory, currentSessionId, notify)
+                : () => undefined,
+            [currentSessionId, syncDirectory],
+        ),
+        React.useCallback(
+            () => currentSessionId ? getSessionPrefetch(syncDirectory, currentSessionId) : undefined,
+            [currentSessionId, syncDirectory],
+        ),
+        React.useCallback(() => undefined, []),
+    );
 
     // Sessions from sync system
     const sessions = useSessions();
 
     // Plan detection - watches messages for plan creation and signals store
-    usePlanDetection(currentSessionId ?? '');
+    usePlanDetection(currentSessionId ?? '', sessionMessages);
 
     // Session status from sync system
     const sessionStatusForCurrent = useSessionStatus(currentSessionId ?? '') ?? IDLE_SESSION_STATUS;
@@ -494,12 +510,13 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     // History metadata — use sync's hasMore/isLoading
     const historyMeta = React.useMemo(() => {
         if (!currentSessionId) return null;
+        const prefetchHasMore = Boolean(sessionPrefetchInfo?.cursor) && sessionPrefetchInfo?.complete !== true;
         return {
             limit: sessionMessages.length,
-            complete: !sync.hasMore(currentSessionId),
+            complete: !(sync.hasMore(currentSessionId) || prefetchHasMore),
             loading: sync.isLoading(currentSessionId),
         };
-    }, [currentSessionId, sessionMessages.length, sync]);
+    }, [currentSessionId, sessionMessages.length, sessionPrefetchInfo, sync]);
 
     const { isMobile } = useDeviceInfo();
     const draftOpen = Boolean(newSessionDraft?.open);
@@ -868,6 +885,7 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
 		<div className="relative flex flex-col h-full bg-background">
 			{returnToParentButton}
 			<ChatViewport
+				key={currentSessionId}
 				currentSessionId={currentSessionId}
                 isDesktopExpandedInput={isDesktopExpandedInput}
                 isMobile={isMobile}
diff --git a/packages/ui/src/components/chat/MarkdownRendererImpl.tsx b/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
index 10c6d0f2..0dff058d 100644
--- a/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
+++ b/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
@@ -27,6 +27,7 @@ import { useDeviceInfo } from '@/lib/device';
 import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import type { EditorAPI } from '@/lib/api/types';
+import { isVSCodeRuntime } from '@/lib/desktop';
 
 const useCurrentMermaidTheme = () => {
   const themeSystem = useOptionalThemeSystem();
@@ -714,6 +715,8 @@ const normalizeCodeBlockText = (code: string, language: string): string => {
 };
 
 const CODE_HIGHLIGHT_SETTLE_MS = 300;
+const CODE_HIGHLIGHT_LINE_LIMIT = 1200;
+const VSCODE_CODE_HIGHLIGHT_LINE_LIMIT = 200;
 const CODE_SHARED_STYLE: React.CSSProperties = {
   margin: 0,
   background: 'transparent',
@@ -722,6 +725,23 @@ const CODE_SHARED_STYLE: React.CSSProperties = {
   lineHeight: 'var(--markdown-code-block-line-height)',
 };
 
+const exceedsLineLimit = (value: string, limit: number): boolean => {
+  let lineCount = 1;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value.charCodeAt(index) === 10) {
+      lineCount += 1;
+      if (lineCount > limit) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+const getCodeHighlightLineLimit = (): number => (
+  isVSCodeRuntime() ? VSCODE_CODE_HIGHLIGHT_LINE_LIMIT : CODE_HIGHLIGHT_LINE_LIMIT
+);
+
 const downloadTextFile = (content: string, filename: string, mimeType: string) => {
   if (typeof window === 'undefined') {
     return;
@@ -753,6 +773,7 @@ const MarkdownCodeBlock: React.FC<{
   const prevCodeRef = React.useRef<string>(code);
   const timerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
   const { isMobile, isTablet } = useDeviceInfo();
+  const skipHighlight = exceedsLineLimit(code, getCodeHighlightLineLimit());
 
   const canPreview = language === 'html' || language === 'htm';
 
@@ -852,7 +873,7 @@ const MarkdownCodeBlock: React.FC<{
         </div>
       ) : (
         <div className="px-3 py-2.5">
-          {highlight ? (
+          {highlight && !skipHighlight ? (
             <SyntaxHighlighter
               language={language}
               style={syntaxTheme}
@@ -1023,10 +1044,22 @@ interface MarkdownRendererProps {
 const MERMAID_BLOCK_SELECTOR = '[data-markdown="mermaid-block"]';
 const FILE_LINK_SELECTOR = '[data-openchamber-file-link="true"]';
 const FILE_REFERENCE_STAT_CONCURRENCY = 4;
+const FILE_REFERENCE_STAT_CACHE_MAX = 1000;
+const VSCODE_FILE_REFERENCE_STAT_CACHE_MAX = 200;
+const FILE_REFERENCE_LINK_LIMIT = 200;
+const VSCODE_FILE_REFERENCE_LINK_LIMIT = 40;
 const FILE_REFERENCE_STAT_CACHE = new Map<string, Promise<boolean>>();
 let activeFileReferenceStatCount = 0;
 const pendingFileReferenceStats: Array<() => void> = [];
 
+const getFileReferenceStatCacheMax = (): number => (
+  isVSCodeRuntime() ? VSCODE_FILE_REFERENCE_STAT_CACHE_MAX : FILE_REFERENCE_STAT_CACHE_MAX
+);
+
+const getFileReferenceLinkLimit = (): number => (
+  isVSCodeRuntime() ? VSCODE_FILE_REFERENCE_LINK_LIMIT : FILE_REFERENCE_LINK_LIMIT
+);
+
 type ParsedFileReference = {
   path: string;
   line?: number;
@@ -1300,6 +1333,8 @@ const fileReferenceExists = (resolvedPath: string): Promise<boolean> => {
 
   const cached = FILE_REFERENCE_STAT_CACHE.get(normalizedPath);
   if (cached) {
+    FILE_REFERENCE_STAT_CACHE.delete(normalizedPath);
+    FILE_REFERENCE_STAT_CACHE.set(normalizedPath, cached);
     return cached;
   }
 
@@ -1326,6 +1361,14 @@ const fileReferenceExists = (resolvedPath: string): Promise<boolean> => {
     pendingFileReferenceStats.push(run);
   });
 
+  const maxCacheEntries = getFileReferenceStatCacheMax();
+  while (FILE_REFERENCE_STAT_CACHE.size >= maxCacheEntries) {
+    const oldest = FILE_REFERENCE_STAT_CACHE.keys().next().value;
+    if (typeof oldest !== 'string') {
+      break;
+    }
+    FILE_REFERENCE_STAT_CACHE.delete(oldest);
+  }
   FILE_REFERENCE_STAT_CACHE.set(normalizedPath, request);
   return request;
 };
@@ -1362,6 +1405,7 @@ const useFileReferenceInteractions = ({
       return;
     }
     let cancelled = false;
+    const fileReferenceLinkLimit = getFileReferenceLinkLimit();
 
     const clearFileLinkAttributes = (candidate: HTMLElement) => {
       candidate.removeAttribute('data-openchamber-file-link');
@@ -1376,18 +1420,37 @@ const useFileReferenceInteractions = ({
       }
     };
 
+    const clearAnnotatedFileLinks = () => {
+      const annotated = container.querySelectorAll<HTMLElement>(FILE_LINK_SELECTOR);
+      for (const candidate of Array.from(annotated)) {
+        clearFileLinkAttributes(candidate);
+      }
+    };
+
+    if (!enabled) {
+      clearAnnotatedFileLinks();
+      return;
+    }
+
     const annotateFileLinks = () => {
       const candidates = container.querySelectorAll<HTMLElement>('[data-markdown="inline-code"], a');
+      let linkedCount = 0;
 
       for (const candidate of Array.from(candidates)) {
         const rawCandidate = extractPathCandidateFromElement(candidate);
         const resolved = getResolvedReference(rawCandidate, effectiveDirectory);
         clearFileLinkAttributes(candidate);
 
-        if (!enabled || !resolved) {
+        if (!resolved) {
           continue;
         }
 
+        if (linkedCount >= fileReferenceLinkLimit) {
+          continue;
+        }
+
+        linkedCount += 1;
+
         void fileReferenceExists(resolved.resolvedPath).then((exists) => {
           if (cancelled || !exists || !container.contains(candidate)) {
             return;
diff --git a/packages/ui/src/components/chat/MessageList.tsx b/packages/ui/src/components/chat/MessageList.tsx
index 5a12b3a0..a1400d95 100644
--- a/packages/ui/src/components/chat/MessageList.tsx
+++ b/packages/ui/src/components/chat/MessageList.tsx
@@ -984,7 +984,7 @@ const StaticHistoryList: React.FC<{
         ? Math.max(0, totalSize - (virtualRows[virtualRows.length - 1]?.end ?? 0))
         : 0;
 
-    if (!shouldVirtualize || (virtualRows.length === 0 && entries.length > 0)) {
+    if (!shouldVirtualize) {
         return (
             <div ref={contentRef} className="relative w-full">
                 {entries.map((entry) => (
@@ -999,6 +999,27 @@ const StaticHistoryList: React.FC<{
         );
     }
 
+    if (virtualRows.length === 0 && entries.length > 0) {
+        const fallbackStart = Math.max(0, entries.length - MESSAGE_LIST_OVERSCAN * 2);
+        const fallbackEntries = entries.slice(fallbackStart);
+        const fallbackHeight = fallbackEntries.reduce((total, entry) => total + estimateHistoryEntryHeight(entry), 0);
+        const fallbackPaddingTop = Math.max(0, totalSize - fallbackHeight);
+
+        return (
+            <div ref={contentRef} className="relative w-full">
+                {fallbackPaddingTop > 0 ? <div aria-hidden="true" style={{ height: `${fallbackPaddingTop}px` }} /> : null}
+                {fallbackEntries.map((entry) => (
+                    <div
+                        key={entry.key}
+                        data-turn-entry={entry.key}
+                    >
+                        {renderEntry(entry)}
+                    </div>
+                ))}
+            </div>
+        );
+    }
+
     return (
         <div ref={contentRef} className="relative w-full">
             {paddingTop > 0 ? <div aria-hidden="true" style={{ height: `${paddingTop}px` }} /> : null}
diff --git a/packages/ui/src/components/chat/hooks/useChatTimelineController.ts b/packages/ui/src/components/chat/hooks/useChatTimelineController.ts
index 463e227b..f677aade 100644
--- a/packages/ui/src/components/chat/hooks/useChatTimelineController.ts
+++ b/packages/ui/src/components/chat/hooks/useChatTimelineController.ts
@@ -13,6 +13,7 @@ import {
 } from '../lib/turns/windowTurns';
 import type { TurnHistorySignals } from '../lib/turns/historySignals';
 import { getMemoryLimits, type SessionHistoryMeta } from '@/stores/types/sessionTypes';
+import { isVSCodeRuntime } from '@/lib/desktop';
 
 type ViewportAnchor = { messageId: string; offsetTop: number };
 
@@ -60,7 +61,29 @@ export interface UseChatTimelineControllerResult {
 }
 
 const TURN_MODEL_CACHE_MAX = 30
+const VSCODE_TURN_MODEL_CACHE_MAX = 4
+const VSCODE_TURN_MODEL_CACHE_MAX_MESSAGES = 30
 const turnModelCache = new Map<string, { messages: ChatMessageEntry[]; model: TurnWindowModel }>()
+const getTurnModelCacheMax = () => isVSCodeRuntime() ? VSCODE_TURN_MODEL_CACHE_MAX : TURN_MODEL_CACHE_MAX
+
+const shouldCacheTurnModelMessages = (messages: ChatMessageEntry[]): boolean => {
+    if (!isVSCodeRuntime()) return true
+    return messages.length <= VSCODE_TURN_MODEL_CACHE_MAX_MESSAGES
+}
+
+const rememberTurnModel = (key: string, value: { messages: ChatMessageEntry[]; model: TurnWindowModel }) => {
+    turnModelCache.delete(key)
+    if (!shouldCacheTurnModelMessages(value.messages)) {
+        return
+    }
+    const max = getTurnModelCacheMax()
+    while (turnModelCache.size >= max) {
+        const oldest = turnModelCache.keys().next().value
+        if (typeof oldest !== 'string') break
+        turnModelCache.delete(oldest)
+    }
+    turnModelCache.set(key, value)
+}
 
 export const useChatTimelineController = ({
     sessionId,
@@ -80,6 +103,7 @@ export const useChatTimelineController = ({
         const key = sessionId ?? ""
         const cached = key ? turnModelCache.get(key) : undefined
         if (cached && cached.messages === messages) {
+            rememberTurnModel(key, cached)
             previousTurnWindowModelRef.current = cached.model
             previousMessagesRef.current = messages
             return cached.model
@@ -95,12 +119,7 @@ export const useChatTimelineController = ({
         previousMessagesRef.current = messages;
 
         if (key && messages.length > 0) {
-            // LRU-like eviction: delete oldest when at capacity
-            if (turnModelCache.size >= TURN_MODEL_CACHE_MAX) {
-                const oldest = turnModelCache.keys().next().value
-                if (oldest !== undefined) turnModelCache.delete(oldest)
-            }
-            turnModelCache.set(key, { messages, model: nextModel })
+            rememberTurnModel(key, { messages, model: nextModel })
         }
 
         return nextModel;
diff --git a/packages/ui/src/components/chat/message/MessageBody.tsx b/packages/ui/src/components/chat/message/MessageBody.tsx
index 76bdd79e..6547528b 100644
--- a/packages/ui/src/components/chat/message/MessageBody.tsx
+++ b/packages/ui/src/components/chat/message/MessageBody.tsx
@@ -42,7 +42,6 @@ import TurnActivity from '../components/TurnActivity';
 import { createProjectPlanFile } from '@/lib/openchamberConfig';
 import { resolveProjectForSessionDirectory } from '@/lib/projectResolution';
 import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
-import { useSessions } from '@/sync/sync-context';
 import { useI18n } from '@/lib/i18n';
 import { extractLoopbackUrls } from '@/lib/url';
 import { useDeviceInfo } from '@/lib/device';
@@ -986,8 +985,16 @@ const AssistantMessageBody = React.memo(({
     const suggestedPlanTitle = React.useMemo(() => suggestPlanTitleFromText(assistantPlanText), [assistantPlanText]);
 
     const openContextPreview = useUIStore((state) => state.openContextPreview);
+    const isVSCode = isVSCodeRuntime();
+    const isMiniChatSurface = chatSurfaceMode === 'mini-chat';
+    const canUseProjectPlanActions = !isVSCode && !isMiniChatSurface && !isMobile;
+    const canShowMultiRunAction = !isVSCode && !isMiniChatSurface && !isMobile;
 
     const messagePreviewUrl = React.useMemo(() => {
+        if (isVSCode || isMobile || isMiniChatSurface) {
+            return null;
+        }
+
         for (const part of assistantTextParts) {
             const text = (part as { text?: unknown }).text;
             if (typeof text !== 'string' || text.length === 0) {
@@ -1013,14 +1020,14 @@ const AssistantMessageBody = React.memo(({
             return url.includes('0.0.0.0') ? url.replace('0.0.0.0', '127.0.0.1') : url;
         }
         return null;
-    }, [assistantTextParts, toolParts]);
+    }, [assistantTextParts, isMobile, isMiniChatSurface, isVSCode, toolParts]);
 
     const createSessionFromAssistantMessage = useSessionUIStore((state) => state.createSessionFromAssistantMessage);
     const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
+    const getDirectoryForSession = useSessionUIStore((state) => state.getDirectoryForSession);
     const openMultiRunLauncherWithPrompt = useUIStore((state) => state.openMultiRunLauncherWithPrompt);
     const projects = useProjectsStore((state) => state.projects);
     const effectiveDirectory = useEffectiveDirectory();
-    const sessions = useSessions();
     const [isPlanDialogOpen, setIsPlanDialogOpen] = React.useState(false);
     const [isSavingPlan, setIsSavingPlan] = React.useState(false);
     const chatRenderMode = useUIStore((state) => state.chatRenderMode);
@@ -1028,25 +1035,22 @@ const AssistantMessageBody = React.memo(({
     const groupReasoningBlocks = useUIStore((state) => state.groupReasoningBlocks);
     const showSplitAssistantMessageActions = useUIStore((state) => state.showSplitAssistantMessageActions);
     const isSortedRenderMode = chatRenderMode === 'sorted';
-    const isMiniChatSurface = chatSurfaceMode === 'mini-chat';
     const collapsedPreviewCount = 7;
     const isLastAssistantInTurn = turnGroupingContext?.isLastAssistantInTurn ?? false;
     const hasStopFinish = messageFinish === 'stop';
 
-    const currentSession = React.useMemo(() => {
-        if (!currentSessionId) {
-            return null;
-        }
-        return sessions.find((session) => session.id === currentSessionId) ?? null;
-    }, [currentSessionId, sessions]);
-
     const availableWorktreesByProject = useSessionUIStore((state) => state.availableWorktreesByProject);
     const currentProjectRef = React.useMemo(() => {
+        if (!canUseProjectPlanActions) {
+            return null;
+        }
+
         const directory = effectiveDirectory
-            ?? (typeof currentSession?.directory === 'string' ? currentSession.directory : '');
+            ?? (currentSessionId ? getDirectoryForSession(currentSessionId) : null)
+            ?? '';
         const resolved = resolveProjectForSessionDirectory(projects, availableWorktreesByProject, directory);
         return resolved ? { id: resolved.id, path: resolved.path } : null;
-    }, [availableWorktreesByProject, currentSession?.directory, effectiveDirectory, projects]);
+    }, [availableWorktreesByProject, canUseProjectPlanActions, currentSessionId, effectiveDirectory, getDirectoryForSession, projects]);
 
     const hasTools = toolParts.length > 0;
 
@@ -1743,7 +1747,6 @@ const AssistantMessageBody = React.memo(({
     }, [messageCompletedAt, messageCreatedAt]);
 
     const footerTimestampClassName = 'text-sm text-muted-foreground/60 tabular-nums flex items-center gap-1';
-    const isVSCode = isVSCodeRuntime();
     const canOpenMessagePreview = !isMiniChatSurface && !isMobile && !isVSCode;
 
     const finalTurnActionButtons = (
@@ -1760,7 +1763,7 @@ const AssistantMessageBody = React.memo(({
                             onPointerDown={(event) => event.stopPropagation()}
                             onClick={() => {
                                 const directory = effectiveDirectory
-                                    ?? (typeof currentSession?.directory === 'string' ? currentSession.directory : null);
+                                    ?? (currentSessionId ? getDirectoryForSession(currentSessionId) : null);
                                 if (!directory) {
                                     return;
                                 }
@@ -1773,7 +1776,7 @@ const AssistantMessageBody = React.memo(({
                     <TooltipContent sideOffset={6}>{t('chat.messageBody.actions.openPreview')}</TooltipContent>
                 </Tooltip>
             ) : null}
-            {!isMiniChatSurface && !isVSCode ? (
+            {canUseProjectPlanActions ? (
                 <Tooltip>
                     <TooltipTrigger asChild>
                         <Button
@@ -1809,7 +1812,7 @@ const AssistantMessageBody = React.memo(({
                 </TooltipTrigger>
                 <TooltipContent sideOffset={6}>{t('chat.messageBody.actions.startNewSession')}</TooltipContent>
             </Tooltip> : null}
-            {!isMiniChatSurface && !isVSCode ? (
+            {canShowMultiRunAction ? (
                 <Tooltip>
                     <TooltipTrigger asChild>
                         <Button
@@ -1840,14 +1843,16 @@ const AssistantMessageBody = React.memo(({
               style={CONTAIN_LAYOUT_STYLE}
           >
               <TextSelectionMenu containerRef={messageContentRef} />
-             <SaveProjectPlanDialog
-                 open={isPlanDialogOpen}
-                 onOpenChange={setIsPlanDialogOpen}
-                 initialTitle={suggestedPlanTitle}
-                 sourceText={assistantPlanText}
-                 saving={isSavingPlan}
-                 onSave={handleConfirmSaveAsPlan}
-             />
+             {canUseProjectPlanActions ? (
+                 <SaveProjectPlanDialog
+                     open={isPlanDialogOpen}
+                     onOpenChange={setIsPlanDialogOpen}
+                     initialTitle={suggestedPlanTitle}
+                     sourceText={assistantPlanText}
+                     saving={isSavingPlan}
+                     onSave={handleConfirmSaveAsPlan}
+                 />
+             ) : null}
               <div>
                  <div
                      className="message-content-text leading-relaxed overflow-hidden text-foreground/90 [&_p:last-child]:mb-0 [&_ul:last-child]:mb-0 [&_ol:last-child]:mb-0"
diff --git a/packages/ui/src/components/chat/message/parts/ToolPart.tsx b/packages/ui/src/components/chat/message/parts/ToolPart.tsx
index c0b41e97..b1933af0 100644
--- a/packages/ui/src/components/chat/message/parts/ToolPart.tsx
+++ b/packages/ui/src/components/chat/message/parts/ToolPart.tsx
@@ -17,6 +17,7 @@ import { getSyncChildStores } from '@/sync/sync-refs';
 import { useUIStore } from '@/stores/useUIStore';
 import { useSessionActivity } from '@/hooks/useSessionActivity';
 import { opencodeClient } from '@/lib/opencode/client';
+import { isVSCodeRuntime } from '@/lib/desktop';
 import { sessionEvents } from '@/lib/sessionEvents';
 import { ScrollShadow } from '@/components/ui/ScrollShadow';
 import { Text } from '@/components/ui/text';
@@ -162,6 +163,9 @@ const TASK_TOOL_POLL_HIDDEN_MS = 6000;
 const TASK_TOOL_INITIAL_FETCH_LIMIT = 500;
 const TASK_TOOL_ACTIVE_FETCH_LIMIT = 160;
 const TASK_TOOL_IDLE_FETCH_LIMIT = 80;
+const VSCODE_TASK_TOOL_INITIAL_FETCH_LIMIT = 30;
+const VSCODE_TASK_TOOL_ACTIVE_FETCH_LIMIT = 30;
+const VSCODE_TASK_TOOL_IDLE_FETCH_LIMIT = 30;
 const TASK_TOOL_NO_CHANGE_BACKOFF_AFTER_POLLS = 3;
 const TASK_TOOL_SETTLE_GRACE_MS = 2500;
 const TASK_TOOL_FALLBACK_RETRY_MS = 3000;
@@ -222,13 +226,19 @@ const parseDiffStats = (metadata?: Record<string, unknown>): { added: number; re
         ?? getPatchText(metadata?.diff);
     if (!diffText) return null;
 
-    const lines = diffText.split('\n');
     let added = 0;
     let removed = 0;
+    let lineStart = 0;
 
-    for (const line of lines) {
+    for (let index = 0; index <= diffText.length; index += 1) {
+        if (index < diffText.length && diffText.charCodeAt(index) !== 10) {
+            continue;
+        }
+
+        const line = diffText.slice(lineStart, index);
         if (line.startsWith('+') && !line.startsWith('+++')) added++;
         if (line.startsWith('-') && !line.startsWith('---')) removed++;
+        lineStart = index + 1;
     }
 
     if (added === 0 && removed === 0) return null;
@@ -237,8 +247,13 @@ const parseDiffStats = (metadata?: Record<string, unknown>): { added: number; re
 
 const parseWriteLineCount = (input?: Record<string, unknown>): number | null => {
     if (!input?.content || typeof input.content !== 'string') return null;
-    const lines = input.content.split('\n');
-    return lines.length;
+    let lines = 1;
+    for (let index = 0; index < input.content.length; index += 1) {
+        if (input.content.charCodeAt(index) === 10) {
+            lines += 1;
+        }
+    }
+    return lines;
 };
 
 const extractFirstChangedLineFromDiff = (diffText: string): number | undefined => {
@@ -291,15 +306,13 @@ const extractFirstChangedLineFromDiff = (diffText: string): number | undefined =
 
 const getPatchText = (value: unknown): string | undefined => {
     if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
+        return /\S/.test(value) ? value : undefined;
     }
 
     if (value && typeof value === 'object') {
         const patch = (value as { patch?: unknown }).patch;
         if (typeof patch === 'string') {
-            const trimmed = patch.trim();
-            return trimmed.length > 0 ? trimmed : undefined;
+            return /\S/.test(patch) ? patch : undefined;
         }
     }
 
@@ -2073,6 +2086,24 @@ const ToolPart: React.FC<ToolPartProps> = ({
     // When true, resolveFallbackTaskSessionId widens its time window (3s → 8s).
     const [taskFallbackRetried, setTaskFallbackRetried] = React.useState(false);
 
+    const metadataTaskSummaryEntries = React.useMemo<TaskToolSummaryEntry[]>(() => {
+        if (!isTaskTool) {
+            return [];
+        }
+        const candidateSummary = (metadata as { summary?: unknown; entries?: unknown; tools?: unknown; calls?: unknown } | undefined);
+        const normalized = normalizeTaskSummaryEntries(
+            candidateSummary?.summary ?? candidateSummary?.entries ?? candidateSummary?.tools ?? candidateSummary?.calls
+        );
+
+        if (normalized.length > 0) {
+            return normalized;
+        }
+
+        return parsedTaskMetadata.summaryEntries;
+    }, [isTaskTool, metadata, parsedTaskMetadata.summaryEntries]);
+
+    const hasFinalMetadataTaskSummary = isFinalized && metadataTaskSummaryEntries.length > 0;
+
     const explicitTaskSessionId = React.useMemo<string | undefined>(() => {
         if (!isTaskTool) {
             return undefined;
@@ -2114,25 +2145,10 @@ const ToolPart: React.FC<ToolPartProps> = ({
     );
 
     const taskSessionId = explicitTaskSessionId ?? fallbackTaskSessionId;
+    const childSessionLookupId = hasFinalMetadataTaskSummary ? '' : (taskSessionId ?? '');
 
-    const childSessionMessages = useSessionMessageRecords(taskSessionId ?? '', currentDirectory);
-    useEnsureSessionMessages(taskSessionId ?? '', currentDirectory);
-
-    const metadataTaskSummaryEntries = React.useMemo<TaskToolSummaryEntry[]>(() => {
-        if (!isTaskTool) {
-            return [];
-        }
-        const candidateSummary = (metadata as { summary?: unknown; entries?: unknown; tools?: unknown; calls?: unknown } | undefined);
-        const normalized = normalizeTaskSummaryEntries(
-            candidateSummary?.summary ?? candidateSummary?.entries ?? candidateSummary?.tools ?? candidateSummary?.calls
-        );
-
-        if (normalized.length > 0) {
-            return normalized;
-        }
-
-        return parsedTaskMetadata.summaryEntries;
-    }, [isTaskTool, metadata, parsedTaskMetadata.summaryEntries]);
+    const childSessionMessages = useSessionMessageRecords(childSessionLookupId, currentDirectory);
+    useEnsureSessionMessages(childSessionLookupId, currentDirectory);
 
     const childSessionTaskSummaryEntries = React.useMemo<TaskToolSummaryEntry[]>(() => {
         if (!isTaskTool || !taskSessionId) {
@@ -2224,7 +2240,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
     ]);
 
     React.useEffect(() => {
-        if (!isTaskTool || !taskSessionId) {
+        if (hasFinalMetadataTaskSummary || !isTaskTool || !taskSessionId) {
             return;
         }
 
@@ -2293,6 +2309,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
         childSessionHasInFlightTools,
         childSessionTaskSummaryEntries.length,
         currentDirectory,
+        hasFinalMetadataTaskSummary,
         activeLatched,
         isFinalized,
         isTaskTool,
@@ -2303,7 +2320,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
     ]);
 
     React.useEffect(() => {
-        if (!isTaskTool || !taskSessionId || !taskChildPollingStopped || !taskPendingFinalFetch || taskFinalFetchDoneRef.current) {
+        if (hasFinalMetadataTaskSummary || !isTaskTool || !taskSessionId || !taskChildPollingStopped || !taskPendingFinalFetch || taskFinalFetchDoneRef.current) {
             return;
         }
 
@@ -2315,7 +2332,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
                 const scopedClient = opencodeClient.getScopedSdkClient(currentDirectory);
                 const response = await scopedClient.session.messages({
                     sessionID: capturedSessionId,
-                    limit: TASK_TOOL_INITIAL_FETCH_LIMIT,
+                    limit: isVSCodeRuntime() ? VSCODE_TASK_TOOL_INITIAL_FETCH_LIMIT : TASK_TOOL_INITIAL_FETCH_LIMIT,
                 });
 
                 if (cancelled) {
@@ -2357,6 +2374,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
         };
     }, [
         currentDirectory,
+        hasFinalMetadataTaskSummary,
         isTaskTool,
         taskChildPollingStopped,
         taskPendingFinalFetch,
@@ -2402,6 +2420,10 @@ const ToolPart: React.FC<ToolPartProps> = ({
         }
 
         const childSessionActive = childSessionActivity.phase === 'busy' || childSessionActivity.phase === 'retry';
+        if (hasFinalMetadataTaskSummary) {
+            return;
+        }
+
         const shouldPoll =
             !taskChildPollingStopped
             && (childSessionHasInFlightTools || childSessionActive || childSessionTaskSummaryEntries.length === 0);
@@ -2421,6 +2443,16 @@ const ToolPart: React.FC<ToolPartProps> = ({
         };
 
         const resolveFetchLimit = (isInitialFetch: boolean) => {
+            if (isVSCodeRuntime()) {
+                if (isInitialFetch && childSessionTaskSummaryEntries.length === 0) {
+                    return VSCODE_TASK_TOOL_INITIAL_FETCH_LIMIT;
+                }
+                if (isActive || childSessionHasInFlightTools || childSessionActive) {
+                    return VSCODE_TASK_TOOL_ACTIVE_FETCH_LIMIT;
+                }
+                return VSCODE_TASK_TOOL_IDLE_FETCH_LIMIT;
+            }
+
             if (isInitialFetch && childSessionTaskSummaryEntries.length === 0) {
                 return TASK_TOOL_INITIAL_FETCH_LIMIT;
             }
@@ -2503,6 +2535,7 @@ const ToolPart: React.FC<ToolPartProps> = ({
         childSessionHasInFlightTools,
         childSessionTaskSummaryEntries.length,
         currentDirectory,
+        hasFinalMetadataTaskSummary,
         isActive,
         isTaskTool,
         taskPendingFinalFetch,
@@ -2522,8 +2555,14 @@ const ToolPart: React.FC<ToolPartProps> = ({
         onContentChange?.('structural');
     }, [isTaskTool, onContentChange, taskSummaryEntries.length]);
 
-    const diffStats = (normalizedPartTool === 'edit' || normalizedPartTool === 'multiedit' || normalizedPartTool === 'apply_patch') ? parseDiffStats(metadata) : null;
-    const writeLineCount = normalizedPartTool === 'write' ? parseWriteLineCount(input) : null;
+    const diffStats = React.useMemo(() => {
+        return (normalizedPartTool === 'edit' || normalizedPartTool === 'multiedit' || normalizedPartTool === 'apply_patch')
+            ? parseDiffStats(metadata)
+            : null;
+    }, [metadata, normalizedPartTool]);
+    const writeLineCount = React.useMemo(() => {
+        return normalizedPartTool === 'write' ? parseWriteLineCount(input) : null;
+    }, [input, normalizedPartTool]);
     const isMultiFileApplyPatch = normalizedPartTool === 'apply_patch' && Array.isArray(metadata?.files) && (metadata?.files as []).length > 1;
     const normalizedPart = normalizedPartTool !== part.tool ? ({ ...part, tool: normalizedPartTool } as ToolPartType) : part;
     const descriptionPath = getToolDescriptionPath(normalizedPart, state, currentDirectory);
diff --git a/packages/ui/src/components/layout/VSCodeLayout.tsx b/packages/ui/src/components/layout/VSCodeLayout.tsx
index bf4f1c7f..fc3acb92 100644
--- a/packages/ui/src/components/layout/VSCodeLayout.tsx
+++ b/packages/ui/src/components/layout/VSCodeLayout.tsx
@@ -5,7 +5,7 @@ import { SessionDialogs } from '@/components/session/SessionDialogs';
 import { ChatView } from '@/components/views/ChatView';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useViewportStore } from '@/sync/viewport-store';
-import { useSessions, useDirectorySync, useSessionMessages, useSessionMessagesResolved } from '@/sync/sync-context';
+import { useDirectorySync, useSessionMessages, useSessionMessagesResolved } from '@/sync/sync-context';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { ContextUsageDisplay } from '@/components/ui/ContextUsageDisplay';
 import { McpDropdown } from '@/components/mcp/McpDropdown';
@@ -136,15 +136,30 @@ export const VSCodeLayout: React.FC = () => {
   const expandedSidebarResizeStartWidthRef = React.useRef(SESSIONS_SIDEBAR_WIDTH);
   const expandedSidebarResizePointerIdRef = React.useRef<number | null>(null);
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
-  const sessions = useSessions();
-
-  const activeSessionTitle = React.useMemo(() => {
-    if (!currentSessionId) {
-      return null;
-    }
-    return sessions.find((session) => session.id === currentSessionId)?.title || t('vscodeLayout.title.sessionFallback');
-  }, [currentSessionId, sessions, t]);
   const newSessionDraftOpen = useSessionUIStore((state) => Boolean(state.newSessionDraft?.open));
+  const activeSessionTitleValue = useDirectorySync(
+    React.useCallback((state) => {
+      if (!currentSessionId) {
+        return null;
+      }
+      return state.session.find((session) => session.id === currentSessionId)?.title || null;
+    }, [currentSessionId]),
+  );
+  const initialSessionExists = useDirectorySync(
+    React.useCallback((state) => {
+      if (!initialSessionId) {
+        return false;
+      }
+      return state.session.some((session) => session.id === initialSessionId);
+    }, [initialSessionId]),
+  );
+
+  const activeSessionTitle = currentSessionId
+    ? activeSessionTitleValue || t('vscodeLayout.title.sessionFallback')
+    : null;
+  const chatTitle = newSessionDraftOpen && !currentSessionId
+    ? t('vscodeLayout.title.newSession')
+    : activeSessionTitle || t('vscodeLayout.title.chat');
   const isSyncingMessages = useViewportStore((state) => state.isSyncing);
   const hasActiveSessionWork = useDirectorySync((state) => {
     const statuses = state.session_status;
@@ -351,13 +366,13 @@ export const VSCodeLayout: React.FC = () => {
       return;
     }
 
-    if (!sessions.some((session) => session.id === initialSessionId)) {
+    if (!initialSessionExists) {
       return;
     }
 
     hasAppliedInitialSession.current = true;
     void useSessionUIStore.getState().setCurrentSession(initialSessionId);
-  }, [connectionStatus, hasInitializedOnce, initialSessionId, openNewSessionDraft, sessions, viewMode]);
+  }, [connectionStatus, hasInitializedOnce, initialSessionExists, initialSessionId, openNewSessionDraft, viewMode]);
 
   // Track container width for responsive settings layout
   React.useEffect(() => {
@@ -433,7 +448,7 @@ export const VSCodeLayout: React.FC = () => {
         // Editor mode: just chat, no sidebar
         <div className="flex flex-col h-full">
           <VSCodeHeader
-            title={sessions.find((session) => session.id === currentSessionId)?.title || t('vscodeLayout.title.chat')}
+            title={activeSessionTitle || t('vscodeLayout.title.chat')}
             showMcp
             showContextUsage
             showRateLimits
@@ -484,9 +499,7 @@ export const VSCodeLayout: React.FC = () => {
           {/* Chat content */}
           <div className="flex-1 flex flex-col min-w-0">
             <VSCodeHeader
-              title={newSessionDraftOpen && !currentSessionId
-                ? t('vscodeLayout.title.newSession')
-                : sessions.find((session) => session.id === currentSessionId)?.title || t('vscodeLayout.title.chat')}
+              title={chatTitle}
               showMcp
               showContextUsage
               showRateLimits
@@ -503,26 +516,26 @@ export const VSCodeLayout: React.FC = () => {
         // Compact layout: drill-down between sessions list and chat
         <>
           {/* Sessions list view */}
-          <div className={cn('flex flex-col h-full', currentView !== 'sessions' && 'hidden')}>
-            <VSCodeHeader
-              title={t('vscodeLayout.title.sessions')}
-            />
-            <div className="flex-1 overflow-hidden">
-              <SessionSidebar
-                mobileVariant
-                allowReselect
-                onSessionSelected={() => setCurrentView('chat')}
-                hideDirectoryControls
-                showOnlyMainWorkspace
+          {currentView === 'sessions' ? (
+            <div className="flex flex-col h-full">
+              <VSCodeHeader
+                title={t('vscodeLayout.title.sessions')}
               />
+              <div className="flex-1 overflow-hidden">
+                <SessionSidebar
+                  mobileVariant
+                  allowReselect
+                  onSessionSelected={() => setCurrentView('chat')}
+                  hideDirectoryControls
+                  showOnlyMainWorkspace
+                />
+              </div>
             </div>
-          </div>
+          ) : null}
           {/* Chat view */}
           <div className={cn('flex flex-col h-full', currentView !== 'chat' && 'hidden')}>
             <VSCodeHeader
-              title={newSessionDraftOpen && !currentSessionId
-                ? t('vscodeLayout.title.newSession')
-                : sessions.find((session) => session.id === currentSessionId)?.title || t('vscodeLayout.title.chat')}
+              title={chatTitle}
               showBack
               onBack={handleBackToSessions}
               showMcp
@@ -580,17 +593,39 @@ const VSCodeHeader: React.FC<VSCodeHeaderProps> = ({ title, showBack, onBack, on
   }, [loadQuotaSettings]);
 
   const currentModel = getCurrentModel();
-  const latestAssistantModel = React.useMemo(() => {
+  const headerMessageSummary = React.useMemo(() => {
+    type AssistantTokens = { input: number; output: number; reasoning: number; cache: { read: number; write: number } };
+    let latestAssistantModel: ReturnType<typeof getCurrentModel> | undefined;
+    let lastTokens: AssistantTokens | undefined;
+    let lastMessageId: string | undefined;
+
     for (let i = currentSessionMessages.length - 1; i >= 0; i -= 1) {
-      const message = currentSessionMessages[i] as { role?: unknown; providerID?: unknown; modelID?: unknown };
-      if (message.role !== 'assistant') continue;
-      if (typeof message.providerID !== 'string' || typeof message.modelID !== 'string') continue;
-      const provider = providers.find((entry) => entry.id === message.providerID);
-      const model = provider?.models.find((entry) => entry.id === message.modelID);
-      if (model) return model;
+      const message = currentSessionMessages[i] as { role?: unknown; providerID?: unknown; modelID?: unknown; tokens?: AssistantTokens };
+      if (message.role !== 'assistant') {
+        continue;
+      }
+
+      if (!latestAssistantModel && typeof message.providerID === 'string' && typeof message.modelID === 'string') {
+        const provider = providers.find((entry) => entry.id === message.providerID);
+        latestAssistantModel = provider?.models.find((entry) => entry.id === message.modelID);
+      }
+
+      if (!lastTokens && message.tokens) {
+        const total = message.tokens.input + message.tokens.output + message.tokens.reasoning + (message.tokens.cache?.read ?? 0) + (message.tokens.cache?.write ?? 0);
+        if (total > 0) {
+          lastTokens = message.tokens;
+          lastMessageId = (currentSessionMessages[i] as { id?: string }).id;
+        }
+      }
+
+      if (latestAssistantModel && lastTokens) {
+        break;
+      }
     }
-    return undefined;
+
+    return { latestAssistantModel, lastTokens, lastMessageId };
   }, [currentSessionMessages, providers]);
+  const latestAssistantModel = headerMessageSummary.latestAssistantModel;
   const modelForLimits = currentModel?.limit ? currentModel : latestAssistantModel;
   const limit = modelForLimits && typeof modelForLimits.limit === 'object' && modelForLimits.limit !== null
     ? (modelForLimits.limit as Record<string, unknown>)
@@ -599,31 +634,11 @@ const VSCodeHeader: React.FC<VSCodeHeaderProps> = ({ title, showBack, onBack, on
   const outputLimit = limit && typeof limit.output === 'number' ? limit.output : 0;
 
   const contextUsage = React.useMemo<SessionContextUsage | null>(() => {
-    if (!currentSessionId || currentSessionMessages.length === 0) {
-      return null;
-    }
-
-    type AssistantTokens = { input: number; output: number; reasoning: number; cache: { read: number; write: number } };
-    let lastTokens: AssistantTokens | undefined;
-    let lastMessageId: string | undefined;
-
-    for (let i = currentSessionMessages.length - 1; i >= 0; i -= 1) {
-      const message = currentSessionMessages[i];
-      if (message.role !== 'assistant') continue;
-      const tokens = (message as { tokens?: AssistantTokens }).tokens;
-      if (!tokens) continue;
-      const total = tokens.input + tokens.output + tokens.reasoning + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0);
-      if (total > 0) {
-        lastTokens = tokens;
-        lastMessageId = message.id;
-        break;
-      }
-    }
-
-    if (!lastTokens) {
+    if (!currentSessionId || !headerMessageSummary.lastTokens) {
       return null;
     }
 
+    const lastTokens = headerMessageSummary.lastTokens;
     const totalTokens = lastTokens.input + lastTokens.output + lastTokens.reasoning + (lastTokens.cache?.read ?? 0) + (lastTokens.cache?.write ?? 0);
     const thresholdLimit = contextLimit > 0 ? contextLimit : 200000;
     const percentage = contextLimit > 0 ? Math.round((totalTokens / contextLimit) * 100) : 0;
@@ -636,9 +651,9 @@ const VSCodeHeader: React.FC<VSCodeHeaderProps> = ({ title, showBack, onBack, on
       outputLimit: outputLimit || undefined,
       normalizedOutput,
       thresholdLimit,
-      lastMessageId,
+      lastMessageId: headerMessageSummary.lastMessageId,
     };
-  }, [contextLimit, currentSessionId, currentSessionMessages, outputLimit]);
+  }, [contextLimit, currentSessionId, headerMessageSummary.lastMessageId, headerMessageSummary.lastTokens, outputLimit]);
   const [stableContextUsage, setStableContextUsage] = React.useState<SessionContextUsage | null>(null);
   const isContextUsageResolvedForSession = !currentSessionId || currentSessionMessagesResolved;
 
diff --git a/packages/ui/src/components/session/SessionSwitcherDropdown.tsx b/packages/ui/src/components/session/SessionSwitcherDropdown.tsx
index 73a887b0..d48bda25 100644
--- a/packages/ui/src/components/session/SessionSwitcherDropdown.tsx
+++ b/packages/ui/src/components/session/SessionSwitcherDropdown.tsx
@@ -11,12 +11,10 @@ import { Icon } from '@/components/icon/Icon';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useGlobalSessionStatus } from '@/sync/sync-context';
 import { useSessionUnseenCount } from '@/sync/notification-store';
-import { useSync } from '@/sync/use-sync';
-import { useDirectoryStore } from '@/stores/useDirectoryStore';
 import { useSwitcherItems, type SwitcherItem } from '@/components/session/sidebar/hooks/useSwitcherItems';
 import { useUIStore } from '@/stores/useUIStore';
 import { resolveGlobalSessionDirectory } from '@/stores/useGlobalSessionsStore';
-import { formatSessionCompactDateLabel, normalizePath, resolveSessionDiffStats } from './sidebar/utils';
+import { formatSessionCompactDateLabel, resolveSessionDiffStats } from './sidebar/utils';
 import type { SessionNode, SessionSummaryMeta } from './sidebar/types';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
@@ -72,9 +70,6 @@ type SwitcherContentProps = {
 
 function SwitcherContent({ onSelect, variant, scopeProjectId }: SwitcherContentProps): React.ReactElement {
   const items = useSwitcherItems(true, { scopeProjectId });
-  const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
-  const currentDirectory = useDirectoryStore((state) => state.currentDirectory);
-  const ensureSessionRenderable = useSync().ensureSessionRenderable;
   const openNewSessionDraft = useSessionUIStore((state) => state.openNewSessionDraft);
   const setActiveMainTab = useUIStore((state) => state.setActiveMainTab);
   const { t } = useI18n();
@@ -85,48 +80,6 @@ function SwitcherContent({ onSelect, variant, scopeProjectId }: SwitcherContentP
     openNewSessionDraft();
   }, [onSelect, openNewSessionDraft, setActiveMainTab]);
 
-  const prefetchedRef = React.useRef<Set<string>>(new Set());
-
-  React.useEffect(() => {
-    // Prefetch only sessions that live in the currently mounted sync directory.
-    // ensureSessionRenderable closes over SyncProvider's directory, so a cross-directory
-    // call would hit the wrong backend context. Switching to such a session re-mounts
-    // SyncProvider anyway, so the prefetch wouldn't have survived either way.
-    const normalizedCurrent = normalizePath(currentDirectory);
-    const queue: string[] = [];
-    for (const item of items) {
-      const id = item.node.session.id;
-      if (id === currentSessionId) continue;
-      if (prefetchedRef.current.has(id)) continue;
-      const sessionDir = normalizePath(resolveGlobalSessionDirectory(item.node.session));
-      if (!sessionDir || sessionDir !== normalizedCurrent) continue;
-      prefetchedRef.current.add(id);
-      queue.push(id);
-    }
-    if (queue.length === 0) return;
-
-    let cancelled = false;
-    const CONCURRENCY = 2;
-    const runNext = async (): Promise<void> => {
-      while (!cancelled) {
-        const id = queue.shift();
-        if (!id) return;
-        try {
-          await ensureSessionRenderable(id);
-        } catch {
-          // best-effort prefetch; ignore errors
-        }
-      }
-    };
-
-    const workers = Array.from({ length: Math.min(CONCURRENCY, queue.length) }, () => runNext());
-    void Promise.all(workers);
-
-    return () => {
-      cancelled = true;
-    };
-  }, [currentDirectory, currentSessionId, ensureSessionRenderable, items]);
-
   const [expandedParents, setExpandedParents] = React.useState<Set<string>>(new Set());
   const toggleParent = React.useCallback((sessionId: string) => {
     setExpandedParents((prev) => {
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
index 26734f36..8d00bc84 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
@@ -2,6 +2,7 @@ import React from 'react';
 import type { Session } from '@opencode-ai/sdk/v2';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { getSyncSessionMaterializationStatus } from '@/sync/sync-refs';
+import { isVSCodeRuntime } from '@/lib/desktop';
 
 const SESSION_PREFETCH_HOVER_DELAY_MS = 180;
 const SESSION_PREFETCH_SETTLE_MS = 600;
@@ -19,9 +20,10 @@ export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSes
   const sessionPrefetchTimersRef = React.useRef<Map<string, number>>(new Map());
   const sessionPrefetchQueueRef = React.useRef<string[]>([]);
   const sessionPrefetchInFlightRef = React.useRef<Set<string>>(new Set());
+  const prefetchDisabled = React.useMemo(() => isVSCodeRuntime(), []);
 
   const pumpSessionPrefetchQueue = React.useCallback(() => {
-    if (typeof window === 'undefined') {
+    if (prefetchDisabled || typeof window === 'undefined') {
       return;
     }
 
@@ -49,10 +51,10 @@ export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSes
           pumpSessionPrefetchQueue();
         });
     }
-  }, [ensureSessionRenderable]);
+  }, [ensureSessionRenderable, prefetchDisabled]);
 
   const scheduleSessionPrefetch = React.useCallback((sessionId: string | null | undefined) => {
-    if (!sessionId || sessionId === currentSessionId || typeof window === 'undefined') {
+    if (prefetchDisabled || !sessionId || sessionId === currentSessionId || typeof window === 'undefined') {
       return;
     }
 
@@ -84,12 +86,12 @@ export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSes
       pumpSessionPrefetchQueue();
     }, SESSION_PREFETCH_HOVER_DELAY_MS);
     sessionPrefetchTimersRef.current.set(sessionId, timer);
-  }, [currentSessionId, pumpSessionPrefetchQueue]);
+  }, [currentSessionId, prefetchDisabled, pumpSessionPrefetchQueue]);
 
   // Wait for the active session to finish loading before prefetching neighbors.
   // On rapid session switches the timer resets, so only the final session triggers prefetch.
   React.useEffect(() => {
-    if (!currentSessionId || sortedSessions.length === 0) {
+    if (prefetchDisabled || !currentSessionId || sortedSessions.length === 0) {
       return;
     }
     const timer = window.setTimeout(() => {
@@ -99,10 +101,10 @@ export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSes
       scheduleSessionPrefetch(sortedSessions[currentIndex + 1]?.id);
     }, SESSION_PREFETCH_SETTLE_MS);
     return () => window.clearTimeout(timer);
-  }, [currentSessionId, scheduleSessionPrefetch, sortedSessions]);
+  }, [currentSessionId, prefetchDisabled, scheduleSessionPrefetch, sortedSessions]);
 
   React.useEffect(() => {
-    if (!currentSessionId || recentSessionIds.length === 0) {
+    if (prefetchDisabled || !currentSessionId || recentSessionIds.length === 0) {
       return;
     }
     const timer = window.setTimeout(() => {
@@ -112,7 +114,7 @@ export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSes
       scheduleSessionPrefetch(recentSessionIds[currentIndex + 1]);
     }, SESSION_PREFETCH_SETTLE_MS);
     return () => window.clearTimeout(timer);
-  }, [currentSessionId, recentSessionIds, scheduleSessionPrefetch]);
+  }, [currentSessionId, prefetchDisabled, recentSessionIds, scheduleSessionPrefetch]);
 
   React.useEffect(() => {
     const prefetchTimers = sessionPrefetchTimersRef.current;
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSwitcherItems.ts b/packages/ui/src/components/session/sidebar/hooks/useSwitcherItems.ts
index 417e5f8f..c742f7cc 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSwitcherItems.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSwitcherItems.ts
@@ -4,8 +4,7 @@ import type { Session } from '@opencode-ai/sdk/v2';
 import { useGlobalSessionsStore, resolveGlobalSessionDirectory } from '@/stores/useGlobalSessionsStore';
 import { useProjectsStore } from '@/stores/useProjectsStore';
 import { useSessionPinnedStore } from '@/stores/useSessionPinnedStore';
-import { useGitAllBranches, useGitStore } from '@/stores/useGitStore';
-import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import { useGitAllBranches } from '@/stores/useGitStore';
 import type { SessionNode } from '../types';
 import { compareSessionsByPinnedAndTime, isPathWithinProject } from '../utils';
 
@@ -46,8 +45,6 @@ export const useSwitcherItems = (enabled: boolean, options: SwitcherItemsOptions
   const projects = useProjectsStore((state) => state.projects);
   const pinnedSessionIds = useSessionPinnedStore((state) => state.ids);
   const branchesByDirectory = useGitAllBranches();
-  const ensureGitStatus = useGitStore((state) => state.ensureStatus);
-  const { git: gitApi } = useRuntimeAPIs();
 
   const normalizedProjects = React.useMemo(
     () => projects
@@ -123,16 +120,5 @@ export const useSwitcherItems = (enabled: boolean, options: SwitcherItemsOptions
     });
   }, [activeSessions, branchesByDirectory, enabled, findProjectForDirectory, pinnedSessionIds, scopeProjectId]);
 
-  React.useEffect(() => {
-    if (!enabled || !gitApi) return;
-    const seen = new Set<string>();
-    for (const item of items) {
-      const dir = item.groupDirectory;
-      if (!dir || seen.has(dir)) continue;
-      seen.add(dir);
-      void ensureGitStatus(dir, gitApi).catch(() => {});
-    }
-  }, [enabled, ensureGitStatus, gitApi, items]);
-
   return items;
 };
diff --git a/packages/ui/src/hooks/usePlanDetection.ts b/packages/ui/src/hooks/usePlanDetection.ts
index 109fc950..c230865e 100644
--- a/packages/ui/src/hooks/usePlanDetection.ts
+++ b/packages/ui/src/hooks/usePlanDetection.ts
@@ -1,9 +1,10 @@
 import React from 'react';
-import { useSessionMessages } from '@/sync/sync-context';
-import { getSyncParts } from '@/sync/sync-refs';
+import type { Message, Part } from '@opencode-ai/sdk/v2';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useFeatureFlagsStore } from '@/stores/useFeatureFlagsStore';
 
+type SessionMessageRecord = { info: Message; parts: Part[] };
+
 /**
  * Watches session messages for plan creation and marks sessions as plan-available.
  * 
@@ -13,11 +14,10 @@ import { useFeatureFlagsStore } from '@/stores/useFeatureFlagsStore';
  * 
  * The Header component subscribes to sessionPlanAvailable map to show/hide the Plan tab.
  */
-export const usePlanDetection = (sessionId: string, directory?: string) => {
+export const usePlanDetection = (sessionId: string, messageRecords: SessionMessageRecord[]) => {
   const planModeEnabled = useFeatureFlagsStore((state) => state.planModeEnabled);
   const markSessionPlanAvailable = useSessionUIStore((state) => state.markSessionPlanAvailable);
   const isSessionPlanAvailable = useSessionUIStore((state) => state.isSessionPlanAvailable);
-  const messages = useSessionMessages(sessionId, directory);
 
   React.useEffect(() => {
     // Early exit if plan mode is disabled - don't parse messages
@@ -27,15 +27,16 @@ export const usePlanDetection = (sessionId: string, directory?: string) => {
     // Already marked as available - no need to check again
     if (isSessionPlanAvailable(sessionId)) return;
 
-    // Scan messages for plan references
-    for (const message of messages) {
+    // Scan the already-materialized message records used by ChatContainer so
+    // plan detection does not add a second active-session message subscription.
+    for (const message of messageRecords) {
       // Only check assistant messages for plan references
-      if (message.role !== 'assistant') continue;
+      if (message.info.role !== 'assistant') continue;
 
-      const parts = getSyncParts(message.id, directory);
-      for (const part of parts) {
-        if (part.type !== 'text') continue;
-        const text = (part as { text?: string }).text || '';
+      for (const part of message.parts) {
+        const record = part as { type?: string; text?: string };
+        if (record.type !== 'text') continue;
+        const text = record.text || '';
 
         // Check for plan file reference in synthetic messages
         if (text.includes('The plan at ') || text.includes('User has requested to enter plan mode')) {
@@ -44,5 +45,5 @@ export const usePlanDetection = (sessionId: string, directory?: string) => {
         }
       }
     }
-  }, [planModeEnabled, sessionId, directory, messages, markSessionPlanAvailable, isSessionPlanAvailable]);
+  }, [planModeEnabled, sessionId, messageRecords, markSessionPlanAvailable, isSessionPlanAvailable]);
 };
diff --git a/packages/ui/src/stores/useUIStore.ts b/packages/ui/src/stores/useUIStore.ts
index b16465f5..54f4a976 100644
--- a/packages/ui/src/stores/useUIStore.ts
+++ b/packages/ui/src/stores/useUIStore.ts
@@ -1306,10 +1306,16 @@ export const useUIStore = create<UIStore>()(
         },
 
         setSessionSwitcherOpen: (open) => {
+          if (get().isSessionSwitcherOpen === open) {
+            return;
+          }
           set({ isSessionSwitcherOpen: open });
         },
 
         setSessionDropdownOpen: (open) => {
+          if (get().isSessionDropdownOpen === open) {
+            return;
+          }
           set({ isSessionDropdownOpen: open });
         },
 
diff --git a/packages/ui/src/sync/session-prefetch-cache.ts b/packages/ui/src/sync/session-prefetch-cache.ts
index 16e70122..24335afe 100644
--- a/packages/ui/src/sync/session-prefetch-cache.ts
+++ b/packages/ui/src/sync/session-prefetch-cache.ts
@@ -21,9 +21,16 @@ const compositeKey = (directory: string, sessionID: string) =>
 const cache = new Map<string, Meta>()
 const inflight = new Map<string, Promise<Meta | undefined>>()
 const rev = new Map<string, number>()
+const listeners = new Map<string, Set<() => void>>()
 
 const version = (id: string) => rev.get(id) ?? 0
 
+const notify = (id: string) => {
+  const callbacks = listeners.get(id)
+  if (!callbacks) return
+  callbacks.forEach((callback) => callback())
+}
+
 /** Check if a prefetch/sync can be skipped (recently fetched). */
 export function shouldSkipSessionPrefetch(input: {
   hasMessages: boolean
@@ -46,6 +53,21 @@ export function getSessionPrefetch(directory: string, sessionID: string): Meta |
   return cache.get(compositeKey(directory, sessionID))
 }
 
+export function subscribeSessionPrefetch(directory: string, sessionID: string, callback: () => void) {
+  if (!sessionID) return () => undefined
+  const id = compositeKey(directory, sessionID)
+  let callbacks = listeners.get(id)
+  if (!callbacks) {
+    callbacks = new Set()
+    listeners.set(id, callbacks)
+  }
+  callbacks.add(callback)
+  return () => {
+    callbacks?.delete(callback)
+    if (callbacks?.size === 0) listeners.delete(id)
+  }
+}
+
 export function getSessionPrefetchPromise(directory: string, sessionID: string) {
   return inflight.get(compositeKey(directory, sessionID))
 }
@@ -82,12 +104,14 @@ export function setSessionPrefetch(input: {
   complete: boolean
   at?: number
 }) {
-  cache.set(compositeKey(input.directory, input.sessionID), {
+  const id = compositeKey(input.directory, input.sessionID)
+  cache.set(id, {
     limit: input.limit,
     cursor: input.cursor,
     complete: input.complete,
     at: input.at ?? Date.now(),
   })
+  notify(id)
 }
 
 /** Invalidate cache for specific sessions (e.g. after eviction). */
@@ -98,6 +122,7 @@ export function clearSessionPrefetch(directory: string, sessionIDs: Iterable<str
     rev.set(id, version(id) + 1)
     cache.delete(id)
     inflight.delete(id)
+    notify(id)
   }
 }
 
@@ -110,5 +135,6 @@ export function clearSessionPrefetchDirectory(directory: string) {
     rev.set(id, version(id) + 1)
     cache.delete(id)
     inflight.delete(id)
+    notify(id)
   }
 }
diff --git a/packages/ui/src/sync/session-ui-store.ts b/packages/ui/src/sync/session-ui-store.ts
index 70d6236a..a58197c1 100644
--- a/packages/ui/src/sync/session-ui-store.ts
+++ b/packages/ui/src/sync/session-ui-store.ts
@@ -1208,6 +1208,9 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
   // ---------------------------------------------------------------------------
   markSessionPlanAvailable: (sessionId) => {
     set((state) => {
+      if (state.sessionPlanAvailable.get(sessionId) === true) {
+        return state
+      }
       const next = new Map(state.sessionPlanAvailable)
       next.set(sessionId, true)
       return { sessionPlanAvailable: next }
diff --git a/packages/ui/src/sync/sync-context.tsx b/packages/ui/src/sync/sync-context.tsx
index 8f69e3f6..ebf77aab 100644
--- a/packages/ui/src/sync/sync-context.tsx
+++ b/packages/ui/src/sync/sync-context.tsx
@@ -38,6 +38,7 @@ import type { PermissionRequest } from "@/types/permission"
 import type { QuestionRequest } from "@/types/question"
 import * as sessionActions from "./session-actions"
 import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
+import { setSessionPrefetch } from "./session-prefetch-cache"
 
 // ---------------------------------------------------------------------------
 // Context
@@ -195,6 +196,14 @@ async function materializeSessionFromServer(
   )
   const records = (result.data ?? []).filter((record: { info?: { id?: string } }) => !!record?.info?.id)
   if (records.length === 0) return
+  const cursor = result.response?.headers?.get?.("x-next-cursor") ?? undefined
+  setSessionPrefetch({
+    directory,
+    sessionID,
+    limit: records.length,
+    cursor,
+    complete: !cursor,
+  })
 
   store.setState((state: DirectoryStore) => {
     const materialized = materializeSessionSnapshots(
@@ -937,6 +946,14 @@ async function resyncDirectoryAfterReconnect(
     const session = sessionResponse?.data
     const records = messageResponse?.data
     if (!session || !records) return
+    const cursor = messageResponse.response?.headers?.get?.("x-next-cursor") ?? undefined
+    setSessionPrefetch({
+      directory,
+      sessionID: sessionId,
+      limit: records.length,
+      cursor,
+      complete: !cursor,
+    })
 
     const nextSession = stripSessionDiffSnapshots(session)
     const nextMessages = records
@@ -1562,10 +1579,16 @@ export function useSessionRevertMessageID(sessionID: string, directory?: string)
 
 /** Get session messages for a specific session */
 export function useSessionMessages(sessionID: string, directory?: string) {
-  return useDirectorySync(
-    useCallback((state: State) => state.message[sessionID] ?? EMPTY_MESSAGES, [sessionID]),
-    directory,
-  )
+  const store = useDirectoryStore(directory)
+  const getSnapshot = useCallback(() => {
+    if (!sessionID) return EMPTY_MESSAGES
+    return store.getState().message[sessionID] ?? EMPTY_MESSAGES
+  }, [sessionID, store])
+  const subscribe = useCallback((notify: () => void) => {
+    if (!sessionID) return () => undefined
+    return store.subscribe(notify)
+  }, [sessionID, store])
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
 
 /**
@@ -1602,18 +1625,30 @@ export function useSessionParts(messageID: string, directory?: string) {
 
 /** Get status for a specific session */
 export function useSessionStatus(sessionID: string, directory?: string) {
-  return useDirectorySync(
-    useCallback((state: State) => state.session_status?.[sessionID], [sessionID]),
-    directory,
-  )
+  const store = useDirectoryStore(directory)
+  const getSnapshot = useCallback(() => {
+    if (!sessionID) return undefined
+    return store.getState().session_status?.[sessionID]
+  }, [sessionID, store])
+  const subscribe = useCallback((notify: () => void) => {
+    if (!sessionID) return () => undefined
+    return store.subscribe(notify)
+  }, [sessionID, store])
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
 
 /** Get permissions for a specific session */
 export function useSessionPermissions(sessionID: string, directory?: string) {
-  return useDirectorySync(
-    useCallback((state: State) => state.permission[sessionID] ?? EMPTY_PERMISSION_REQUESTS, [sessionID]),
-    directory,
-  )
+  const store = useDirectoryStore(directory)
+  const getSnapshot = useCallback(() => {
+    if (!sessionID) return EMPTY_PERMISSION_REQUESTS
+    return store.getState().permission[sessionID] ?? EMPTY_PERMISSION_REQUESTS
+  }, [sessionID, store])
+  const subscribe = useCallback((notify: () => void) => {
+    if (!sessionID) return () => undefined
+    return store.subscribe(notify)
+  }, [sessionID, store])
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
 
 /** Get questions for a specific session */
@@ -1812,16 +1847,121 @@ const getFirstTextFromParts = (parts: Part[]): string => {
 }
 
 type SessionMessageRecord = { info: Message; parts: Part[] }
+const EMPTY_SESSION_MESSAGE_RECORDS: SessionMessageRecord[] = []
 
 type SessionMessageRecordsSnapshot = {
   sessionID: string
   sourceMessages: Message[]
   visibleMessages: Message[]
   revertMessageID?: string
+  suspendPartUpdates: boolean
   list: SessionMessageRecord[]
   byId: Map<string, SessionMessageRecord>
 }
 
+const SESSION_MESSAGE_RECORDS_CACHE_MAX = 40
+const VSCODE_SESSION_MESSAGE_RECORDS_CACHE_MAX = 4
+const VSCODE_SESSION_MESSAGE_RECORDS_CACHE_MAX_MESSAGES = 30
+const sessionMessageRecordsCache = new WeakMap<StoreApi<DirectoryStore>, Map<string, SessionMessageRecordsSnapshot>>()
+
+const getSessionMessageRecordsCacheKey = (sessionID: string, suspendPartUpdates: boolean): string => (
+  `${sessionID}\u0000${suspendPartUpdates ? 1 : 0}`
+)
+
+const getSessionMessageRecordsCache = (store: StoreApi<DirectoryStore>): Map<string, SessionMessageRecordsSnapshot> => {
+  let cache = sessionMessageRecordsCache.get(store)
+  if (!cache) {
+    cache = new Map()
+    sessionMessageRecordsCache.set(store, cache)
+  }
+  return cache
+}
+
+const readCachedSessionMessageRecordsSnapshot = (
+  store: StoreApi<DirectoryStore>,
+  sessionID: string,
+  suspendPartUpdates: boolean,
+): SessionMessageRecordsSnapshot | undefined => {
+  const cache = sessionMessageRecordsCache.get(store)
+  if (!cache) return undefined
+  const key = getSessionMessageRecordsCacheKey(sessionID, suspendPartUpdates)
+  const cached = cache.get(key)
+  if (!cached) return undefined
+  cache.delete(key)
+  cache.set(key, cached)
+  return cached
+}
+
+const rememberSessionMessageRecordsSnapshot = (
+  store: StoreApi<DirectoryStore>,
+  snapshot: SessionMessageRecordsSnapshot,
+): void => {
+  if (!snapshot.sessionID) return
+  const cache = getSessionMessageRecordsCache(store)
+  const key = getSessionMessageRecordsCacheKey(snapshot.sessionID, snapshot.suspendPartUpdates)
+  if (isVSCodeRuntime() && snapshot.list.length > VSCODE_SESSION_MESSAGE_RECORDS_CACHE_MAX_MESSAGES) {
+    cache.delete(key)
+    return
+  }
+  cache.delete(key)
+  cache.set(key, snapshot)
+  const max = isVSCodeRuntime() ? VSCODE_SESSION_MESSAGE_RECORDS_CACHE_MAX : SESSION_MESSAGE_RECORDS_CACHE_MAX
+  while (cache.size > max) {
+    const oldest = cache.keys().next().value
+    if (typeof oldest !== "string") break
+    cache.delete(oldest)
+  }
+}
+
+export function dropCachedSessionMessageRecordsSnapshots(
+  store: StoreApi<DirectoryStore>,
+  sessionIDs: Iterable<string>,
+): void {
+  const cache = sessionMessageRecordsCache.get(store)
+  if (!cache) return
+  for (const sessionID of sessionIDs) {
+    if (!sessionID) continue
+    cache.delete(getSessionMessageRecordsCacheKey(sessionID, false))
+    cache.delete(getSessionMessageRecordsCacheKey(sessionID, true))
+  }
+}
+
+const snapshotPartsMatchState = (snapshot: SessionMessageRecordsSnapshot, state: State): boolean => {
+  if (snapshot.suspendPartUpdates) {
+    return true
+  }
+
+  for (const record of snapshot.list) {
+    if ((state.part[record.info.id] ?? EMPTY_PARTS) !== record.parts) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const getReusableSessionMessageRecordsSnapshot = (
+  store: StoreApi<DirectoryStore>,
+  state: State,
+  sessionID: string,
+  suspendPartUpdates: boolean,
+): SessionMessageRecordsSnapshot | undefined => {
+  const cached = readCachedSessionMessageRecordsSnapshot(store, sessionID, suspendPartUpdates)
+  if (!cached) return undefined
+  const sourceMessages = state.message[sessionID] ?? EMPTY_MESSAGES
+  const session = state.session.find((candidate) => candidate.id === sessionID)
+  const revertMessageID = (session as { revert?: { messageID?: string } } | undefined)?.revert?.messageID
+  if (
+    cached.sourceMessages === sourceMessages
+    && cached.revertMessageID === revertMessageID
+    && cached.suspendPartUpdates === suspendPartUpdates
+    && snapshotPartsMatchState(cached, state)
+  ) {
+    return cached
+  }
+  return undefined
+}
+
 function getVisibleMessagesForSession(state: State, sessionID: string, previous?: SessionMessageRecordsSnapshot): {
   sourceMessages: Message[]
   visibleMessages: Message[]
@@ -1886,6 +2026,7 @@ export function buildSessionMessageRecordsSnapshot(
     sourceMessages,
     visibleMessages,
     revertMessageID,
+    suspendPartUpdates,
     list: nextList,
     byId: nextById,
   }
@@ -1949,22 +2090,45 @@ export function useSessionMessageRecords(
     sourceMessages: EMPTY_MESSAGES,
     visibleMessages: EMPTY_MESSAGES,
     revertMessageID: undefined,
+    suspendPartUpdates: Boolean(options?.suspendPartUpdates),
     list: [],
     byId: new Map(),
   })
 
   const getSnapshot = useCallback(() => {
+    if (!sessionID) {
+      return EMPTY_SESSION_MESSAGE_RECORDS
+    }
+
+    const state = store.getState()
+    const suspendPartUpdates = Boolean(options?.suspendPartUpdates)
+    const reusableSnapshot = getReusableSessionMessageRecordsSnapshot(store, state, sessionID, suspendPartUpdates)
+    if (reusableSnapshot) {
+      snapshotRef.current = reusableSnapshot
+      return reusableSnapshot.list
+    }
+
+    const previousSnapshot = snapshotRef.current.sessionID === sessionID
+      ? snapshotRef.current
+      : readCachedSessionMessageRecordsSnapshot(store, sessionID, suspendPartUpdates)
+
     const nextSnapshot = buildSessionMessageRecordsSnapshot(
-      store.getState(),
+      state,
       sessionID,
-      snapshotRef.current.sessionID === sessionID ? snapshotRef.current : undefined,
-      Boolean(options?.suspendPartUpdates),
+      previousSnapshot,
+      suspendPartUpdates,
     )
     snapshotRef.current = nextSnapshot
+    rememberSessionMessageRecordsSnapshot(store, nextSnapshot)
     return nextSnapshot.list
   }, [options?.suspendPartUpdates, sessionID, store])
 
-  return React.useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot)
+  const subscribe = useCallback((notify: () => void) => {
+    if (!sessionID) return () => undefined
+    return store.subscribe(notify)
+  }, [sessionID, store])
+
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
 
 /**
diff --git a/packages/ui/src/sync/use-sync.ts b/packages/ui/src/sync/use-sync.ts
index fd8b9f41..cc1615a0 100644
--- a/packages/ui/src/sync/use-sync.ts
+++ b/packages/ui/src/sync/use-sync.ts
@@ -2,15 +2,16 @@ import { useCallback, useRef, useMemo } from "react"
 import type { Message, Part } from "@opencode-ai/sdk/v2/client"
 import { Binary } from "./binary"
 import { retry } from "./retry"
-import { SESSION_CACHE_LIMIT } from "./types"
+import { SESSION_CACHE_LIMIT, type State } from "./types"
 import { pickSessionCacheEvictions } from "./session-cache"
 import {
   mergeOptimisticPage,
   type OptimisticItem,
 } from "./optimistic"
-import { useDirectoryStore, useSyncSDK, useSyncDirectory, useChildStoreManager } from "./sync-context"
+import { dropCachedSessionMessageRecordsSnapshots, useDirectoryStore, useSyncSDK, useSyncDirectory, useChildStoreManager } from "./sync-context"
 import { dropSessionCaches, getProtectedSessionCacheIds } from "./session-cache"
 import { stripMessageDiffSnapshots } from "./sanitize"
+import { isVSCodeRuntime } from "@/lib/desktop"
 import {
   shouldSkipSessionPrefetch,
   getSessionPrefetch,
@@ -20,14 +21,60 @@ import {
 import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
-const MESSAGE_PAGE_SIZE = 200
+const MESSAGE_PAGE_SIZE = 150
+const VSCODE_MESSAGE_PAGE_SIZE = 30
+const VSCODE_INITIAL_PAGE_EXPANSION_LIMITS = [50, 80, 120] as const
 const MAX_SEEN_DIRS = 30
+const VSCODE_SESSION_CACHE_LIMIT = 4
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 
+// Shared across useSync() instances so cache eviction is based on app-level
+// session recency, not whichever component happened to call sync first.
+const seenByDirectory = new Map<string, Set<string>>()
+
+type SyncMeta = {
+  limit: number
+  cursor: string | undefined
+  complete: boolean
+  loading: boolean
+}
+
+const getEffectiveSessionCacheLimit = () => isVSCodeRuntime() ? VSCODE_SESSION_CACHE_LIMIT : SESSION_CACHE_LIMIT
+const getEffectiveMessagePageSize = () => isVSCodeRuntime() ? VSCODE_MESSAGE_PAGE_SIZE : MESSAGE_PAGE_SIZE
+const getVSCodeInitialPageExpansionMax = () => VSCODE_INITIAL_PAGE_EXPANSION_LIMITS[VSCODE_INITIAL_PAGE_EXPANSION_LIMITS.length - 1]
+const getDefaultMeta = (): SyncMeta => ({ limit: getEffectiveMessagePageSize(), cursor: undefined, complete: false, loading: false })
+
+function getPrefetchMeta(directory: string, sessionID: string): SyncMeta | undefined {
+  const info = getSessionPrefetch(directory, sessionID)
+  if (!info) return undefined
+  return {
+    limit: info.limit,
+    cursor: info.cursor,
+    complete: info.complete,
+    loading: false,
+  }
+}
+
 function sortParts(parts: Part[]) {
   return parts.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id))
 }
 
+function isHeavyVSCodeSessionCache(state: Pick<State, "message" | "part">, sessionID: string): boolean {
+  const messages = state.message[sessionID]
+  if (!messages || messages.length === 0) return false
+  return messages.length > VSCODE_MESSAGE_PAGE_SIZE
+}
+
+function isUserMessage(message: Message): boolean {
+  const info = message as Message & { clientRole?: unknown; role?: unknown }
+  const role = typeof info.clientRole === "string" ? info.clientRole : info.role
+  return role === "user"
+}
+
+function hasUserMessage(messages: Message[] | undefined): boolean {
+  return Boolean(messages?.some(isUserMessage))
+}
+
 // ---------------------------------------------------------------------------
 // useSync — message loading, pagination, optimistic updates
 // Message loading, pagination, optimistic updates
@@ -42,13 +89,7 @@ export function useSync() {
   // Refs for mutable tracking (no re-renders)
   const inflight = useRef(new Map<string, Promise<void>>())
   const optimistic = useRef(new Map<string, Map<string, OptimisticItem>>())
-  const seen = useRef(new Map<string, Set<string>>())
-  const meta = useRef(new Map<string, {
-    limit: number
-    cursor: string | undefined
-    complete: boolean
-    loading: boolean
-  }>())
+  const meta = useRef(new Map<string, SyncMeta>())
 
   const keyFor = useCallback(
     (sessionID: string) => `${directory}\n${sessionID}`,
@@ -58,18 +99,18 @@ export function useSync() {
   const getMetaFor = useCallback(
     (sessionID: string) => {
       const key = keyFor(sessionID)
-      return meta.current.get(key) ?? { limit: MESSAGE_PAGE_SIZE, cursor: undefined, complete: false, loading: false }
+      return meta.current.get(key) ?? getPrefetchMeta(directory, sessionID) ?? getDefaultMeta()
     },
-    [keyFor],
+    [directory, keyFor],
   )
 
   const setMetaFor = useCallback(
     (sessionID: string, patch: Partial<{ limit: number; cursor: string | undefined; complete: boolean; loading: boolean }>) => {
       const key = keyFor(sessionID)
-      const current = meta.current.get(key) ?? { limit: MESSAGE_PAGE_SIZE, cursor: undefined, complete: false, loading: false }
+      const current = meta.current.get(key) ?? getPrefetchMeta(directory, sessionID) ?? getDefaultMeta()
       meta.current.set(key, { ...current, ...patch })
     },
-    [keyFor],
+    [directory, keyFor],
   )
 
   // Session cache eviction — two levels of LRU:
@@ -93,6 +134,7 @@ export function useSync() {
         question: { ...current.question },
       }
       dropSessionCaches(draft, sessionIDs)
+      dropCachedSessionMessageRecordsSnapshots(dirStore, sessionIDs)
       dirStore.setState(draft)
 
       // Clear meta + optimistic + prefetch cache for evicted sessions
@@ -109,22 +151,22 @@ export function useSync() {
   // When seen directories exceed MAX_SEEN_DIRS, evict the oldest directory's caches.
   // LRU reorder on access. Evicts oldest directory when exceeding MAX_SEEN_DIRS.
   const seenFor = useCallback(() => {
-    const existing = seen.current.get(directory)
+    const existing = seenByDirectory.get(directory)
     if (existing) {
       // LRU reorder: delete + re-insert moves to end (most recent)
-      seen.current.delete(directory)
-      seen.current.set(directory, existing)
+      seenByDirectory.delete(directory)
+      seenByDirectory.set(directory, existing)
       return existing
     }
     const created = new Set<string>()
-    seen.current.set(directory, created)
+    seenByDirectory.set(directory, created)
 
     // Evict oldest directories if over limit
-    while (seen.current.size > MAX_SEEN_DIRS) {
-      const first = seen.current.keys().next().value
+    while (seenByDirectory.size > MAX_SEEN_DIRS) {
+      const first = seenByDirectory.keys().next().value
       if (!first) break
-      const staleSessionIds = [...(seen.current.get(first) ?? [])]
-      seen.current.delete(first)
+      const staleSessionIds = [...(seenByDirectory.get(first) ?? [])]
+      seenByDirectory.delete(first)
       evict(first, staleSessionIds)
     }
 
@@ -136,13 +178,34 @@ export function useSync() {
     (sessionID: string) => {
       const s = seenFor()
       const protectedIds = getProtectedSessionCacheIds(store.getState())
+      const cacheLimit = getEffectiveSessionCacheLimit()
       const stale = pickSessionCacheEvictions({
         seen: s,
         keep: sessionID,
-        limit: SESSION_CACHE_LIMIT,
+        limit: cacheLimit,
         preserve: protectedIds,
       })
       evict(directory, stale)
+
+      if (isVSCodeRuntime()) {
+        const state = store.getState()
+        const keep = new Set([sessionID, ...s, ...protectedIds])
+        const prefetched = Object.keys(state.message).filter((id) => !keep.has(id))
+        evict(directory, prefetched)
+
+        // One very large inactive session can create memory/GC pressure that
+        // makes later small-session switches feel slow. Keep it while active,
+        // but do not retain it as a warm cache in the VSCode webview.
+        const afterPrefetchEviction = prefetched.length > 0 ? store.getState() : state
+        const heavyInactive = Object.keys(afterPrefetchEviction.message).filter((id) => {
+          if (id === sessionID || protectedIds.has(id)) return false
+          return isHeavyVSCodeSessionCache(afterPrefetchEviction, id)
+        })
+        if (heavyInactive.length > 0) {
+          for (const id of heavyInactive) s.delete(id)
+          evict(directory, heavyInactive)
+        }
+      }
     },
     [directory, seenFor, evict, store],
   )
@@ -213,8 +276,21 @@ export function useSync() {
       setMetaFor(sessionID, { loading: true })
 
       try {
-        const limit = m.limit
-        const page = await fetchMessages(sessionID, limit, options?.before)
+        const limit = options?.before ? getEffectiveMessagePageSize() : m.limit
+        let page = await fetchMessages(sessionID, limit, options?.before)
+
+        // VSCode keeps the initial page small for switch performance. Some
+        // sessions have a very large final turn, so the latest 30 records can
+        // contain only assistant/tool records and no user boundary. That makes
+        // turn projection render an empty chat until the user manually loads
+        // older messages. Expand only this initial tail fetch, with a hard cap.
+        if (!options?.before && isVSCodeRuntime() && !page.complete && !hasUserMessage(page.session)) {
+          for (const nextLimit of VSCODE_INITIAL_PAGE_EXPANSION_LIMITS) {
+            if (nextLimit <= limit) continue
+            page = await fetchMessages(sessionID, nextLimit)
+            if (page.complete || hasUserMessage(page.session)) break
+          }
+        }
 
         // Merge optimistic items
         const items = getOptimistic(sessionID)
@@ -234,13 +310,13 @@ export function useSync() {
           { skipPartTypes: SKIP_PARTS, mode: options?.mode === "prepend" ? "prepend" : "merge" },
         )
 
-        store.setState({ message: materialized.message, part: materialized.part })
         setMetaFor(sessionID, {
           limit: materialized.messages.length,
           cursor: merged.cursor,
           complete: merged.complete,
           loading: false,
         })
+        store.setState({ message: materialized.message, part: materialized.part })
         setSessionPrefetch({
           directory,
           sessionID,
@@ -269,16 +345,32 @@ export function useSync() {
       const m = getMetaFor(sessionID)
       const materialization = getSessionMaterializationStatus(current, sessionID)
       const cached = materialization.hasMessages && materialization.renderable && m.limit > 0
+      const prefetchInfo = !force ? getSessionPrefetch(directory, sessionID) : undefined
+      const knownCachedLimit = Math.max(m.limit, prefetchInfo?.limit ?? 0)
+      const needsVSCodeInitialTurnBoundary = isVSCodeRuntime()
+        && cached
+        && !hasUserMessage(current.message[sessionID])
+        && knownCachedLimit < getVSCodeInitialPageExpansionMax()
+        && !m.complete
+        && prefetchInfo?.complete !== true
+        && Boolean(m.cursor ?? prefetchInfo?.cursor)
+      if (needsVSCodeInitialTurnBoundary && prefetchInfo && prefetchInfo.limit > m.limit) {
+        setMetaFor(sessionID, {
+          limit: prefetchInfo.limit,
+          cursor: prefetchInfo.cursor,
+          complete: prefetchInfo.complete,
+        })
+      }
+      const cachedReady = cached && !needsVSCodeInitialTurnBoundary
       const hasSession = Binary.search(current.session, sessionID, (s) => s.id).found
-      if (cached && hasSession && !force) return
+      if (cachedReady && hasSession && !force) return
 
       // Skip if recently fetched (TTL)
-      if (!force) {
-        const prefetchInfo = getSessionPrefetch(directory, sessionID)
+      if (!force && !needsVSCodeInitialTurnBoundary) {
         if (shouldSkipSessionPrefetch({
-          hasMessages: cached,
+          hasMessages: cachedReady,
           info: prefetchInfo,
-          pageSize: MESSAGE_PAGE_SIZE,
+          pageSize: getEffectiveMessagePageSize(),
         })) return
       }
 
@@ -304,7 +396,7 @@ export function useSync() {
         }
 
         // Load messages if needed
-        if (!cached || force) {
+        if (!cachedReady || force) {
           await loadMessages(sessionID)
         }
       })()
@@ -313,7 +405,7 @@ export function useSync() {
       promise.finally(() => inflight.current.delete(key))
       return promise
     },
-    [store, sdk, keyFor, touch, getMetaFor, loadMessages, directory],
+    [store, sdk, keyFor, touch, getMetaFor, setMetaFor, loadMessages, directory],
   )
 
   // Load more (pagination)
diff --git a/packages/vscode/src/bridge-proxy-runtime.ts b/packages/vscode/src/bridge-proxy-runtime.ts
index 6de2808a..65fb05cf 100644
--- a/packages/vscode/src/bridge-proxy-runtime.ts
+++ b/packages/vscode/src/bridge-proxy-runtime.ts
@@ -23,7 +23,23 @@ type ApiSessionMessageRequestPayload = {
 type ApiProxyResponsePayload = {
   status: number;
   headers: Record<string, string>;
-  bodyBase64: string;
+  bodyBase64?: string;
+  bodyText?: string;
+};
+
+const shouldReturnTextBody = (headers: Headers): boolean => {
+  const contentType = headers.get('content-type')?.toLowerCase() || '';
+  return contentType.startsWith('application/json')
+    || contentType.startsWith('text/')
+    || contentType.includes('+json');
+};
+
+const collectProxyResponseHeaders = (headers: Headers, deps: Pick<ProxyRuntimeDeps, 'collectHeaders'>): Record<string, string> => {
+  const result = deps.collectHeaders(headers);
+  delete result['content-length'];
+  delete result['content-encoding'];
+  delete result['transfer-encoding'];
+  return result;
 };
 
 type ProxyRuntimeDeps = {
@@ -88,10 +104,22 @@ export async function handleProxyBridgeMessage(
               : undefined,
         });
 
+        const responseHeaders = collectProxyResponseHeaders(response.headers, deps);
+        if (shouldReturnTextBody(response.headers)) {
+          const bodyText = await response.text();
+          const data: ApiProxyResponsePayload = {
+            status: response.status,
+            headers: responseHeaders,
+            bodyText,
+          };
+
+          return { id, type, success: true, data };
+        }
+
         const arrayBuffer = await response.arrayBuffer();
         const data: ApiProxyResponsePayload = {
           status: response.status,
-          headers: deps.collectHeaders(response.headers),
+          headers: responseHeaders,
           bodyBase64: Buffer.from(arrayBuffer).toString('base64'),
         };
 
@@ -103,7 +131,7 @@ export async function handleProxyBridgeMessage(
         const data: ApiProxyResponsePayload = {
           status: 502,
           headers: { 'content-type': 'application/json' },
-          bodyBase64: deps.base64EncodeUtf8(body),
+          bodyText: body,
         };
         return { id, type, success: true, data };
       }
@@ -149,10 +177,22 @@ export async function handleProxyBridgeMessage(
           signal: AbortSignal.timeout(45000),
         });
 
+        const responseHeaders = collectProxyResponseHeaders(response.headers, deps);
+        if (shouldReturnTextBody(response.headers)) {
+          const bodyText = await response.text();
+          const data: ApiProxyResponsePayload = {
+            status: response.status,
+            headers: responseHeaders,
+            bodyText,
+          };
+
+          return { id, type, success: true, data };
+        }
+
         const arrayBuffer = await response.arrayBuffer();
         const data: ApiProxyResponsePayload = {
           status: response.status,
-          headers: deps.collectHeaders(response.headers),
+          headers: responseHeaders,
           bodyBase64: Buffer.from(arrayBuffer).toString('base64'),
         };
 
@@ -168,7 +208,7 @@ export async function handleProxyBridgeMessage(
         const data: ApiProxyResponsePayload = {
           status: isTimeout ? 504 : 503,
           headers: { 'content-type': 'application/json' },
-          bodyBase64: deps.base64EncodeUtf8(body),
+          bodyText: body,
         };
         return { id, type, success: true, data };
       }
diff --git a/packages/vscode/webview/api/bridge.ts b/packages/vscode/webview/api/bridge.ts
index 3422b397..c2cedee1 100644
--- a/packages/vscode/webview/api/bridge.ts
+++ b/packages/vscode/webview/api/bridge.ts
@@ -107,7 +107,8 @@ export function sendBridgeMessageWithOptions<T = unknown>(
 export type ProxiedApiResponse = {
   status: number;
   headers: Record<string, string>;
-  bodyBase64: string;
+  bodyBase64?: string;
+  bodyText?: string;
 };
 
 export async function proxyApiRequest(options: {
diff --git a/packages/vscode/webview/main.tsx b/packages/vscode/webview/main.tsx
index 1671bba1..263b0a32 100644
--- a/packages/vscode/webview/main.tsx
+++ b/packages/vscode/webview/main.tsx
@@ -327,12 +327,16 @@ const decodeBase64 = (value: string): Uint8Array => {
 const isNullBodyStatus = (status: number): boolean => status === 204 || status === 205 || status === 304;
 
 const buildProxiedResponse = (
-  proxied: { status: number; headers: Record<string, string>; bodyBase64?: string }
+  proxied: { status: number; headers: Record<string, string>; bodyBase64?: string; bodyText?: string }
 ): Response => {
   if (isNullBodyStatus(proxied.status)) {
     return new Response(null, { status: proxied.status, headers: proxied.headers });
   }
 
+  if (typeof proxied.bodyText === 'string') {
+    return new Response(proxied.bodyText, { status: proxied.status, headers: proxied.headers });
+  }
+
   const body = proxied.bodyBase64 ? decodeBase64(proxied.bodyBase64) : new Uint8Array();
   return new Response(body, { status: proxied.status, headers: proxied.headers });
 };