perf(components): use Streamdown static mode for finished markdown

packages/components/src/components/ai-gui/AGENTS.md

@@ -93,7 +93,7 @@ File-by-file ownership and coverage pointers: [README.md](README.md).
 - Conversation font size is a bounded integer pixel value. Scale body, headings,
   dense monospace, terminal output, and collapsed height through
   `conversation-font-size-classes.ts`; settings own legacy preset migration.
-  Keep Streamdown in streaming mode, but never enable word-level `animated`.
+  Streamdown mode is streaming while growing or a fence is open; never word-level `animated`.
 - A Mermaid diagram opens in `mermaid-diagram-viewer.tsx`, never Streamdown's own
   full-screen overlay (`controls.mermaid.fullscreen` stays off). Keep three
   properties: controls padded by the `--safe-area-*` variables rather than a fixed

packages/components/src/components/ai-gui/markdown-renderer.tsx

@@ -58,6 +58,7 @@ import { useResolvedTheme } from '../../theme-provider';
 import type { ConversationFontSize } from '@/atoms/settings';
 import { useTaskImageUrl } from '@/hooks/use-task-image';
 import { MarkdownDiffBlock } from './markdown-diff-block';
+import { resolveMarkdownStreamdownMode } from './markdown-streamdown-mode';
 import { createMarkdownMermaidConfig, createMarkdownMermaidPlugin } from './markdown-mermaid';
 import { MermaidDiagramViewer, type MermaidDiagramSelection } from './mermaid-diagram-viewer';
 
@@ -1409,7 +1410,7 @@ export const MarkdownRenderer = memo(function MarkdownRenderer({
           // remount when raw-HTML mode or Mermaid theme changes so sanitized
           // rendering and diagram colors update correctly.
           key={streamdownKey}
-          mode="streaming"
+          mode={resolveMarkdownStreamdownMode(isStreaming, normalizedText)}
           className="space-y-0"
           controls={STREAMDOWN_CONTROLS}
           isAnimating={isStreaming}

packages/components/src/components/ai-gui/markdown-streamdown-mode.ts

@@ -0,0 +1,31 @@
+const FENCE_LINE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+
+export function markdownHasUnclosedFence(text: string): boolean {
+  let open: { char: string; len: number } | null = null;
+  for (const raw of text.split('\n')) {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+    const match = FENCE_LINE.exec(line);
+    if (!match) continue;
+    const marker = match[2];
+    const char = marker[0];
+    const len = marker.length;
+    const info = match[3];
+    if (!open) {
+      if (char === '`' && info.includes('`')) continue;
+      open = { char, len };
+      continue;
+    }
+    if (char === open.char && len >= open.len && info.trim() === '') {
+      open = null;
+    }
+  }
+  return open !== null;
+}
+
+export function resolveMarkdownStreamdownMode(
+  isStreaming: boolean,
+  text = ''
+): 'static' | 'streaming' {
+  if (isStreaming || markdownHasUnclosedFence(text)) return 'streaming';
+  return 'static';
+}

packages/components/tests/markdown-streamdown-mode.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveMarkdownStreamdownMode } from '../src/components/ai-gui/markdown-streamdown-mode';
+
+describe('resolveMarkdownStreamdownMode', () => {
+  it('uses static mode for finished complete markdown', () => {
+    expect(resolveMarkdownStreamdownMode(false, 'Hello **world**.')).toBe('static');
+  });
+
+  it('uses streaming mode while a turn is still growing', () => {
+    expect(resolveMarkdownStreamdownMode(true, 'Hello **wor')).toBe('streaming');
+  });
+
+  it('keeps streaming mode for a finished turn with an unclosed fence', () => {
+    expect(resolveMarkdownStreamdownMode(false, '```ts\nconst x = 1;\n')).toBe('streaming');
+  });
+
+  it('keeps streaming mode for an unclosed indented backtick fence', () => {
+    expect(resolveMarkdownStreamdownMode(false, '1. example:\n   ```ts\n   const x = 1;\n')).toBe(
+      'streaming'
+    );
+  });
+
+  it('keeps streaming mode for an unclosed tilde fence', () => {
+    expect(resolveMarkdownStreamdownMode(false, '~~~js\nconst x = 1;\n')).toBe('streaming');
+  });
+
+  it('uses static mode when an indented fence is closed', () => {
+    expect(
+      resolveMarkdownStreamdownMode(false, '1. example:\n   ```ts\n   const x = 1;\n   ```\n')
+    ).toBe('static');
+  });
+
+  it('does not treat a 4-space indent as a fence', () => {
+    expect(resolveMarkdownStreamdownMode(false, '    ```ts\n    const x = 1;\n')).toBe('static');
+  });
+
+  it('keeps streaming mode when a shorter closer cannot end a longer fence', () => {
+    expect(resolveMarkdownStreamdownMode(false, '````ts\nconst x = 1;\n```\n')).toBe('streaming');
+  });
+});