diff --git a/docs/features/markstream-chat-rendering-optimization/plan.md b/docs/features/markstream-chat-rendering-optimization/plan.md
new file mode 100644
index 000000000..c0297d233
--- /dev/null
+++ b/docs/features/markstream-chat-rendering-optimization/plan.md
@@ -0,0 +1,98 @@
+# MarkStream Chat Rendering Optimization Plan
+
+## Chosen approach
+
+Use MarkStream's own chat-mode and performance presets inside each Markdown message, while keeping DeepChat's existing outer message windowing and row behavior. This gives the main performance gain where Markdown is expensive without breaking chat-level features that depend on the current DOM/scroll model.
+
+## Current path
+
+`ChatPage` builds display messages, `MessageList` renders rows, assistant rows render `MessageBlockContent`, and text parts render `MarkdownRenderer`, which wraps `markstream-vue`'s `NodeRenderer` with DeepChat custom components.
+
+## Rendering strategy
+
+### Streaming / live content
+
+- Keep `mode="chat"` stable.
+- Pass `final=false` while the block or part is still loading.
+- Use `smooth-streaming="auto"` unless the caller disables smooth streaming.
+- Enable `typewriter` and `code-block-stream` for the generating message.
+- Use incremental rendering by setting live node limit to `0` while streaming.
+- Tune MarkStream batch props for small frame-friendly chunks:
+  - small initial/render batch sizes;
+  - short render delay;
+  - low per-frame budget;
+  - idle timeout for catch-up.
+- Keep `fade=false` to avoid repeated opacity animation during streaming updates.
+
+### Completed / static content
+
+- Pass `final=true` after generation completes.
+- Disable smooth-streaming/typewriter/code-block-stream.
+- Use MarkStream node virtualization and viewport priority for completed long Markdown:
+  - `node-virtual="auto"` when allowed;
+  - `max-live-nodes` and `live-node-buffer` bounded;
+  - deferred offscreen nodes;
+  - viewport-priority rendering.
+- Keep the custom code block, Mermaid, reference, and link mappings registered through scoped `custom-id`.
+
+### Compatibility guardrails
+
+- Inline chat search disables Markdown node virtualization for all rendered messages while search is open.
+- Search-result messages always disable Markdown node virtualization.
+- Streaming content disables Markdown node virtualization even if the caller allows virtualization.
+- Message capture keeps using the complete display message list through `allMessagesForCapture`.
+- Session switch clears message-window measurements before loading the new session.
+
+## Affected interfaces
+
+- `MarkdownRenderer.vue`
+  - `streaming?: boolean`
+  - `final?: boolean`
+  - `virtualizeNodes?: boolean`
+  - internal MarkStream tuning constants for streaming and completed content.
+- `MessageBlockContent.vue`
+  - derives streaming/final state from block status and processed part loading;
+  - passes virtualization guard to MarkdownRenderer.
+- `MessageItemAssistant.vue`, `MessageListRow.vue`, `MessageList.vue`
+  - pass through `disableMarkdownVirtualization`.
+- `ChatPage.vue`
+  - disables Markdown virtualization while inline chat search is open;
+  - clears row measurements during session switch.
+
+## Test strategy
+
+Focused tests should assert both behavior and configuration:
+
+- `MarkdownRenderer.test.ts`
+  - static completed defaults;
+  - streaming configuration;
+  - smooth streaming opt-out;
+  - node virtualization opt-out;
+  - custom preview/reference behavior remains wired.
+- `MessageBlockContent.test.ts`
+  - pending/loading parts pass streaming/final state;
+  - completed parts pass final/static state;
+  - search-result and parent disable flags disable node virtualization.
+- `MessageList.test.ts`
+  - disable flag propagates through list rows.
+- `ChatPage.test.ts`
+  - chat search disables markdown virtualization;
+  - session switch clears measurements.
+
+Project checks before handoff:
+
+- `pnpm run format`
+- `pnpm run i18n`
+- `pnpm run lint`
+- `pnpm run typecheck:web`
+- focused renderer/list/page Vitest command.
+
+## Self-review loop
+
+After implementation:
+
+1. Inspect `git diff` for accidental unrelated changes.
+2. Re-read the render path and verify streaming/static/search/capture/jump invariants.
+3. Run focused tests and project checks.
+4. Fix any issues and repeat diff/test review until clean.
+5. Push the branch and update the PR body with concrete behavior and validation.
diff --git a/docs/features/markstream-chat-rendering-optimization/spec.md b/docs/features/markstream-chat-rendering-optimization/spec.md
new file mode 100644
index 000000000..a13ebd2a6
--- /dev/null
+++ b/docs/features/markstream-chat-rendering-optimization/spec.md
@@ -0,0 +1,46 @@
+# MarkStream Chat Rendering Optimization Spec
+
+## User need
+
+DeepChat's assistant messages can stream long Markdown responses with code blocks, Mermaid diagrams, tables, references, artifacts, and search highlights. Rendering must feel smooth while content is generating and stay fast when browsing completed long conversations.
+
+## Goal
+
+Build a high-performance, high-experience Markdown rendering path using `markstream-vue` for both streaming and completed chat content while preserving DeepChat's current behavior.
+
+The optimized path remains:
+
+`ChatPage` → `MessageList` / `MessageListRow` → `MessageItemAssistant` → `MessageBlockContent` → `MarkdownRenderer` → `markstream-vue` `NodeRenderer`
+
+## Acceptance criteria
+
+- Streaming assistant text blocks pass explicit live state to `markstream-vue` (`mode="chat"`, `final=false`) and use MarkStream's streaming-friendly features.
+- Completed assistant text blocks pass `final=true` and use MarkStream's completed-content virtualization/deferral features for long Markdown.
+- Streaming Markdown uses incremental rendering settings that prioritize frame budget and smooth typing cadence instead of large per-token DOM commits.
+- Static/completed Markdown uses a virtualized node window for long documents to preserve scrollback responsiveness and memory usage.
+- Code blocks remain Monaco/custom-renderer backed and support DeepChat artifact preview behavior.
+- Mermaid, references, links, artifact previews, tool calls, message capture, spotlight jump, scroll anchoring, and inline chat search remain compatible.
+- Chat search and search-result messages keep Markdown DOM available by disabling node virtualization where DOM search/highlighting needs it.
+- Session changes reset message height measurements so old session row heights cannot affect new session windowing.
+- The implementation is explicit, documented, and covered by focused renderer/list/page tests.
+- The PR description clearly explains the concrete performance/UX behavior, non-goals, and validation.
+
+## Constraints
+
+- Use `markstream-vue`; do not replace it with another renderer.
+- Prefer focused changes in the existing render chain and avoid broad unrelated refactors.
+- Do not replace the outer `MessageList` with `MarkstreamVirtualTimeline` in this slice; DeepChat's row-level tool/action/artifact/search/capture/jump/anchor behaviors need separate design before an outer virtual timeline can safely own them.
+- Keep `fade=false` to avoid opacity restart flicker during high-frequency streaming.
+- Preserve Monaco-backed code block rendering and artifact preview behavior.
+- Do not claim benchmark numbers unless measured in this task.
+
+## Non-goals
+
+- Full outer chat-list virtualization.
+- Redesign of DOM-based chat search/highlight.
+- New performance instrumentation UI.
+- Replacing DeepChat's custom code block/artifact preview components.
+
+## Open questions
+
+None for this implementation slice.
diff --git a/docs/features/markstream-chat-rendering-optimization/tasks.md b/docs/features/markstream-chat-rendering-optimization/tasks.md
new file mode 100644
index 000000000..c615bf899
--- /dev/null
+++ b/docs/features/markstream-chat-rendering-optimization/tasks.md
@@ -0,0 +1,17 @@
+# MarkStream Chat Rendering Optimization Tasks
+
+- [x] Create SDD spec, plan, and task documents.
+- [x] Reconfirm MarkStream Vue props and existing focused tests.
+- [x] Add streaming/final MarkStream option handling in `MarkdownRenderer.vue`.
+- [x] Pass explicit streaming/final state from `MessageBlockContent.vue`.
+- [x] Enable streaming code-block mode for live Markdown.
+- [x] Add a Markdown node virtualization guard for chat search/search-result messages.
+- [x] Clear message height measurements on session switch.
+- [x] Update focused component tests for the first pass.
+- [x] Tune MarkStream streaming batch settings for smoother live rendering.
+- [x] Tune completed-node virtualization settings for responsive static scrollback.
+- [x] Add/adjust tests for batch tuning props and compatibility guardrails.
+- [x] Run self-review pass for render-path invariants and unrelated changes.
+- [x] Run focused renderer/list/page tests.
+- [x] Run format, i18n, lint, and typecheck:web.
+- [x] Push branch and update PR description.
diff --git a/docs/issues/chat-send-jitter/spec.md b/docs/issues/chat-send-jitter/spec.md
new file mode 100644
index 000000000..3a580cc8d
--- /dev/null
+++ b/docs/issues/chat-send-jitter/spec.md
@@ -0,0 +1,44 @@
+# Chat send jitter
+
+## Issue
+
+When the user sends a message while the chat is pinned to the bottom, the message list can visibly jump for one frame immediately after submit or flash when the first assistant chunk starts rendering.
+
+## Impact
+
+The MarkStream rendering work feels smoother during generation, but the first outgoing-turn UI updates can still feel unstable because the list scroll position is corrected twice and the pending assistant row can be replaced by a different keyed DOM node at stream start.
+
+## Suspected root cause
+
+`ChatPage` inserts both an optimistic user message and an empty pending assistant placeholder before the backend starts streaming. `useMessageWindow` estimates an empty pending assistant row as a normal assistant message (`ASSISTANT_BASE`, 136px), while the real DOM for that row is only the assistant header plus spinner. `MessageListRow` then reports the smaller measured height on the next animation frame, and `ChatPage.onMessageMeasure` scrolls to the bottom again, causing a visible submit-time adjustment.
+
+At stream start, `chat.stream.updated` can set `isStreaming` before the real assistant record is available. The old placeholder was hidden immediately on `isStreaming`, leaving a one-frame gap. When the real assistant message then appears, `MessageList` keyed it by the real message id instead of the pending placeholder id, unmounting the spinner row and mounting a new assistant row.
+
+## Fix plan
+
+- Teach `useMessageWindow` to estimate empty pending assistant placeholders close to their actual spinner row height.
+- Keep the change narrowly scoped to synthetic pending assistant rows so real assistant messages keep their existing estimates.
+- Keep the pending assistant placeholder visible until the first real streaming assistant content exists.
+- Carry the pending placeholder render key onto the first real assistant row so Vue patches the existing row instead of replacing it.
+- Add regression tests covering the placeholder estimate, measurement delta, and stream-start row transition.
+
+## Task checklist
+
+- [x] Link GitHub bug issue
+- [x] Update placeholder height estimate
+- [x] Keep placeholder stable through stream-start
+- [x] Add regression coverage
+- [x] Run focused tests and required checks
+- [x] Commit and push the PR branch
+
+## Validation
+
+- `pnpm exec vitest --config vitest.config.renderer.ts test/renderer/composables/useMessageWindow.test.ts test/renderer/components/MessageListRow.test.ts test/renderer/components/ChatPage.test.ts`
+- `pnpm run format`
+- `pnpm run i18n`
+- `pnpm run lint`
+- `pnpm run typecheck:web`
+
+## Linked GitHub issue
+
+https://github.com/ThinkInAIXYZ/deepchat/issues/1897
diff --git a/package.json b/package.json
index 0e9f97ae4..523a087f7 100644
--- a/package.json
+++ b/package.json
@@ -190,7 +190,7 @@
     "electron-vite": "5.0.0",
     "jsdom": "^26.1.0",
     "katex": "^0.16.47",
-    "markstream-vue": "1.0.5-beta.2",
+    "markstream-vue": "^1.0.5",
     "mermaid": "^11.15.0",
     "minimatch": "^10.2.5",
     "monaco-editor": "^0.55.1",
@@ -199,7 +199,7 @@
     "picocolors": "^1.1.1",
     "pinia": "^3.0.4",
     "reka-ui": "^2.9.7",
-    "stream-monaco": "^0.0.45",
+    "stream-monaco": "^0.0.46",
     "tailwind-merge": "^3.6.0",
     "tailwind-scrollbar-hide": "^4.0.0",
     "tailwindcss": "^4.3.0",
diff --git a/src/renderer/src/components/artifacts/MarkdownArtifact.vue b/src/renderer/src/components/artifacts/MarkdownArtifact.vue
index 3e31f83fa..ea6009461 100644
--- a/src/renderer/src/components/artifacts/MarkdownArtifact.vue
+++ b/src/renderer/src/components/artifacts/MarkdownArtifact.vue
@@ -5,6 +5,9 @@
   >
     <MarkdownRenderer
       :content="props.block.content || ''"
+      :final="true"
+      :smooth-streaming="false"
+      :virtualize-nodes="false"
       :link-context="{ source: 'artifact' }"
       @copy="handleCopyClick"
     />
diff --git a/src/renderer/src/components/chat/MessageList.vue b/src/renderer/src/components/chat/MessageList.vue
index e9e9214d5..6f251df4f 100644
--- a/src/renderer/src/components/chat/MessageList.vue
+++ b/src/renderer/src/components/chat/MessageList.vue
@@ -8,12 +8,13 @@
       />
       <MessageListRow
         v-for="item in allRenderedMessages"
-        :key="item.id"
+        :key="item.renderKey ?? item.id"
         :item="item"
         :is-generating="isGenerating"
         :show-trace="traceMessageIdSet.has(item.id)"
-        :is-capturing="isCapturing"
+        :is-capturing="isCapturingValue"
         :is-read-only="isReadOnly"
+        :disable-markdown-virtualization="shouldDisableMarkdownVirtualization"
         @retry="onRetry"
         @delete="onDelete"
         @fork="onFork"
@@ -42,7 +43,7 @@
 </template>
 
 <script setup lang="ts">
-import { computed } from 'vue'
+import { computed, unref } from 'vue'
 import MessageBlockAction from '@/components/message/MessageBlockAction.vue'
 import { useMessageCapture } from '@/composables/message/useMessageCapture'
 import {
@@ -64,6 +65,7 @@ const props = withDefaults(
     allMessagesForCapture?: MessageListItem[]
     beforeSpacerHeight?: number
     afterSpacerHeight?: number
+    disableMarkdownVirtualization?: boolean
   }>(),
   {
     conversationId: '',
@@ -74,7 +76,8 @@ const props = withDefaults(
     isReadOnly: false,
     allMessagesForCapture: () => [],
     beforeSpacerHeight: 0,
-    afterSpacerHeight: 0
+    afterSpacerHeight: 0,
+    disableMarkdownVirtualization: false
   }
 )
 
@@ -89,11 +92,15 @@ const emit = defineEmits<{
 }>()
 
 const traceMessageIdSet = computed(() => new Set(props.traceMessageIds))
+const { isCapturing, captureMessage } = useMessageCapture()
+const isCapturingValue = computed(() => Boolean(unref(isCapturing)))
+const shouldDisableMarkdownVirtualization = computed(
+  () => props.disableMarkdownVirtualization || isCapturingValue.value
+)
 const allRenderedMessages = computed(() => props.messages)
 const captureSearchMessages = computed(() =>
   props.allMessagesForCapture.length > 0 ? props.allMessagesForCapture : props.messages
 )
-const { isCapturing, captureMessage } = useMessageCapture()
 
 const onRetry = (messageId: string) => emit('retry', messageId)
 const onDelete = (messageId: string) => emit('delete', messageId)
diff --git a/src/renderer/src/components/chat/MessageListRow.vue b/src/renderer/src/components/chat/MessageListRow.vue
index 74f2b4f93..df56734d4 100644
--- a/src/renderer/src/components/chat/MessageListRow.vue
+++ b/src/renderer/src/components/chat/MessageListRow.vue
@@ -38,6 +38,7 @@
       :show-trace="showTrace"
       :is-capturing-image="isCapturing"
       :is-read-only="isReadOnly"
+      :disable-markdown-virtualization="disableMarkdownVirtualization"
       @retry="onRetry"
       @delete="onDelete"
       @fork="onFork"
@@ -67,12 +68,14 @@ const props = withDefaults(
     showTrace?: boolean
     isCapturing?: boolean
     isReadOnly?: boolean
+    disableMarkdownVirtualization?: boolean
   }>(),
   {
     isGenerating: false,
     showTrace: false,
     isCapturing: false,
-    isReadOnly: false
+    isReadOnly: false,
+    disableMarkdownVirtualization: false
   }
 )
 
@@ -103,7 +106,7 @@ const emitMeasuredHeight = () => {
 
   measureFrame = window.requestAnimationFrame(() => {
     measureFrame = null
-    const messageId = props.item?.id
+    const messageId = props.item?.renderKey ?? props.item?.id
     if (!messageId) return
     const height = rowRef.value?.offsetHeight ?? 0
     if (height <= 0 || Math.abs(height - lastMeasuredHeight) < 1) return
@@ -123,7 +126,7 @@ onMounted(() => {
 })
 
 watch(
-  () => props.item?.id,
+  () => props.item?.renderKey ?? props.item?.id,
   () => {
     lastMeasuredHeight = 0
     emitMeasuredHeight()
diff --git a/src/renderer/src/components/chat/messageListItems.ts b/src/renderer/src/components/chat/messageListItems.ts
index d3410d7c4..c1dd03d43 100644
--- a/src/renderer/src/components/chat/messageListItems.ts
+++ b/src/renderer/src/components/chat/messageListItems.ts
@@ -176,6 +176,7 @@ type DisplayMessageBase = {
   conversationId: string
   is_variant: number
   variants?: DisplayMessage[]
+  renderKey?: string
   orderSeq: number
   messageType?: 'normal' | 'compaction'
   compactionStatus?: 'compacting' | 'compacted'
diff --git a/src/renderer/src/components/markdown/MarkdownRenderer.vue b/src/renderer/src/components/markdown/MarkdownRenderer.vue
index fd4d2e636..6c8eab77e 100644
--- a/src/renderer/src/components/markdown/MarkdownRenderer.vue
+++ b/src/renderer/src/components/markdown/MarkdownRenderer.vue
@@ -4,11 +4,27 @@
   >
     <NodeRenderer
       :content="debouncedContent"
-      :final="!smoothStreaming"
       :custom-id="customRendererId"
       :isDark="themeStore.isDark"
-      :smooth-streaming="smoothStreaming"
+      :mode="props.mode"
+      :final="resolvedFinal"
+      :smooth-streaming="resolvedSmoothStreaming"
+      :typewriter="isStreaming"
+      :code-block-stream="isStreaming"
       :fade="false"
+      :batch-rendering="true"
+      :initial-render-batch-size="initialRenderBatchSize"
+      :render-batch-size="renderBatchSize"
+      :render-batch-delay="renderBatchDelay"
+      :render-batch-budget-ms="renderBatchBudgetMs"
+      :render-batch-idle-timeout-ms="renderBatchIdleTimeoutMs"
+      :parse-coalesce-ms="parseCoalesceMs"
+      html-policy="safe"
+      :defer-nodes-until-visible="shouldDeferNodesUntilVisible"
+      :viewport-priority="shouldVirtualizeNodes"
+      :node-virtual="resolvedNodeVirtual"
+      :max-live-nodes="maxLiveNodes"
+      :live-node-buffer="liveNodeBuffer"
       :codeBlockDarkTheme="codeBlockDarkTheme"
       :codeBlockLightTheme="codeBlockLightTheme"
       :codeBlockMonacoOptions="codeBlockMonacoOption"
@@ -46,9 +62,17 @@ const props = withDefaults(
     threadId?: string
     linkContext?: MarkdownLinkContext
     smoothStreaming?: boolean
+    streaming?: boolean
+    final?: boolean
+    virtualizeNodes?: boolean
+    mode?: 'docs' | 'chat' | 'minimal'
   }>(),
   {
-    smoothStreaming: true
+    smoothStreaming: true,
+    streaming: false,
+    final: undefined,
+    virtualizeNodes: true,
+    mode: 'docs'
   }
 )
 const themeStore = useThemeStore()
@@ -93,6 +117,57 @@ const codeBlockMonacoOption = computed(() => ({
   fontFamily: uiSettingsStore.formattedCodeFontFamily,
   wordWrap: 'on' as const
 }))
+const isStreaming = computed(
+  () => props.final === false || (props.streaming && props.final !== true)
+)
+const resolvedFinal = computed(() => props.final ?? !isStreaming.value)
+const resolvedSmoothStreaming = computed(() => {
+  if (!props.smoothStreaming || resolvedFinal.value) {
+    return false
+  }
+
+  return 'auto' as const
+})
+const STREAM_INITIAL_RENDER_BATCH_SIZE = 10
+const STREAM_RENDER_BATCH_SIZE = 14
+const STREAM_RENDER_BATCH_DELAY_MS = 8
+const STREAM_RENDER_BATCH_BUDGET_MS = 3
+const STREAM_RENDER_BATCH_IDLE_TIMEOUT_MS = 24
+const STREAM_PARSE_COALESCE_MS = 12
+const STATIC_INITIAL_RENDER_BATCH_SIZE = 96
+const STATIC_RENDER_BATCH_SIZE = 80
+const STATIC_RENDER_BATCH_DELAY_MS = 0
+const STATIC_RENDER_BATCH_BUDGET_MS = 8
+const STATIC_RENDER_BATCH_IDLE_TIMEOUT_MS = 16
+const STATIC_PARSE_COALESCE_MS = 0
+const STATIC_MAX_LIVE_NODES = 260
+const STATIC_LIVE_NODE_BUFFER = 80
+
+const shouldVirtualizeNodes = computed(() => props.virtualizeNodes && !isStreaming.value)
+const shouldDeferNodesUntilVisible = computed(() => shouldVirtualizeNodes.value)
+const resolvedNodeVirtual = computed(() =>
+  shouldVirtualizeNodes.value ? ('auto' as const) : false
+)
+const maxLiveNodes = computed(() => (shouldVirtualizeNodes.value ? STATIC_MAX_LIVE_NODES : 0))
+const liveNodeBuffer = computed(() => (shouldVirtualizeNodes.value ? STATIC_LIVE_NODE_BUFFER : 0))
+const initialRenderBatchSize = computed(() =>
+  isStreaming.value ? STREAM_INITIAL_RENDER_BATCH_SIZE : STATIC_INITIAL_RENDER_BATCH_SIZE
+)
+const renderBatchSize = computed(() =>
+  isStreaming.value ? STREAM_RENDER_BATCH_SIZE : STATIC_RENDER_BATCH_SIZE
+)
+const renderBatchDelay = computed(() =>
+  isStreaming.value ? STREAM_RENDER_BATCH_DELAY_MS : STATIC_RENDER_BATCH_DELAY_MS
+)
+const renderBatchBudgetMs = computed(() =>
+  isStreaming.value ? STREAM_RENDER_BATCH_BUDGET_MS : STATIC_RENDER_BATCH_BUDGET_MS
+)
+const renderBatchIdleTimeoutMs = computed(() =>
+  isStreaming.value ? STREAM_RENDER_BATCH_IDLE_TIMEOUT_MS : STATIC_RENDER_BATCH_IDLE_TIMEOUT_MS
+)
+const parseCoalesceMs = computed(() =>
+  isStreaming.value ? STREAM_PARSE_COALESCE_MS : STATIC_PARSE_COALESCE_MS
+)
 const { navigateLink } = useMarkdownLinkNavigation({
   linkContext: effectiveLinkContext
 })
@@ -129,6 +204,11 @@ const updateContentSlow = useDebounceFn(
 const updateContent = (value: string) => {
   const revision = ++contentRevision
 
+  if (isStreaming.value && debouncedContent.value.length === 0 && value.length > 0) {
+    debouncedContent.value = value
+    return
+  }
+
   if (props.smoothStreaming && value.length > 12_000) {
     updateContentSlow(revision, value)
     return
diff --git a/src/renderer/src/components/message/MessageBlockContent.vue b/src/renderer/src/components/message/MessageBlockContent.vue
index 11faad7f8..f68920164 100644
--- a/src/renderer/src/components/message/MessageBlockContent.vue
+++ b/src/renderer/src/components/message/MessageBlockContent.vue
@@ -6,7 +6,11 @@
       v-if="part.type === 'text'"
       :content="part.content"
       :loading="part.loading"
+      mode="chat"
       :smooth-streaming="shouldSmoothStream"
+      :streaming="isStreamingPart(part)"
+      :final="!isStreamingPart(part)"
+      :virtualize-nodes="shouldVirtualizeNodes"
       :message-id="messageId"
       :thread-id="threadId"
       :link-context="{
@@ -51,6 +55,7 @@ const props = defineProps<{
   messageId: string
   threadId: string
   isSearchResult?: boolean
+  disableMarkdownVirtualization?: boolean
 }>()
 
 const { processedContent } = useBlockContent(props)
@@ -58,6 +63,13 @@ const lastArtifactSnapshot = ref<string>('')
 const shouldSmoothStream = computed(
   () => props.block.status === 'pending' || props.block.status === 'loading'
 )
+const isStreamingPart = (part: ProcessedPart) => shouldSmoothStream.value || Boolean(part.loading)
+const hasStreamingContent = computed(() =>
+  processedContent.value.some((part) => part.type === 'text' && isStreamingPart(part))
+)
+const shouldVirtualizeNodes = computed(
+  () => !props.disableMarkdownVirtualization && !props.isSearchResult && !hasStreamingContent.value
+)
 
 const artifactSnapshot = computed(() =>
   processedContent.value
diff --git a/src/renderer/src/components/message/MessageItemAssistant.vue b/src/renderer/src/components/message/MessageItemAssistant.vue
index b35dcd917..0ce57c76c 100644
--- a/src/renderer/src/components/message/MessageItemAssistant.vue
+++ b/src/renderer/src/components/message/MessageItemAssistant.vue
@@ -29,14 +29,14 @@
 
         <div class="flex flex-col w-full space-y-1.5">
           <MessageInfo :name="currentMessage.model_name" :timestamp="currentMessage.timestamp" />
-          <Spinner
-            v-if="
-              currentContent.length === 0 &&
-              (currentMessage?.status ?? message.status) === 'pending'
-            "
-            class="size-3 text-muted-foreground"
-          />
-          <div v-else class="flex flex-col w-full gap-1.5" data-message-content="true">
+          <div class="flex flex-col w-full gap-1.5" data-message-content="true">
+            <Spinner
+              v-if="
+                currentContent.length === 0 &&
+                (currentMessage?.status ?? message.status) === 'pending'
+              "
+              class="size-3 text-muted-foreground"
+            />
             <template v-for="item in currentRenderItems" :key="item.key">
               <MessageBlockActivityGroup
                 v-if="item.kind === 'activity-group'"
@@ -55,6 +55,7 @@
                 :message-id="currentMessage.id"
                 :thread-id="currentThreadId"
                 :is-search-result="isSearchResult"
+                :disable-markdown-virtualization="disableMarkdownVirtualization"
               />
               <MessageBlockThink
                 v-else-if="
@@ -248,6 +249,7 @@ const props = defineProps<{
   isInGeneratingThread?: boolean
   showTrace?: boolean
   isReadOnly?: boolean
+  disableMarkdownVirtualization?: boolean
 }>()
 
 const themeStore = useThemeStore()
diff --git a/src/renderer/src/components/sidepanel/viewer/WorkspacePreviewPane.vue b/src/renderer/src/components/sidepanel/viewer/WorkspacePreviewPane.vue
index 1996fb379..999d81bba 100644
--- a/src/renderer/src/components/sidepanel/viewer/WorkspacePreviewPane.vue
+++ b/src/renderer/src/components/sidepanel/viewer/WorkspacePreviewPane.vue
@@ -11,6 +11,9 @@
       <div class="min-h-full px-4 py-4">
         <MarkdownRenderer
           :content="resolvedContent"
+          :final="true"
+          :smooth-streaming="false"
+          :virtualize-nodes="false"
           :message-id="previewSourceId"
           :thread-id="props.sessionId"
           :link-context="markdownLinkContext"
diff --git a/src/renderer/src/composables/message/useMessageWindow.ts b/src/renderer/src/composables/message/useMessageWindow.ts
index 8f3b2440c..e0ae7b896 100644
--- a/src/renderer/src/composables/message/useMessageWindow.ts
+++ b/src/renderer/src/composables/message/useMessageWindow.ts
@@ -3,6 +3,7 @@ import type { MessageListItem } from '@/components/chat/messageListItems'
 
 export type MessageLayoutEntry = {
   id: string
+  measurementKey: string
   orderSeq: number
   estimatedHeight: number
   measuredHeight?: number
@@ -20,6 +21,8 @@ const MIN_HEIGHT = 96
 const MAX_HEIGHT = 1200
 const USER_BASE = 112
 const ASSISTANT_BASE = 136
+const PENDING_ASSISTANT_PLACEHOLDER_HEIGHT = 80
+const PENDING_ASSISTANT_PLACEHOLDER_ID_PREFIX = '__pending_assistant_'
 const CHARS_PER_LINE = 72
 const LINE_H = 22
 
@@ -37,6 +40,14 @@ function estimateHeight(msg: MessageListItem): number {
       USER_BASE + Math.ceil(Math.max(textLen, richLen) / CHARS_PER_LINE) * LINE_H + files * 34
     )
   }
+  if (
+    msg.status === 'pending' &&
+    msg.id.startsWith(PENDING_ASSISTANT_PLACEHOLDER_ID_PREFIX) &&
+    msg.content.length === 0
+  ) {
+    return PENDING_ASSISTANT_PLACEHOLDER_HEIGHT
+  }
+
   let h = ASSISTANT_BASE
   for (const block of msg.content) {
     switch (block.type) {
@@ -82,11 +93,13 @@ export function useMessageWindow(options: UseMessageWindowOptions) {
   const entries = computed<MessageLayoutEntry[]>(() => {
     let offset = 0
     return options.messages.value.map((msg) => {
-      const measured = measuredHeights.value[msg.id]
+      const measurementKey = msg.renderKey ?? msg.id
+      const measured = measuredHeights.value[measurementKey]
       const estimated = estimateHeight(msg)
       const height = measured ?? estimated
       const entry: MessageLayoutEntry = {
         id: msg.id,
+        measurementKey,
         orderSeq: msg.orderSeq,
         estimatedHeight: estimated,
         measuredHeight: measured,
@@ -101,7 +114,7 @@ export function useMessageWindow(options: UseMessageWindowOptions) {
   const totalHeight = computed(() => entries.value[entries.value.length - 1]?.bottom ?? 0)
 
   function getEntry(messageId: string): MessageLayoutEntry | undefined {
-    return entries.value.find((e) => e.id === messageId)
+    return entries.value.find((e) => e.id === messageId || e.measurementKey === messageId)
   }
 
   function setMeasuredHeight(messageId: string, height: number): number {
diff --git a/src/renderer/src/pages/ChatPage.vue b/src/renderer/src/pages/ChatPage.vue
index 146d17674..eaf83fdfd 100644
--- a/src/renderer/src/pages/ChatPage.vue
+++ b/src/renderer/src/pages/ChatPage.vue
@@ -48,6 +48,7 @@
           :is-generating="isGenerating"
           :trace-message-ids="traceMessageIds"
           :is-read-only="isReadOnlySession"
+          :disable-markdown-virtualization="isChatSearchOpen"
           @retry="onMessageRetry"
           @delete="onMessageDelete"
           @fork="onMessageFork"
@@ -352,10 +353,6 @@ async function loadMessagesAndRehydrate(sessionId: string, count?: number) {
 const scrollContainer = ref<HTMLDivElement>()
 const messageSearchRoot = ref<HTMLDivElement>()
 const bottomScrollAnchor = ref<HTMLDivElement | null>(null)
-const messageListRef = ref<{
-  scrollToBottom?: () => void
-  forceUpdate?: (clear?: boolean) => void
-} | null>(null)
 const planFloatLayer = ref<HTMLDivElement | null>(null)
 const chatInputHeroHostRef = ref<HTMLDivElement | null>(null)
 const pendingDeleteMessageId = ref<string | null>(null)
@@ -367,6 +364,7 @@ const pendingAssistantPlaceholder = ref<{
   baselineMessageOrderSeq: number
   baselineCreatedAt: number
 } | null>(null)
+const assistantRenderKeyByMessageId = ref<Record<string, string>>({})
 let pendingAssistantPlaceholderSeq = 0
 // Track whether user is near the bottom; if they scroll up, stop auto-following
 const isNearBottom = ref(true)
@@ -404,6 +402,7 @@ const displayMessageCache = new Map<
     modelId: string
     providerId: string
     status: DisplayMessage['status']
+    renderKey?: string
     message: DisplayMessage
   }
 >()
@@ -427,6 +426,10 @@ let userScrollAwayIntentUntil = 0
 let cancelSessionRestoreTask: (() => void) | null = null
 let cancelSessionRestoreScrollIntentListeners: (() => void) | null = null
 let cancelPlanUpdatedListener: (() => void) | null = null
+// The immediate session watcher can call clearMessageWindowMeasurements before
+// messageWindow exists; keep this no-op forward reference and rebind it to
+// messageWindow.clearMeasurements after useMessageWindow is created below.
+let clearMessageWindowMeasurements = () => {}
 let sessionRestoreRequestId = 0
 let planFloatResizeObserver: ResizeObserver | null = null
 let sessionRestoreResizeObserver: ResizeObserver | null = null
@@ -943,10 +946,12 @@ watch(
     pendingAssistantPlaceholder.value = null
     clearChatSearchState()
     displayMessageCache.clear()
+    assistantRenderKeyByMessageId.value = {}
     sessionRestoreRequestId += 1
     cancelSessionRestoreTask?.()
     cancelSessionRestoreTask = null
     cancelSessionRestoreScrollSettle()
+    clearMessageWindowMeasurements()
     messageStore.clear()
     pendingInputStore.clear()
     if (id) {
@@ -1016,7 +1021,8 @@ function toDisplayMessage(record: ChatMessageRecord): DisplayMessage {
     cached.metadata === record.metadata &&
     cached.modelId === modelId &&
     cached.providerId === providerId &&
-    cached.status === record.status
+    cached.status === record.status &&
+    cached.renderKey === assistantRenderKeyByMessageId.value[record.id]
   ) {
     return cached.message
   }
@@ -1042,10 +1048,12 @@ function toDisplayMessage(record: ChatMessageRecord): DisplayMessage {
     summaryUpdatedAt: metadata.summaryUpdatedAt ?? null
   } as const
 
+  const streamingRenderKey = assistantRenderKeyByMessageId.value[record.id]
   const nextMessage =
     record.role === 'assistant'
       ? ({
           ...baseMessage,
+          ...(streamingRenderKey ? { renderKey: streamingRenderKey } : {}),
           role: 'assistant',
           content: messageStore.getAssistantMessageBlocks(record)
         } as DisplayMessage)
@@ -1062,6 +1070,7 @@ function toDisplayMessage(record: ChatMessageRecord): DisplayMessage {
     modelId,
     providerId,
     status: record.status,
+    renderKey: streamingRenderKey,
     message: nextMessage
   })
 
@@ -1104,6 +1113,9 @@ const hasInlineStreamingTarget = computed(() => {
   if (!messageId) return false
   return messageStore.messageCache.has(messageId)
 })
+const hasFirstStreamingContent = computed(
+  () => messageStore.streamingBlocks.length > 0 && hasInlineStreamingTarget.value
+)
 
 const ephemeralRateLimitMessageId = computed(() => {
   const messageId = messageStore.currentStreamMessageId
@@ -1152,17 +1164,17 @@ const shouldShowPendingAssistantPlaceholder = computed(() => {
   return Boolean(
     pending &&
     pending.sessionId === props.sessionId &&
-    !messageStore.isStreaming &&
-    !hasInlineStreamingTarget.value &&
+    !hasFirstStreamingContent.value &&
     !hasNewAssistantMessageAfterPendingPlaceholder.value &&
     !ephemeralRateLimitBlock.value
   )
 })
 
 watch(
-  () => messageStore.isStreaming || hasNewAssistantMessageAfterPendingPlaceholder.value,
+  () => hasFirstStreamingContent.value || hasNewAssistantMessageAfterPendingPlaceholder.value,
   (shouldClearPendingAssistant) => {
     if (shouldClearPendingAssistant) {
+      bindPendingAssistantRenderKey()
       pendingAssistantPlaceholder.value = null
     }
   }
@@ -1236,6 +1248,29 @@ function clearPendingAssistantPlaceholder(id?: string): void {
   }
 }
 
+function bindPendingAssistantRenderKey(): void {
+  const pending = pendingAssistantPlaceholder.value
+  const streamMessageId = messageStore.currentStreamMessageId
+  if (
+    !pending ||
+    pending.sessionId !== props.sessionId ||
+    !streamMessageId ||
+    !hasInlineStreamingTarget.value ||
+    assistantRenderKeyByMessageId.value[streamMessageId] === pending.id
+  ) {
+    return
+  }
+  assistantRenderKeyByMessageId.value = {
+    ...assistantRenderKeyByMessageId.value,
+    [streamMessageId]: pending.id
+  }
+}
+
+watch(
+  () => [messageStore.currentStreamMessageId, hasInlineStreamingTarget.value] as const,
+  bindPendingAssistantRenderKey
+)
+
 const displayMessages = computed(() => {
   const msgs: DisplayMessage[] = []
   const activeMessageIds = new Set<string>()
@@ -1274,6 +1309,7 @@ const displayMessages = computed(() => {
 const messageWindow = useMessageWindow({
   messages: displayMessages
 })
+clearMessageWindowMeasurements = messageWindow.clearMeasurements
 
 const findFirstEntryWithBottomAtOrAfter = (
   entries: Array<{ bottom: number }>,
diff --git a/test/renderer/components/ChatPage.test.ts b/test/renderer/components/ChatPage.test.ts
index eacce1d98..a1eda95fb 100644
--- a/test/renderer/components/ChatPage.test.ts
+++ b/test/renderer/components/ChatPage.test.ts
@@ -340,10 +340,14 @@ const setup = async (options: SetupOptions = {}) => {
         afterSpacerHeight: {
           type: Number,
           default: 0
+        },
+        disableMarkdownVirtualization: {
+          type: Boolean,
+          default: false
         }
       },
       template:
-        '<div class="message-list-stub" :data-read-only="String(isReadOnly)" :data-has-rate-limit="String(Boolean(ephemeralRateLimitBlock))"><div v-for="message in messages" :key="message.id" class="message-item-stub" :data-message-id="message.id" /></div>'
+        '<div class="message-list-stub" :data-read-only="String(isReadOnly)" :data-has-rate-limit="String(Boolean(ephemeralRateLimitBlock))" :data-disable-markdown-virtualization="String(disableMarkdownVirtualization)"><div v-for="message in messages" :key="message.renderKey ?? message.id" class="message-item-stub" :data-message-id="message.id" :data-render-key="message.renderKey ?? message.id" /></div>'
     })
   }))
   vi.doMock('@/components/chat/ChatInputBox.vue', () => ({
@@ -955,9 +959,42 @@ describe('ChatPage', () => {
     await flushPromises()
 
     const streamingMessages = messageList.props('messages') as Array<{ id: string; role: string }>
-    expect(streamingMessages.some((message) => message.id.startsWith('__pending_assistant_'))).toBe(
-      false
+    const pendingAssistant = streamingMessages.find((message) =>
+      message.id.startsWith('__pending_assistant_')
+    )
+    expect(pendingAssistant).toBeDefined()
+
+    const firstChunkMessage = {
+      ...buildAssistantMessage([
+        {
+          type: 'content',
+          content: 'first chunk',
+          status: 'loading',
+          timestamp: 2
+        }
+      ]),
+      id: 'assistant-stream-1',
+      orderSeq: 2,
+      status: 'pending' as const
+    }
+    messageStore.currentStreamMessageId = firstChunkMessage.id
+    messageStore.streamingBlocks = JSON.parse(firstChunkMessage.content)
+    messageStore.messages.push(firstChunkMessage)
+    messageStore.messageIds.push(firstChunkMessage.id)
+    messageStore.messageCache.set(firstChunkMessage.id, firstChunkMessage)
+    await flushPromises()
+
+    const firstChunkMessages = messageList.props('messages') as Array<{
+      id: string
+      renderKey?: string
+    }>
+    const firstChunkAssistant = firstChunkMessages.find(
+      (message) => message.id === firstChunkMessage.id
     )
+    expect(
+      firstChunkMessages.some((message) => message.id.startsWith('__pending_assistant_'))
+    ).toBe(false)
+    expect(firstChunkAssistant?.renderKey).toBe(pendingAssistant?.id)
 
     deferredSend.resolve({ accepted: true, requestId: null, messageId: null })
     await flushPromises()
@@ -1917,10 +1954,16 @@ describe('ChatPage', () => {
     window.dispatchEvent(new KeyboardEvent('keydown', { key: 'f', ctrlKey: true }))
     await flushPromises()
     expect(wrapper.find('.chat-search-bar-stub').exists()).toBe(true)
+    expect(
+      wrapper.find('.message-list-stub').attributes('data-disable-markdown-virtualization')
+    ).toBe('true')
 
     window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }))
     await flushPromises()
     expect(wrapper.find('.chat-search-bar-stub').exists()).toBe(false)
+    expect(
+      wrapper.find('.message-list-stub').attributes('data-disable-markdown-virtualization')
+    ).toBe('false')
   })
 
   it('renders subagent sessions as read-only display mode', async () => {
diff --git a/test/renderer/components/MarkdownArtifact.test.ts b/test/renderer/components/MarkdownArtifact.test.ts
new file mode 100644
index 000000000..de3606f1b
--- /dev/null
+++ b/test/renderer/components/MarkdownArtifact.test.ts
@@ -0,0 +1,59 @@
+import { mount } from '@vue/test-utils'
+import { defineComponent } from 'vue'
+import { describe, expect, it } from 'vitest'
+import MarkdownArtifact from '@/components/artifacts/MarkdownArtifact.vue'
+import type { MarkdownLinkContext } from '@/components/markdown/linkTypes'
+
+describe('MarkdownArtifact', () => {
+  it('renders artifact markdown as completed non-virtualized content', () => {
+    const wrapper = mount(MarkdownArtifact, {
+      props: {
+        block: {
+          artifact: {
+            type: 'text/markdown',
+            title: 'Readme'
+          },
+          content: '# Artifact'
+        }
+      },
+      global: {
+        stubs: {
+          MarkdownRenderer: defineComponent({
+            name: 'MarkdownRenderer',
+            props: {
+              content: {
+                type: String,
+                required: true
+              },
+              final: {
+                type: Boolean,
+                default: undefined
+              },
+              smoothStreaming: {
+                type: Boolean,
+                default: true
+              },
+              virtualizeNodes: {
+                type: Boolean,
+                default: true
+              },
+              linkContext: {
+                type: Object as () => MarkdownLinkContext | undefined,
+                default: undefined
+              }
+            },
+            template:
+              '<div data-testid="markdown-renderer" :data-final="String(final)" :data-smooth-streaming="String(smoothStreaming)" :data-virtualize-nodes="String(virtualizeNodes)" :data-link-source="linkContext?.source">{{ content }}</div>'
+          })
+        }
+      }
+    })
+
+    const renderer = wrapper.get('[data-testid="markdown-renderer"]')
+    expect(renderer.text()).toContain('# Artifact')
+    expect(renderer.attributes('data-final')).toBe('true')
+    expect(renderer.attributes('data-smooth-streaming')).toBe('false')
+    expect(renderer.attributes('data-virtualize-nodes')).toBe('false')
+    expect(renderer.attributes('data-link-source')).toBe('artifact')
+  })
+})
diff --git a/test/renderer/components/MarkdownRenderer.test.ts b/test/renderer/components/MarkdownRenderer.test.ts
index 106e0e427..336aca497 100644
--- a/test/renderer/components/MarkdownRenderer.test.ts
+++ b/test/renderer/components/MarkdownRenderer.test.ts
@@ -87,11 +87,79 @@ const setup = async (props: Record<string, unknown> = {}) => {
       props: {
         final: {
           type: Boolean,
-          default: false
+          default: undefined
+        },
+        mode: {
+          type: String,
+          default: undefined
+        },
+        htmlPolicy: {
+          type: String,
+          default: undefined
         },
         smoothStreaming: {
+          type: [Boolean, String],
+          default: false
+        },
+        typewriter: {
+          type: Boolean,
+          default: false
+        },
+        batchRendering: {
+          type: Boolean,
+          default: false
+        },
+        deferNodesUntilVisible: {
+          type: Boolean,
+          default: false
+        },
+        viewportPriority: {
           type: Boolean,
           default: false
+        },
+        nodeVirtual: {
+          type: [Boolean, String],
+          default: false
+        },
+        maxLiveNodes: {
+          type: Number,
+          default: undefined
+        },
+        liveNodeBuffer: {
+          type: Number,
+          default: undefined
+        },
+        codeBlockStream: {
+          type: Boolean,
+          default: false
+        },
+        initialRenderBatchSize: {
+          type: Number,
+          default: undefined
+        },
+        renderBatchSize: {
+          type: Number,
+          default: undefined
+        },
+        renderBatchDelay: {
+          type: Number,
+          default: undefined
+        },
+        renderBatchBudgetMs: {
+          type: Number,
+          default: undefined
+        },
+        renderBatchIdleTimeoutMs: {
+          type: Number,
+          default: undefined
+        },
+        parseCoalesceMs: {
+          type: Number,
+          default: undefined
+        },
+        content: {
+          type: String,
+          default: ''
         }
       },
       setup(props) {
@@ -101,7 +169,24 @@ const setup = async (props: Record<string, unknown> = {}) => {
             {
               'data-testid': 'node-renderer',
               'data-final': String(props.final),
-              'data-smooth-streaming': String(props.smoothStreaming)
+              'data-mode': props.mode,
+              'data-html-policy': props.htmlPolicy,
+              'data-smooth-streaming': String(props.smoothStreaming),
+              'data-typewriter': String(props.typewriter),
+              'data-batch-rendering': String(props.batchRendering),
+              'data-defer-nodes-until-visible': String(props.deferNodesUntilVisible),
+              'data-viewport-priority': String(props.viewportPriority),
+              'data-node-virtual': String(props.nodeVirtual),
+              'data-max-live-nodes': String(props.maxLiveNodes),
+              'data-live-node-buffer': String(props.liveNodeBuffer),
+              'data-code-block-stream': String(props.codeBlockStream),
+              'data-initial-render-batch-size': String(props.initialRenderBatchSize),
+              'data-render-batch-size': String(props.renderBatchSize),
+              'data-render-batch-delay': String(props.renderBatchDelay),
+              'data-render-batch-budget-ms': String(props.renderBatchBudgetMs),
+              'data-render-batch-idle-timeout-ms': String(props.renderBatchIdleTimeoutMs),
+              'data-parse-coalesce-ms': String(props.parseCoalesceMs),
+              'data-content': props.content
             },
             [
               customComponents.code_block?.({
@@ -234,12 +319,28 @@ describe('MarkdownRenderer', () => {
     )
   })
 
-  it('enables smooth streaming by default', async () => {
+  it('renders static markdown as final docs content by default', async () => {
     const { wrapper } = await setup()
+    const nodeRenderer = wrapper.get('[data-testid="node-renderer"]')
 
-    expect(wrapper.get('[data-testid="node-renderer"]').attributes('data-smooth-streaming')).toBe(
-      'true'
-    )
+    expect(nodeRenderer.attributes('data-mode')).toBe('docs')
+    expect(nodeRenderer.attributes('data-html-policy')).toBe('safe')
+    expect(nodeRenderer.attributes('data-final')).toBe('true')
+    expect(nodeRenderer.attributes('data-smooth-streaming')).toBe('false')
+    expect(nodeRenderer.attributes('data-typewriter')).toBe('false')
+    expect(nodeRenderer.attributes('data-batch-rendering')).toBe('true')
+    expect(nodeRenderer.attributes('data-defer-nodes-until-visible')).toBe('true')
+    expect(nodeRenderer.attributes('data-viewport-priority')).toBe('true')
+    expect(nodeRenderer.attributes('data-node-virtual')).toBe('auto')
+    expect(nodeRenderer.attributes('data-max-live-nodes')).toBe('260')
+    expect(nodeRenderer.attributes('data-live-node-buffer')).toBe('80')
+    expect(nodeRenderer.attributes('data-code-block-stream')).toBe('false')
+    expect(nodeRenderer.attributes('data-initial-render-batch-size')).toBe('96')
+    expect(nodeRenderer.attributes('data-render-batch-size')).toBe('80')
+    expect(nodeRenderer.attributes('data-render-batch-delay')).toBe('0')
+    expect(nodeRenderer.attributes('data-render-batch-budget-ms')).toBe('8')
+    expect(nodeRenderer.attributes('data-render-batch-idle-timeout-ms')).toBe('16')
+    expect(nodeRenderer.attributes('data-parse-coalesce-ms')).toBe('0')
   })
 
   it('marks the root for scoped code block scrollbar stabilization', async () => {
@@ -248,13 +349,59 @@ describe('MarkdownRenderer', () => {
     expect(wrapper.classes()).toContain('markdown-renderer-root')
   })
 
-  it('passes explicit smooth streaming to NodeRenderer', async () => {
+  it('passes the requested chat mode and streaming options to NodeRenderer for live content', async () => {
+    const { wrapper } = await setup({
+      mode: 'chat',
+      streaming: true,
+      final: false,
+      smoothStreaming: true
+    })
+    const nodeRenderer = wrapper.get('[data-testid="node-renderer"]')
+
+    expect(nodeRenderer.attributes('data-mode')).toBe('chat')
+    expect(nodeRenderer.attributes('data-final')).toBe('false')
+    expect(nodeRenderer.attributes('data-smooth-streaming')).toBe('auto')
+    expect(nodeRenderer.attributes('data-typewriter')).toBe('true')
+    expect(nodeRenderer.attributes('data-node-virtual')).toBe('false')
+    expect(nodeRenderer.attributes('data-max-live-nodes')).toBe('0')
+    expect(nodeRenderer.attributes('data-live-node-buffer')).toBe('0')
+    expect(nodeRenderer.attributes('data-code-block-stream')).toBe('true')
+    expect(nodeRenderer.attributes('data-defer-nodes-until-visible')).toBe('false')
+    expect(nodeRenderer.attributes('data-viewport-priority')).toBe('false')
+    expect(nodeRenderer.attributes('data-initial-render-batch-size')).toBe('10')
+    expect(nodeRenderer.attributes('data-render-batch-size')).toBe('14')
+    expect(nodeRenderer.attributes('data-render-batch-delay')).toBe('8')
+    expect(nodeRenderer.attributes('data-render-batch-budget-ms')).toBe('3')
+    expect(nodeRenderer.attributes('data-render-batch-idle-timeout-ms')).toBe('24')
+    expect(nodeRenderer.attributes('data-parse-coalesce-ms')).toBe('12')
+  })
+
+  it('renders the first non-empty streaming update immediately', async () => {
     const { wrapper } = await setup({
+      content: '',
+      streaming: true,
+      final: false,
       smoothStreaming: true
     })
 
+    expect(wrapper.get('[data-testid="node-renderer"]').attributes('data-content')).toBe('')
+
+    await wrapper.setProps({ content: 'first chunk' })
+
+    expect(wrapper.get('[data-testid="node-renderer"]').attributes('data-content')).toBe(
+      'first chunk'
+    )
+  })
+
+  it('disables smooth streaming when requested for live content', async () => {
+    const { wrapper } = await setup({
+      streaming: true,
+      final: false,
+      smoothStreaming: false
+    })
+
     expect(wrapper.get('[data-testid="node-renderer"]').attributes('data-smooth-streaming')).toBe(
-      'true'
+      'false'
     )
     expect(wrapper.get('[data-testid="node-renderer"]').attributes('data-final')).toBe('false')
   })
@@ -268,6 +415,19 @@ describe('MarkdownRenderer', () => {
     expect(nodeRenderer.attributes('data-final')).toBe('true')
   })
 
+  it('allows callers to disable completed-node virtualization and deferral', async () => {
+    const { wrapper } = await setup({
+      virtualizeNodes: false
+    })
+    const nodeRenderer = wrapper.get('[data-testid="node-renderer"]')
+
+    expect(nodeRenderer.attributes('data-node-virtual')).toBe('false')
+    expect(nodeRenderer.attributes('data-defer-nodes-until-visible')).toBe('false')
+    expect(nodeRenderer.attributes('data-viewport-priority')).toBe('false')
+    expect(nodeRenderer.attributes('data-max-live-nodes')).toBe('0')
+    expect(nodeRenderer.attributes('data-live-node-buffer')).toBe('0')
+  })
+
   it('routes reference clicks through the shared markdown link navigator', async () => {
     getSearchResultsMock.mockResolvedValueOnce([
       {
diff --git a/test/renderer/components/MessageList.test.ts b/test/renderer/components/MessageList.test.ts
index 8c1b84e30..a13e18878 100644
--- a/test/renderer/components/MessageList.test.ts
+++ b/test/renderer/components/MessageList.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { defineComponent } from 'vue'
 import { mount } from '@vue/test-utils'
 import type {
@@ -44,10 +44,14 @@ vi.mock('@/components/message/MessageItemAssistant.vue', () => ({
       isReadOnly: {
         type: Boolean,
         default: false
+      },
+      disableMarkdownVirtualization: {
+        type: Boolean,
+        default: false
       }
     },
     template:
-      '<div class="assistant-item" :data-read-only="String(isReadOnly)">{{ message.id }}</div>'
+      '<div class="assistant-item" :data-read-only="String(isReadOnly)" :data-disable-markdown-virtualization="String(disableMarkdownVirtualization)">{{ message.id }}</div>'
   })
 }))
 
@@ -64,13 +68,22 @@ vi.mock('@/components/message/MessageBlockAction.vue', () => ({
   })
 }))
 
-vi.mock('@/composables/message/useMessageCapture', () => ({
-  useMessageCapture: () => ({
-    isCapturing: false,
-    captureMessage: vi.fn().mockResolvedValue(undefined)
-  })
+const { isCapturingRef } = vi.hoisted(() => ({
+  isCapturingRef: { current: undefined as undefined | import('vue').Ref<boolean> }
 }))
 
+vi.mock('@/composables/message/useMessageCapture', async () => {
+  const { ref } = await import('vue')
+  const isCapturing = ref(false)
+  isCapturingRef.current = isCapturing
+  return {
+    useMessageCapture: () => ({
+      isCapturing,
+      captureMessage: vi.fn().mockResolvedValue(undefined)
+    })
+  }
+})
+
 import MessageList from '@/components/chat/MessageList.vue'
 
 function createMessage(id: string, role: 'user' | 'assistant', orderSeq: number): DisplayMessage {
@@ -128,6 +141,12 @@ function createCompactionMessage(
 }
 
 describe('MessageList', () => {
+  beforeEach(() => {
+    if (isCapturingRef.current) {
+      isCapturingRef.current.value = false
+    }
+  })
+
   it('renders persisted compaction messages inline with the message list', () => {
     const wrapper = mount(MessageList, {
       props: {
@@ -204,4 +223,33 @@ describe('MessageList', () => {
     expect(wrapper.find('.rate-limit-block-stub').text()).toBe('rate_limit')
     expect(wrapper.findAll('.assistant-item')).toHaveLength(0)
   })
+
+  it('passes markdown virtualization disable state to assistant rows', () => {
+    const wrapper = mount(MessageList, {
+      props: {
+        messages: [createMessage('a1', 'assistant', 1)],
+        disableMarkdownVirtualization: true
+      }
+    })
+
+    expect(wrapper.find('.assistant-item').attributes('data-disable-markdown-virtualization')).toBe(
+      'true'
+    )
+  })
+
+  it('disables markdown virtualization while capturing message screenshots', () => {
+    if (isCapturingRef.current) {
+      isCapturingRef.current.value = true
+    }
+
+    const wrapper = mount(MessageList, {
+      props: {
+        messages: [createMessage('a1', 'assistant', 1)]
+      }
+    })
+
+    expect(wrapper.find('.assistant-item').attributes('data-disable-markdown-virtualization')).toBe(
+      'true'
+    )
+  })
 })
diff --git a/test/renderer/components/MessageListRow.test.ts b/test/renderer/components/MessageListRow.test.ts
index bef58c5d2..d2170f020 100644
--- a/test/renderer/components/MessageListRow.test.ts
+++ b/test/renderer/components/MessageListRow.test.ts
@@ -80,4 +80,29 @@ describe('MessageListRow', () => {
 
     expect(wrapper.emitted('measure')).toEqual([[{ messageId: 'm1', height: 114 }]])
   })
+
+  it('emits renderKey measurements when a streaming row reuses a pending placeholder node', async () => {
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+      callback(0)
+      return 1
+    })
+    vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
+    vi.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockReturnValue(88)
+
+    const wrapper = mount(MessageListRow, {
+      props: {
+        item: {
+          ...baseItem,
+          id: 'assistant-real-1',
+          renderKey: '__pending_assistant_1'
+        } as never
+      }
+    })
+
+    await nextTick()
+
+    expect(wrapper.emitted('measure')).toEqual([
+      [{ messageId: '__pending_assistant_1', height: 88 }]
+    ])
+  })
 })
diff --git a/test/renderer/components/WorkspacePreviewPane.test.ts b/test/renderer/components/WorkspacePreviewPane.test.ts
index ded5a90f2..80146e957 100644
--- a/test/renderer/components/WorkspacePreviewPane.test.ts
+++ b/test/renderer/components/WorkspacePreviewPane.test.ts
@@ -130,13 +130,25 @@ describe('WorkspacePreviewPane', () => {
                 type: String,
                 default: undefined
               },
+              final: {
+                type: Boolean,
+                default: undefined
+              },
+              smoothStreaming: {
+                type: Boolean,
+                default: true
+              },
+              virtualizeNodes: {
+                type: Boolean,
+                default: true
+              },
               linkContext: {
                 type: Object as () => MarkdownLinkContext | undefined,
                 default: undefined
               }
             },
             template:
-              '<div data-testid="markdown-renderer" :data-message-id="messageId" :data-thread-id="threadId" :data-link-source="linkContext?.source" :data-link-session-id="linkContext?.sessionId" :data-source-file-path="linkContext?.sourceFilePath">{{ content }}</div>'
+              '<div data-testid="markdown-renderer" :data-message-id="messageId" :data-thread-id="threadId" :data-final="String(final)" :data-smooth-streaming="String(smoothStreaming)" :data-virtualize-nodes="String(virtualizeNodes)" :data-link-source="linkContext?.source" :data-link-session-id="linkContext?.sessionId" :data-source-file-path="linkContext?.sourceFilePath">{{ content }}</div>'
           }),
           HTMLArtifact: true,
           SvgArtifact: true,
@@ -158,6 +170,13 @@ describe('WorkspacePreviewPane', () => {
     expect(wrapper.get('[data-testid="markdown-renderer"]').attributes('data-thread-id')).toBe(
       'session-1'
     )
+    expect(wrapper.get('[data-testid="markdown-renderer"]').attributes('data-final')).toBe('true')
+    expect(
+      wrapper.get('[data-testid="markdown-renderer"]').attributes('data-smooth-streaming')
+    ).toBe('false')
+    expect(
+      wrapper.get('[data-testid="markdown-renderer"]').attributes('data-virtualize-nodes')
+    ).toBe('false')
     expect(wrapper.get('[data-testid="markdown-renderer"]').attributes('data-link-source')).toBe(
       'workspace'
     )
diff --git a/test/renderer/components/message/MessageBlockContent.test.ts b/test/renderer/components/message/MessageBlockContent.test.ts
index 8b24d11db..9a2b3a309 100644
--- a/test/renderer/components/message/MessageBlockContent.test.ts
+++ b/test/renderer/components/message/MessageBlockContent.test.ts
@@ -52,6 +52,10 @@ vi.mock('@/components/markdown/MarkdownRenderer.vue', () => ({
         type: String,
         default: ''
       },
+      mode: {
+        type: String,
+        default: undefined
+      },
       messageId: {
         type: String,
         default: undefined
@@ -64,13 +68,25 @@ vi.mock('@/components/markdown/MarkdownRenderer.vue', () => ({
         type: Boolean,
         default: false
       },
+      streaming: {
+        type: Boolean,
+        default: false
+      },
+      final: {
+        type: Boolean,
+        default: true
+      },
+      virtualizeNodes: {
+        type: Boolean,
+        default: true
+      },
       linkContext: {
         type: Object as () => MarkdownLinkContext | undefined,
         default: undefined
       }
     },
     template:
-      '<div class="markdown-stub" :data-message-id="messageId" :data-thread-id="threadId" :data-link-source="linkContext?.source" :data-link-session-id="linkContext?.sessionId" :data-smooth-streaming="String(smoothStreaming)">{{ content }}</div>'
+      '<div class="markdown-stub" :data-mode="mode" :data-message-id="messageId" :data-thread-id="threadId" :data-link-source="linkContext?.source" :data-link-session-id="linkContext?.sessionId" :data-smooth-streaming="String(smoothStreaming)" :data-streaming="String(streaming)" :data-final="String(final)" :data-virtualize-nodes="String(virtualizeNodes)">{{ content }}</div>'
   })
 }))
 
@@ -168,12 +184,13 @@ describe('MessageBlockContent', () => {
     const markdown = wrapper.get('.markdown-stub')
     expect(markdown.attributes('data-message-id')).toBe('m3')
     expect(markdown.attributes('data-thread-id')).toBe('s3')
+    expect(markdown.attributes('data-mode')).toBe('chat')
     expect(markdown.attributes('data-link-source')).toBe('chat')
     expect(markdown.attributes('data-link-session-id')).toBe('s3')
     expect(markdown.text()).toContain('plain markdown content')
   })
 
-  it('disables smooth streaming for completed content blocks', async () => {
+  it('marks completed content blocks as final static markdown', async () => {
     const wrapper = mount(MessageBlockContent, {
       props: {
         block: createBlock({
@@ -187,7 +204,11 @@ describe('MessageBlockContent', () => {
 
     await flushPromises()
 
-    expect(wrapper.get('.markdown-stub').attributes('data-smooth-streaming')).toBe('false')
+    const markdown = wrapper.get('.markdown-stub')
+    expect(markdown.attributes('data-smooth-streaming')).toBe('false')
+    expect(markdown.attributes('data-streaming')).toBe('false')
+    expect(markdown.attributes('data-final')).toBe('true')
+    expect(markdown.attributes('data-virtualize-nodes')).toBe('true')
   })
 
   it.each(['pending', 'loading'] as const)(
@@ -206,7 +227,47 @@ describe('MessageBlockContent', () => {
 
       await flushPromises()
 
-      expect(wrapper.get('.markdown-stub').attributes('data-smooth-streaming')).toBe('true')
+      const markdown = wrapper.get('.markdown-stub')
+      expect(markdown.attributes('data-smooth-streaming')).toBe('true')
+      expect(markdown.attributes('data-streaming')).toBe('true')
+      expect(markdown.attributes('data-final')).toBe('false')
+      expect(markdown.attributes('data-virtualize-nodes')).toBe('false')
     }
   )
+
+  it('keeps all nodes mounted for searchable result messages', async () => {
+    const wrapper = mount(MessageBlockContent, {
+      props: {
+        block: createBlock({
+          status: 'success',
+          content: 'searchable markdown content'
+        }),
+        messageId: 'm6',
+        threadId: 's6',
+        isSearchResult: true
+      }
+    })
+
+    await flushPromises()
+
+    expect(wrapper.get('.markdown-stub').attributes('data-virtualize-nodes')).toBe('false')
+  })
+
+  it('keeps all nodes mounted when chat search disables markdown virtualization', async () => {
+    const wrapper = mount(MessageBlockContent, {
+      props: {
+        block: createBlock({
+          status: 'success',
+          content: 'plain markdown content'
+        }),
+        messageId: 'm7',
+        threadId: 's7',
+        disableMarkdownVirtualization: true
+      }
+    })
+
+    await flushPromises()
+
+    expect(wrapper.get('.markdown-stub').attributes('data-virtualize-nodes')).toBe('false')
+  })
 })
diff --git a/test/renderer/components/message/MessageItemAssistant.test.ts b/test/renderer/components/message/MessageItemAssistant.test.ts
index 524807ad1..20cce405d 100644
--- a/test/renderer/components/message/MessageItemAssistant.test.ts
+++ b/test/renderer/components/message/MessageItemAssistant.test.ts
@@ -194,7 +194,17 @@ describe('MessageItemAssistant', () => {
     stubs: {
       ModelIcon: componentStub('ModelIcon'),
       MessageInfo: componentStub('MessageInfo'),
-      MessageBlockContent: componentStub('MessageBlockContent'),
+      MessageBlockContent: defineComponent({
+        name: 'MessageBlockContent',
+        props: {
+          disableMarkdownVirtualization: {
+            type: Boolean,
+            default: false
+          }
+        },
+        template:
+          '<div data-testid="message-block-content" :data-disable-markdown-virtualization="String(disableMarkdownVirtualization)"><slot /></div>'
+      }),
       MessageBlockThink: componentStub('MessageBlockThink'),
       MessageBlockToolCall: componentStub('MessageBlockToolCall'),
       MessageBlockError: componentStub('MessageBlockError'),
@@ -250,6 +260,56 @@ describe('MessageItemAssistant', () => {
     })
 
     expect(wrapper.find('[data-testid="spinner"]').exists()).toBe(true)
+    expect(wrapper.find('[data-message-content="true"]').exists()).toBe(true)
+  })
+
+  it('keeps the message content wrapper stable when the first pending content arrives', async () => {
+    const wrapper = mount(MessageItemAssistant, {
+      props: {
+        message: createMessage('pending', []),
+        isCapturingImage: false
+      },
+      global
+    })
+    const contentWrapper = wrapper.find('[data-message-content="true"]').element
+
+    await wrapper.setProps({
+      message: createMessage('pending', [
+        {
+          type: 'content',
+          content: 'first chunk',
+          status: 'loading',
+          timestamp: 2
+        }
+      ])
+    })
+
+    expect(wrapper.find('[data-testid="spinner"]').exists()).toBe(false)
+    expect(wrapper.find('[data-message-content="true"]').element).toBe(contentWrapper)
+  })
+
+  it('passes markdown virtualization disable state to message content blocks', () => {
+    const wrapper = mount(MessageItemAssistant, {
+      props: {
+        message: createMessage('pending', [
+          {
+            type: 'content',
+            content: 'visible content',
+            status: 'loading',
+            timestamp: 2
+          }
+        ]),
+        isCapturingImage: false,
+        disableMarkdownVirtualization: true
+      },
+      global
+    })
+
+    expect(
+      wrapper
+        .get('[data-testid="message-block-content"]')
+        .attributes('data-disable-markdown-virtualization')
+    ).toBe('true')
   })
 
   it('renders video blocks from legacy content urls', () => {
diff --git a/test/renderer/composables/useMessageWindow.test.ts b/test/renderer/composables/useMessageWindow.test.ts
index 7483a5beb..bdc9503c8 100644
--- a/test/renderer/composables/useMessageWindow.test.ts
+++ b/test/renderer/composables/useMessageWindow.test.ts
@@ -40,6 +40,52 @@ const createUserMessage = (id: string, orderSeq: number, text = 'hello'): Messag
   }
 })
 
+const createPendingAssistantPlaceholder = (): MessageListItem => ({
+  id: '__pending_assistant_1',
+  role: 'assistant',
+  timestamp: 1,
+  updatedAt: 1,
+  avatar: '',
+  name: 'Assistant',
+  model_name: 'Assistant',
+  model_id: 'model-1',
+  model_provider: 'provider-1',
+  status: 'pending',
+  error: '',
+  usage,
+  conversationId: 'session-1',
+  is_variant: 0,
+  orderSeq: 1,
+  content: []
+})
+
+const createStreamingAssistant = (): MessageListItem => ({
+  id: 'assistant-real-1',
+  renderKey: '__pending_assistant_1',
+  role: 'assistant',
+  timestamp: 2,
+  updatedAt: 2,
+  avatar: '',
+  name: 'Assistant',
+  model_name: 'Assistant',
+  model_id: 'model-1',
+  model_provider: 'provider-1',
+  status: 'pending',
+  error: '',
+  usage,
+  conversationId: 'session-1',
+  is_variant: 0,
+  orderSeq: 1,
+  content: [
+    {
+      type: 'content',
+      content: 'hello',
+      status: 'loading',
+      timestamp: 2
+    }
+  ]
+})
+
 const createMessages = (count: number): MessageListItem[] =>
   Array.from({ length: count }, (_, index) => createUserMessage(`message-${index}`, index))
 
@@ -86,6 +132,29 @@ describe('useMessageWindow', () => {
     expect(entry1!.top).toBe(entry0!.bottom)
   })
 
+  it('estimates pending assistant placeholder near its spinner row height', () => {
+    const messages = ref([createPendingAssistantPlaceholder()])
+    const window = useMessageWindow({ messages })
+
+    const entry = window.getEntry('__pending_assistant_1')
+
+    expect(entry?.estimatedHeight).toBe(80)
+    expect(window.setMeasuredHeight('__pending_assistant_1', 78)).toBe(-2)
+  })
+
+  it('reuses a pending placeholder measurement through the real streaming row render key', () => {
+    const messages = ref([createPendingAssistantPlaceholder()])
+    const window = useMessageWindow({ messages })
+
+    expect(window.setMeasuredHeight('__pending_assistant_1', 78)).toBe(-2)
+
+    messages.value = [createStreamingAssistant()]
+
+    const entry = window.getEntry('assistant-real-1')
+    expect(entry?.measuredHeight).toBe(78)
+    expect(entry?.bottom).toBe(78)
+  })
+
   it('clearMeasurements resets to estimated heights', () => {
     const messages = ref(createMessages(1))
     const window = useMessageWindow({ messages })