@xelauvas/xela-cli 0.1.0

package/src/components/Messages.tsx

@@ -0,0 +1,834 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import chalk from 'chalk';
+import type { UUID } from 'crypto';
+import type { RefObject } from 'react';
+import * as React from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { every } from 'src/utils/set.js';
+import { getIsRemoteMode } from '../bootstrap/state.js';
+import type { Command } from '../commands.js';
+import { BLACK_CIRCLE } from '../constants/figures.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';
+import { useTerminalNotification } from '../ink/useTerminalNotification.js';
+import { Box, Text } from '../ink.js';
+import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';
+import type { Screen } from '../screens/REPL.js';
+import type { Tools } from '../Tool.js';
+import { findToolByName } from '../Tool.js';
+import type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js';
+import type { Message as MessageType, NormalizedMessage, ProgressMessage as ProgressMessageType, RenderableMessage } from '../types/message.js';
+import { type AdvisorBlock, isAdvisorBlock } from '../utils/advisor.js';
+import { collapseBackgroundBashNotifications } from '../utils/collapseBackgroundBashNotifications.js';
+import { collapseHookSummaries } from '../utils/collapseHookSummaries.js';
+import { collapseReadSearchGroups } from '../utils/collapseReadSearch.js';
+import { collapseTeammateShutdowns } from '../utils/collapseTeammateShutdowns.js';
+import { getGlobalConfig } from '../utils/config.js';
+import { isEnvTruthy } from '../utils/envUtils.js';
+import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
+import { applyGrouping } from '../utils/groupToolUses.js';
+import { buildMessageLookups, createAssistantMessage, deriveUUID, getMessagesAfterCompactBoundary, getToolUseID, getToolUseIDs, hasUnresolvedHooksFromLookup, isNotEmptyMessage, normalizeMessages, reorderMessagesInUI, type StreamingThinking, type StreamingToolUse, shouldShowUserMessage } from '../utils/messages.js';
+import { plural } from '../utils/stringUtils.js';
+import { renderableSearchText } from '../utils/transcriptSearch.js';
+import { Divider } from './design-system/Divider.js';
+import type { UnseenDivider } from './FullscreenLayout.js';
+import { LogoV2 } from './LogoV2/LogoV2.js';
+import { StreamingMarkdown } from './Markdown.js';
+import { hasContentAfterIndex, MessageRow } from './MessageRow.js';
+import { InVirtualListContext, type MessageActionsNav, MessageActionsSelectedContext, type MessageActionsState } from './messageActions.js';
+import { AssistantThinkingMessage } from './messages/AssistantThinkingMessage.js';
+import { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js';
+import { OffscreenFreeze } from './OffscreenFreeze.js';
+import type { ToolUseConfirm } from './permissions/PermissionRequest.js';
+import { StatusNotices } from './StatusNotices.js';
+import type { JumpHandle } from './VirtualMessageList.js';
+
+// Memoed logo header: this box is the FIRST sibling before all MessageRows
+// in main-screen mode. If it becomes dirty on every Messages re-render,
+// renderChildren's seenDirtyChild cascade disables prevScreen (blit) for
+// ALL subsequent siblings — every MessageRow re-writes from scratch instead
+// of blitting. In long sessions (~2800 messages) this is 150K+ writes/frame
+// and pegs CPU at 100%. Memo on agentDefinitions so a new messages array
+// doesn't invalidate the logo subtree. LogoV2/StatusNotices internally
+// subscribe to useAppState/useSettings for their own updates.
+const LogoHeader = React.memo(function LogoHeader(t0) {
+  const $ = _c(3);
+  const {
+    agentDefinitions
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <LogoV2 />;
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  let t2;
+  if ($[1] !== agentDefinitions) {
+    t2 = <OffscreenFreeze><Box flexDirection="column" gap={1}>{t1}<React.Suspense fallback={null}><StatusNotices agentDefinitions={agentDefinitions} /></React.Suspense></Box></OffscreenFreeze>;
+    $[1] = agentDefinitions;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+});
+
+// Dead code elimination: conditional import for proactive mode
+/* eslint-disable @typescript-eslint/no-require-imports */
+const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;
+const BRIEF_TOOL_NAME: string | null = feature('KAIROS') || feature('KAIROS_BRIEF') ? (require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')).BRIEF_TOOL_NAME : null;
+const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS') ? (require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')).SEND_USER_FILE_TOOL_NAME : null;
+
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { VirtualMessageList } from './VirtualMessageList.js';
+
+/**
+ * In brief-only mode, filter messages to show ONLY Brief tool_use blocks,
+ * their tool_results, and real user input. All assistant text is dropped —
+ * if the model forgets to call Brief, the user sees nothing for that turn.
+ * That's on the model to get right; the filter does not second-guess it.
+ */
+export function filterForBriefTool<T extends {
+  type: string;
+  subtype?: string;
+  isMeta?: boolean;
+  isApiErrorMessage?: boolean;
+  message?: {
+    content: Array<{
+      type: string;
+      name?: string;
+      tool_use_id?: string;
+    }>;
+  };
+  attachment?: {
+    type: string;
+    isMeta?: boolean;
+    origin?: unknown;
+    commandMode?: string;
+  };
+}>(messages: T[], briefToolNames: string[]): T[] {
+  const nameSet = new Set(briefToolNames);
+  // tool_use always precedes its tool_result in the array, so we can collect
+  // IDs and match against them in a single pass.
+  const briefToolUseIDs = new Set<string>();
+  return messages.filter(msg => {
+    // System messages (attach confirmation, remote errors, compact boundaries)
+    // must stay visible — dropping them leaves the viewer with no feedback.
+    // Exception: api_metrics is per-turn debug noise (TTFT, config writes,
+    // hook timing) that defeats the point of brief mode. Still visible in
+    // transcript mode (ctrl+o) which bypasses this filter.
+    if (msg.type === 'system') return msg.subtype !== 'api_metrics';
+    const block = msg.message?.content[0];
+    if (msg.type === 'assistant') {
+      // API error messages (auth failures, rate limits, etc.) must stay visible
+      if (msg.isApiErrorMessage) return true;
+      // Keep Brief tool_use blocks (renders with standard tool call chrome,
+      // and must be in the list so buildMessageLookups can resolve tool results)
+      if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) {
+        if ('id' in block) {
+          briefToolUseIDs.add((block as {
+            id: string;
+          }).id);
+        }
+        return true;
+      }
+      return false;
+    }
+    if (msg.type === 'user') {
+      if (block?.type === 'tool_result') {
+        return block.tool_use_id !== undefined && briefToolUseIDs.has(block.tool_use_id);
+      }
+      // Real user input only — drop meta/tick messages.
+      return !msg.isMeta;
+    }
+    if (msg.type === 'attachment') {
+      // Human input drained mid-turn arrives as a queued_command attachment
+      // (query.ts mid-chain drain → getQueuedCommandAttachments). Keep it —
+      // it's what the user typed. commandMode === 'prompt' positively
+      // identifies human-typed input; task-notification callers set
+      // mode: 'task-notification' but not origin/isMeta, so the positive
+      // commandMode check is required to exclude them.
+      const att = msg.attachment;
+      return att?.type === 'queued_command' && att.commandMode === 'prompt' && !att.isMeta && att.origin === undefined;
+    }
+    return false;
+  });
+}
+
+/**
+ * Full-transcript companion to filterForBriefTool. When the Brief tool is
+ * in use, the model's text output is redundant with the SendUserMessage
+ * content it wrote right after — drop the text so only the SendUserMessage
+ * block shows. Tool calls and their results stay visible.
+ *
+ * Per-turn: only drops text in turns that actually called Brief. If the
+ * model forgets, text still shows — otherwise the user would see nothing.
+ */
+export function dropTextInBriefTurns<T extends {
+  type: string;
+  isMeta?: boolean;
+  message?: {
+    content: Array<{
+      type: string;
+      name?: string;
+    }>;
+  };
+}>(messages: T[], briefToolNames: string[]): T[] {
+  const nameSet = new Set(briefToolNames);
+  // First pass: find which turns (bounded by non-meta user messages) contain
+  // a Brief tool_use. Tag each assistant text block with its turn index.
+  const turnsWithBrief = new Set<number>();
+  const textIndexToTurn: number[] = [];
+  let turn = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]!;
+    const block = msg.message?.content[0];
+    if (msg.type === 'user' && block?.type !== 'tool_result' && !msg.isMeta) {
+      turn++;
+      continue;
+    }
+    if (msg.type === 'assistant') {
+      if (block?.type === 'text') {
+        textIndexToTurn[i] = turn;
+      } else if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) {
+        turnsWithBrief.add(turn);
+      }
+    }
+  }
+  if (turnsWithBrief.size === 0) return messages;
+  // Second pass: drop text blocks whose turn called Brief.
+  return messages.filter((_, i) => {
+    const t = textIndexToTurn[i];
+    return t === undefined || !turnsWithBrief.has(t);
+  });
+}
+type Props = {
+  messages: MessageType[];
+  tools: Tools;
+  commands: Command[];
+  verbose: boolean;
+  toolJSX: {
+    jsx: React.ReactNode | null;
+    shouldHidePromptInput: boolean;
+    shouldContinueAnimation?: true;
+  } | null;
+  toolUseConfirmQueue: ToolUseConfirm[];
+  inProgressToolUseIDs: Set<string>;
+  isMessageSelectorVisible: boolean;
+  conversationId: string;
+  screen: Screen;
+  streamingToolUses: StreamingToolUse[];
+  showAllInTranscript?: boolean;
+  agentDefinitions?: AgentDefinitionsResult;
+  onOpenRateLimitOptions?: () => void;
+  /** Hide the logo/header - used for subagent zoom view */
+  hideLogo?: boolean;
+  isLoading: boolean;
+  /** In transcript mode, hide all thinking blocks except the last one */
+  hidePastThinking?: boolean;
+  /** Streaming thinking content (live updates, not frozen) */
+  streamingThinking?: StreamingThinking | null;
+  /** Streaming text preview (rendered as last item so transition to final message is positionally seamless) */
+  streamingText?: string | null;
+  /** When true, only show Brief tool output (hide everything else) */
+  isBriefOnly?: boolean;
+  /** Fullscreen-mode "─── N new ───" divider. Renders before the first
+   *  renderableMessage derived from firstUnseenUuid (matched by the 24-char
+   *  prefix that deriveUUID preserves). */
+  unseenDivider?: UnseenDivider;
+  /** Fullscreen-mode ScrollBox handle. Enables React-level virtualization when present. */
+  scrollRef?: RefObject<ScrollBoxHandle | null>;
+  /** Fullscreen-mode: enable sticky-prompt tracking (writes via ScrollChromeContext). */
+  trackStickyPrompt?: boolean;
+  /** Transcript search: jump-to-index + setSearchQuery/nextMatch/prevMatch. */
+  jumpRef?: RefObject<JumpHandle | null>;
+  /** Transcript search: fires when match count/position changes. */
+  onSearchMatchesChange?: (count: number, current: number) => void;
+  /** Paint an existing DOM subtree to fresh Screen, scan. Element comes
+   *  from the main tree (all real providers). Message-relative positions. */
+  scanElement?: (el: import('../ink/dom.js').DOMElement) => import('../ink/render-to-screen.js').MatchPosition[];
+  /** Position-based CURRENT highlight. positions stable (msg-relative),
+   *  rowOffset tracks scroll. null clears. */
+  setPositions?: (state: {
+    positions: import('../ink/render-to-screen.js').MatchPosition[];
+    rowOffset: number;
+    currentIdx: number;
+  } | null) => void;
+  /** Bypass MAX_MESSAGES_WITHOUT_VIRTUALIZATION. For one-shot headless renders
+   *  (e.g. /export via renderToString) where the memory concern doesn't apply
+   *  and the "already in scrollback" justification doesn't hold. */
+  disableRenderCap?: boolean;
+  /** In-transcript cursor; expanded overrides verbose for selected message. */
+  cursor?: MessageActionsState | null;
+  setCursor?: (cursor: MessageActionsState | null) => void;
+  /** Passed through to VirtualMessageList (heightCache owns visibility). */
+  cursorNavRef?: React.Ref<MessageActionsNav>;
+  /** Render only collapsed.slice(start, end). For chunked headless export
+   *  (streamRenderedMessages in exportRenderer.tsx): prep runs on the FULL
+   *  messages array so grouping/lookups are correct, but only this slice
+   *  chunk instead of the full session. The logo renders only for chunk 0
+   *  (start === 0); later chunks are mid-stream continuations.
+   *  Measured Mar 2026: 538-msg session, 20 slices → −55% plateau RSS. */
+  renderRange?: readonly [start: number, end: number];
+};
+const MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE = 30;
+
+// Safety cap for the non-virtualized render path (fullscreen off or
+// explicitly disabled). Ink mounts a full fiber tree per message (~250 KB
+// RSS each); yoga layout height grows unbounded; the screen buffer is sized
+// to fit every line. At ~2000 messages this is ~3000-line screens, ~500 MB
+// of fibers, and per-frame write costs that push the process into a GC
+// death spiral (observed: 59 GB RSS, 14k mmap/munmap/sec). Content dropped
+// from this slice has already been printed to terminal scrollback — users
+// can still scroll up natively. VirtualMessageList (the default ant path)
+// bypasses this cap entirely. Headless one-shot renders (e.g. /export)
+// pass disableRenderCap to opt out — they have no scrollback and the
+// memory concern doesn't apply to renderToString.
+//
+// The slice boundary is tracked as a UUID anchor, not a count-derived
+// index. Count-based slicing (slice(-200)) drops one message from the
+// front on every append, shifting scrollback content and forcing a full
+// terminal reset per turn (CC-941). Quantizing to 50-message steps
+// (CC-1154) helped but still shifted on compaction and collapse regrouping
+// since those change collapsed.length without adding messages. The UUID
+// anchor only advances when rendered count genuinely exceeds CAP+STEP —
+// immune to length churn from grouping/compaction (CC-1174).
+//
+// The anchor stores BOTH uuid and index. Some uuids are unstable between
+// renders: collapseHookSummaries derives the merged uuid from the first
+// summary in a group, but reorderMessagesInUI reshuffles hook adjacency
+// as tool results stream in, changing which summary is first. When the
+// uuid vanishes, falling back to the stored index (clamped) keeps the
+// slice roughly where it was instead of resetting to 0 — which would
+// jump from ~200 rendered messages to the full history, orphaning
+// in-progress badge snapshots in scrollback.
+const MAX_MESSAGES_WITHOUT_VIRTUALIZATION = 200;
+const MESSAGE_CAP_STEP = 50;
+export type SliceAnchor = {
+  uuid: string;
+  idx: number;
+} | null;
+
+/** Exported for testing. Mutates anchorRef when the window needs to advance. */
+export function computeSliceStart(collapsed: ReadonlyArray<{
+  uuid: string;
+}>, anchorRef: {
+  current: SliceAnchor;
+}, cap = MAX_MESSAGES_WITHOUT_VIRTUALIZATION, step = MESSAGE_CAP_STEP): number {
+  const anchor = anchorRef.current;
+  const anchorIdx = anchor ? collapsed.findIndex(m => m.uuid === anchor.uuid) : -1;
+  // Anchor found → use it. Anchor lost → fall back to stored index
+  // (clamped) so collapse-regrouping uuid churn doesn't reset to 0.
+  let start = anchorIdx >= 0 ? anchorIdx : anchor ? Math.min(anchor.idx, Math.max(0, collapsed.length - cap)) : 0;
+  if (collapsed.length - start > cap + step) {
+    start = collapsed.length - cap;
+  }
+  // Refresh anchor from whatever lives at the current start — heals a
+  // stale uuid after fallback and captures a new one after advancement.
+  const msgAtStart = collapsed[start];
+  if (msgAtStart && (anchor?.uuid !== msgAtStart.uuid || anchor.idx !== start)) {
+    anchorRef.current = {
+      uuid: msgAtStart.uuid,
+      idx: start
+    };
+  } else if (!msgAtStart && anchor) {
+    anchorRef.current = null;
+  }
+  return start;
+}
+const MessagesImpl = ({
+  messages,
+  tools,
+  commands,
+  verbose,
+  toolJSX,
+  toolUseConfirmQueue,
+  inProgressToolUseIDs,
+  isMessageSelectorVisible,
+  conversationId,
+  screen,
+  streamingToolUses,
+  showAllInTranscript = false,
+  agentDefinitions,
+  onOpenRateLimitOptions,
+  hideLogo = false,
+  isLoading,
+  hidePastThinking = false,
+  streamingThinking,
+  streamingText,
+  isBriefOnly = false,
+  unseenDivider,
+  scrollRef,
+  trackStickyPrompt,
+  jumpRef,
+  onSearchMatchesChange,
+  scanElement,
+  setPositions,
+  disableRenderCap = false,
+  cursor = null,
+  setCursor,
+  cursorNavRef,
+  renderRange
+}: Props): React.ReactNode => {
+  const {
+    columns
+  } = useTerminalSize();
+  const toggleShowAllShortcut = useShortcutDisplay('transcript:toggleShowAll', 'Transcript', 'Ctrl+E');
+  const normalizedMessages = useMemo(() => normalizeMessages(messages).filter(isNotEmptyMessage), [messages]);
+
+  // Check if streaming thinking should be visible (streaming or within 30s timeout)
+  const isStreamingThinkingVisible = useMemo(() => {
+    if (!streamingThinking) return false;
+    if (streamingThinking.isStreaming) return true;
+    if (streamingThinking.streamingEndedAt) {
+      return Date.now() - streamingThinking.streamingEndedAt < 30000;
+    }
+    return false;
+  }, [streamingThinking]);
+
+  // Find the last thinking block (message UUID + content index) for hiding past thinking in transcript mode
+  // When streaming thinking is visible, use a special ID that won't match any completed thinking block
+  // With adaptive thinking, only consider thinking blocks from the current turn and stop searching once we
+  // hit the last user message.
+  const lastThinkingBlockId = useMemo(() => {
+    if (!hidePastThinking) return null;
+    // If streaming thinking is visible, hide all completed thinking blocks by using a non-matching ID
+    if (isStreamingThinkingVisible) return 'streaming';
+    // Iterate backwards to find the last message with a thinking block
+    for (let i = normalizedMessages.length - 1; i >= 0; i--) {
+      const msg = normalizedMessages[i];
+      if (msg?.type === 'assistant') {
+        const content = msg.message.content;
+        // Find the last thinking block in this message
+        for (let j = content.length - 1; j >= 0; j--) {
+          if (content[j]?.type === 'thinking') {
+            return `${msg.uuid}:${j}`;
+          }
+        }
+      } else if (msg?.type === 'user') {
+        const hasToolResult = msg.message.content.some(block => block.type === 'tool_result');
+        if (!hasToolResult) {
+          // Reached a previous user turn so don't show stale thinking from before
+          return 'no-thinking';
+        }
+      }
+    }
+    return null;
+  }, [normalizedMessages, hidePastThinking, isStreamingThinkingVisible]);
+
+  // Find the latest user bash output message (from ! commands)
+  // This allows us to show full output for the most recent bash command
+  const latestBashOutputUUID = useMemo(() => {
+    // Iterate backwards to find the last user message with bash output
+    for (let i_0 = normalizedMessages.length - 1; i_0 >= 0; i_0--) {
+      const msg_0 = normalizedMessages[i_0];
+      if (msg_0?.type === 'user') {
+        const content_0 = msg_0.message.content;
+        // Check if any text content is bash output
+        for (const block_0 of content_0) {
+          if (block_0.type === 'text') {
+            const text = block_0.text;
+            if (text.startsWith('<bash-stdout') || text.startsWith('<bash-stderr')) {
+              return msg_0.uuid;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }, [normalizedMessages]);
+
+  // streamingToolUses updates on every input_json_delta while normalizedMessages
+  // stays stable — precompute the Set so the filter is O(k) not O(n×k) per chunk.
+  const normalizedToolUseIDs = useMemo(() => getToolUseIDs(normalizedMessages), [normalizedMessages]);
+  const streamingToolUsesWithoutInProgress = useMemo(() => streamingToolUses.filter(stu => !inProgressToolUseIDs.has(stu.contentBlock.id) && !normalizedToolUseIDs.has(stu.contentBlock.id)), [streamingToolUses, inProgressToolUseIDs, normalizedToolUseIDs]);
+  const syntheticStreamingToolUseMessages = useMemo(() => streamingToolUsesWithoutInProgress.flatMap(streamingToolUse => {
+    const msg_1 = createAssistantMessage({
+      content: [streamingToolUse.contentBlock]
+    });
+    // Override randomUUID with deterministic value derived from content
+    // block ID to prevent React key changes on every memo recomputation.
+    // Same class of bug fixed in normalizeMessages (commit 383326e613):
+    // fresh randomUUID → unstable React keys → component remounts →
+    // Ink rendering corruption (overlapping text from stale DOM nodes).
+    msg_1.uuid = deriveUUID(streamingToolUse.contentBlock.id as UUID, 0);
+    return normalizeMessages([msg_1]);
+  }), [streamingToolUsesWithoutInProgress]);
+  const isTranscriptMode = screen === 'transcript';
+  // Hoisted to mount-time — this component re-renders on every scroll.
+  const disableVirtualScroll = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
+  // Virtual scroll replaces the transcript cap: everything is scrollable and
+  // memory is bounded by the mounted-item count, not the total. scrollRef is
+  // only passed when isFullscreenEnvEnabled() is true (REPL.tsx gates it),
+  // so scrollRef's presence is the signal.
+  const virtualScrollRuntimeGate = scrollRef != null && !disableVirtualScroll;
+  const shouldTruncate = isTranscriptMode && !showAllInTranscript && !virtualScrollRuntimeGate;
+
+  // Anchor for the first rendered message in the non-virtualized cap slice.
+  // Monotonic advance only — mutation during render is idempotent (safe
+  // under StrictMode double-render). See MAX_MESSAGES_WITHOUT_VIRTUALIZATION
+  // comment above for why this replaced count-based slicing.
+  const sliceAnchorRef = useRef<SliceAnchor>(null);
+
+  // Expensive message transforms — filter, reorder, group, collapse, lookups.
+  // All O(n) over 27k messages. Split from the renderRange slice so scrolling
+  // (which only changes renderRange) doesn't re-run these. Previously this
+  // useMemo included renderRange → every scroll rebuilt 6 Maps over 27k
+  // messages + 4 filter/map passes = ~50ms alloc per scroll → GC pressure →
+  // 100-173ms stop-the-world pauses on the 1GB heap.
+  const {
+    collapsed: collapsed_0,
+    lookups: lookups_0,
+    hasTruncatedMessages: hasTruncatedMessages_0,
+    hiddenMessageCount: hiddenMessageCount_0
+  } = useMemo(() => {
+    // In fullscreen mode the alt buffer has no native scrollback, so the
+    // compact-boundary filter just hides history the ScrollBox could
+    // otherwise scroll to. Main-screen mode keeps the filter — pre-compact
+    // rows live above the viewport in native scrollback there, and
+    // re-rendering them triggers full resets.
+    // includeSnipped: UI rendering keeps snipped messages for scrollback
+    // (this PR's core goal — full history in UI, filter only for the model).
+    // Also avoids a UUID mismatch: normalizeMessages derives new UUIDs, so
+    // projectSnippedView's check against original removedUuids would fail.
+    const compactAwareMessages = verbose || isFullscreenEnvEnabled() ? normalizedMessages : getMessagesAfterCompactBoundary(normalizedMessages, {
+      includeSnipped: true
+    });
+    const messagesToShowNotTruncated = reorderMessagesInUI(compactAwareMessages.filter((msg_2): msg_2 is Exclude<NormalizedMessage, ProgressMessageType> => msg_2.type !== 'progress')
+    // CC-724: drop attachment messages that AttachmentMessage renders as
+    // null (hook_success, hook_additional_context, hook_cancelled, etc.)
+    // BEFORE counting/slicing so they don't inflate the "N messages"
+    // count in ctrl-o or consume slots in the 200-message render cap.
+    .filter(msg_3 => !isNullRenderingAttachment(msg_3)).filter(_ => shouldShowUserMessage(_, isTranscriptMode)), syntheticStreamingToolUseMessages);
+    // Three-tier filtering. Transcript mode (ctrl+o screen) is truly unfiltered.
+    // Brief-only: SendUserMessage + user input only. Default: drop redundant
+    // assistant text in turns where SendUserMessage was called (the model's
+    // text is working-notes that duplicate the SendUserMessage content).
+    const briefToolNames = [BRIEF_TOOL_NAME, SEND_USER_FILE_TOOL_NAME].filter((n): n is string => n !== null);
+    // dropTextInBriefTurns should only trigger on SendUserMessage turns —
+    // SendUserFile delivers a file without replacement text, so dropping
+    // assistant text for file-only turns would leave the user with no context.
+    const dropTextToolNames = [BRIEF_TOOL_NAME].filter((n_0): n_0 is string => n_0 !== null);
+    const briefFiltered = briefToolNames.length > 0 && !isTranscriptMode ? isBriefOnly ? filterForBriefTool(messagesToShowNotTruncated, briefToolNames) : dropTextToolNames.length > 0 ? dropTextInBriefTurns(messagesToShowNotTruncated, dropTextToolNames) : messagesToShowNotTruncated : messagesToShowNotTruncated;
+    const messagesToShow = shouldTruncate ? briefFiltered.slice(-MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE) : briefFiltered;
+    const hasTruncatedMessages = shouldTruncate && briefFiltered.length > MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE;
+    const {
+      messages: groupedMessages
+    } = applyGrouping(messagesToShow, tools, verbose);
+    const collapsed = collapseBackgroundBashNotifications(collapseHookSummaries(collapseTeammateShutdowns(collapseReadSearchGroups(groupedMessages, tools))), verbose);
+    const lookups = buildMessageLookups(normalizedMessages, messagesToShow);
+    const hiddenMessageCount = messagesToShowNotTruncated.length - MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE;
+    return {
+      collapsed,
+      lookups,
+      hasTruncatedMessages,
+      hiddenMessageCount
+    };
+  }, [verbose, normalizedMessages, isTranscriptMode, syntheticStreamingToolUseMessages, shouldTruncate, tools, isBriefOnly]);
+
+  // Cheap slice — only runs when scroll range or slice config changes.
+  const renderableMessages = useMemo(() => {
+    // Safety cap for the non-virtualized render path. Applied here (not at
+    // the JSX site) so renderMessageRow's index-based lookups and
+    // dividerBeforeIndex compute on the same array. VirtualMessageList
+    // never sees this slice — virtualScrollRuntimeGate is constant for the
+    // component's lifetime (scrollRef is either always passed or never).
+    // renderRange is first: the chunked export path slices the
+    // post-grouping array so each chunk gets correct tool-call grouping.
+    const capApplies = !virtualScrollRuntimeGate && !disableRenderCap;
+    const sliceStart = capApplies ? computeSliceStart(collapsed_0, sliceAnchorRef) : 0;
+    return renderRange ? collapsed_0.slice(renderRange[0], renderRange[1]) : sliceStart > 0 ? collapsed_0.slice(sliceStart) : collapsed_0;
+  }, [collapsed_0, renderRange, virtualScrollRuntimeGate, disableRenderCap]);
+  const streamingToolUseIDs = useMemo(() => new Set(streamingToolUses.map(__0 => __0.contentBlock.id)), [streamingToolUses]);
+
+  // Divider insertion point: first renderableMessage whose uuid shares the
+  // 24-char prefix with firstUnseenUuid (deriveUUID keeps the first 24
+  // chars of the source message uuid, so this matches any block from it).
+  const dividerBeforeIndex = useMemo(() => {
+    if (!unseenDivider) return -1;
+    const prefix = unseenDivider.firstUnseenUuid.slice(0, 24);
+    return renderableMessages.findIndex(m => m.uuid.slice(0, 24) === prefix);
+  }, [unseenDivider, renderableMessages]);
+  const selectedIdx = useMemo(() => {
+    if (!cursor) return -1;
+    return renderableMessages.findIndex(m_0 => m_0.uuid === cursor.uuid);
+  }, [cursor, renderableMessages]);
+
+  // Fullscreen: click a message to toggle verbose rendering for it. Keyed by
+  // tool_use_id where available so a tool_use and its tool_result (separate
+  // rows) expand together; falls back to uuid for groups/thinking. Stale keys
+  // are harmless — they never match anything in renderableMessages.
+  const [expandedKeys, setExpandedKeys] = useState<ReadonlySet<string>>(() => new Set());
+  const onItemClick = useCallback((msg_4: RenderableMessage) => {
+    const k = expandKey(msg_4);
+    setExpandedKeys(prev => {
+      const next = new Set(prev);
+      if (next.has(k)) next.delete(k);else next.add(k);
+      return next;
+    });
+  }, []);
+  const isItemExpanded = useCallback((msg_5: RenderableMessage) => expandedKeys.size > 0 && expandedKeys.has(expandKey(msg_5)), [expandedKeys]);
+  // Only hover/click messages where the verbose toggle reveals more:
+  // collapsed read/search groups, or tool results that self-report truncation
+  // via isResultTruncated. Callback must be stable across message updates: if
+  // its identity (or return value) flips during streaming, onMouseEnter
+  // attaches after the mouse is already inside → hover never fires. tools is
+  // session-stable; lookups is read via ref so the callback doesn't churn on
+  // every new message.
+  const lookupsRef = useRef(lookups_0);
+  lookupsRef.current = lookups_0;
+  const isItemClickable = useCallback((msg_6: RenderableMessage): boolean => {
+    if (msg_6.type === 'collapsed_read_search') return true;
+    if (msg_6.type === 'assistant') {
+      const b = msg_6.message.content[0] as unknown as AdvisorBlock | undefined;
+      return b != null && isAdvisorBlock(b) && b.type === 'advisor_tool_result' && b.content.type === 'advisor_result';
+    }
+    if (msg_6.type !== 'user') return false;
+    const b_0 = msg_6.message.content[0];
+    if (b_0?.type !== 'tool_result' || b_0.is_error || !msg_6.toolUseResult) return false;
+    const name = lookupsRef.current.toolUseByToolUseID.get(b_0.tool_use_id)?.name;
+    const tool = name ? findToolByName(tools, name) : undefined;
+    return tool?.isResultTruncated?.(msg_6.toolUseResult as never) ?? false;
+  }, [tools]);
+  const canAnimate = (!toolJSX || !!toolJSX.shouldContinueAnimation) && !toolUseConfirmQueue.length && !isMessageSelectorVisible;
+  const hasToolsInProgress = inProgressToolUseIDs.size > 0;
+
+  // Report progress to terminal (for terminals that support OSC 9;4)
+  const {
+    progress
+  } = useTerminalNotification();
+  const prevProgressState = useRef<string | null>(null);
+  const progressEnabled = getGlobalConfig().terminalProgressBarEnabled && !getIsRemoteMode() && !(proactiveModule?.isProactiveActive() ?? false);
+  useEffect(() => {
+    const state = progressEnabled ? hasToolsInProgress ? 'indeterminate' : 'completed' : null;
+    if (prevProgressState.current === state) return;
+    prevProgressState.current = state;
+    progress(state);
+  }, [progress, progressEnabled, hasToolsInProgress]);
+  useEffect(() => {
+    return () => progress(null);
+  }, [progress]);
+  const messageKey = useCallback((msg_7: RenderableMessage) => `${msg_7.uuid}-${conversationId}`, [conversationId]);
+  const renderMessageRow = (msg_8: RenderableMessage, index: number) => {
+    const prevType = index > 0 ? renderableMessages[index - 1]?.type : undefined;
+    const isUserContinuation = msg_8.type === 'user' && prevType === 'user';
+    // hasContentAfter is only consumed for collapsed_read_search groups;
+    // skip the scan for everything else. streamingText is rendered as a
+    // sibling after this map, so it's never in renderableMessages — OR it
+    // in explicitly so the group flips to past tense as soon as text starts
+    // streaming instead of waiting for the block to finalize.
+    const hasContentAfter = msg_8.type === 'collapsed_read_search' && (!!streamingText || hasContentAfterIndex(renderableMessages, index, tools, streamingToolUseIDs));
+    const k_0 = messageKey(msg_8);
+    const row = <MessageRow key={k_0} message={msg_8} isUserContinuation={isUserContinuation} hasContentAfter={hasContentAfter} tools={tools} commands={commands} verbose={verbose || isItemExpanded(msg_8) || cursor?.expanded === true && index === selectedIdx} inProgressToolUseIDs={inProgressToolUseIDs} streamingToolUseIDs={streamingToolUseIDs} screen={screen} canAnimate={canAnimate} onOpenRateLimitOptions={onOpenRateLimitOptions} lastThinkingBlockId={lastThinkingBlockId} latestBashOutputUUID={latestBashOutputUUID} columns={columns} isLoading={isLoading} lookups={lookups_0} />;
+
+    // Per-row Provider — only 2 rows re-render on selection change.
+    // Wrapped BEFORE divider branch so both return paths get it.
+    const wrapped = <MessageActionsSelectedContext.Provider key={k_0} value={index === selectedIdx}>
+        {row}
+      </MessageActionsSelectedContext.Provider>;
+    if (unseenDivider && index === dividerBeforeIndex) {
+      return [<Box key="unseen-divider" marginTop={1}>
+          <Divider title={`${unseenDivider.count} new ${plural(unseenDivider.count, 'message')}`} width={columns} color="inactive" />
+        </Box>, wrapped];
+    }
+    return wrapped;
+  };
+
+  // Search indexing: for tool_result messages, look up the Tool and use
+  // its extractSearchText — tool-owned, precise, matches what
+  // renderToolResultMessage shows. Falls back to renderableSearchText
+  // (duck-types toolUseResult) for tools that haven't implemented it,
+  // and for all non-tool-result message types. The drift-catcher test
+  // (toolSearchText.test.tsx) renders + compares to keep these in sync.
+  //
+  // A second-React-root reconcile approach was tried and ruled out
+  // (measured 3.1ms/msg, growing — flushSyncWork processes all roots;
+  // component hooks mutate shared state → main root accumulates updates).
+  const searchTextCache = useRef(new WeakMap<RenderableMessage, string>());
+  const extractSearchText = useCallback((msg_9: RenderableMessage): string => {
+    const cached = searchTextCache.current.get(msg_9);
+    if (cached !== undefined) return cached;
+    let text_0 = renderableSearchText(msg_9);
+    // If this is a tool_result message and the tool implements
+    // extractSearchText, prefer that — it's precise (tool-owned)
+    // vs renderableSearchText's field-name heuristic.
+    if (msg_9.type === 'user' && msg_9.toolUseResult && Array.isArray(msg_9.message.content)) {
+      const tr = msg_9.message.content.find(b_1 => b_1.type === 'tool_result');
+      if (tr && 'tool_use_id' in tr) {
+        const tu = lookups_0.toolUseByToolUseID.get(tr.tool_use_id);
+        const tool_0 = tu && findToolByName(tools, tu.name);
+        const extracted = tool_0?.extractSearchText?.(msg_9.toolUseResult as never);
+        // undefined = tool didn't implement → keep heuristic. Empty
+        // string = tool says "nothing to index" → respect that.
+        if (extracted !== undefined) text_0 = extracted;
+      }
+    }
+    // Cache LOWERED: setSearchQuery's hot loop indexOfs per keystroke.
+    // Lowering here (once, at warm) vs there (every keystroke) trades
+    // ~same steady-state memory for zero per-keystroke alloc. Cache
+    // GC's with messages on transcript exit. Tool methods return raw;
+    // renderableSearchText already lowercases (redundant but cheap).
+    const lowered = text_0.toLowerCase();
+    searchTextCache.current.set(msg_9, lowered);
+    return lowered;
+  }, [tools, lookups_0]);
+  return <>
+      {/* Logo */}
+      {!hideLogo && !(renderRange && renderRange[0] > 0) && <LogoHeader agentDefinitions={agentDefinitions} />}
+
+      {/* Truncation indicator */}
+      {hasTruncatedMessages_0 && <Divider title={`${toggleShowAllShortcut} to show ${chalk.bold(hiddenMessageCount_0)} previous messages`} width={columns} />}
+
+      {/* Show all indicator */}
+      {isTranscriptMode && showAllInTranscript && hiddenMessageCount_0 > 0 &&
+    // disableRenderCap (e.g. [ dump-to-scrollback) means we're uncapped
+    // as a one-shot escape hatch, not a toggle — ctrl+e is dead and
+    // nothing is actually "hidden" to restore.
+    !disableRenderCap && <Divider title={`${toggleShowAllShortcut} to hide ${chalk.bold(hiddenMessageCount_0)} previous messages`} width={columns} />}
+
+      {/* Messages - rendered as memoized MessageRow components.
+          flatMap inserts the unseen-divider as a separate keyed sibling so
+          (a) non-fullscreen renders pay no per-message Fragment wrap, and
+          (b) divider toggle in fullscreen preserves all MessageRows by key.
+          Pre-compute derived values instead of passing renderableMessages to
+          each row - React Compiler pins props in the fiber's memoCache, so
+          passing the array would accumulate every historical version
+          (~1-2MB over a 7-turn session). */}
+      {virtualScrollRuntimeGate ? <InVirtualListContext.Provider value={true}>
+          <VirtualMessageList messages={renderableMessages} scrollRef={scrollRef} columns={columns} itemKey={messageKey} renderItem={renderMessageRow} onItemClick={onItemClick} isItemClickable={isItemClickable} isItemExpanded={isItemExpanded} trackStickyPrompt={trackStickyPrompt} selectedIndex={selectedIdx >= 0 ? selectedIdx : undefined} cursorNavRef={cursorNavRef} setCursor={setCursor} jumpRef={jumpRef} onSearchMatchesChange={onSearchMatchesChange} scanElement={scanElement} setPositions={setPositions} extractSearchText={extractSearchText} />
+        </InVirtualListContext.Provider> : renderableMessages.flatMap(renderMessageRow)}
+
+      {streamingText && !isBriefOnly && <Box alignItems="flex-start" flexDirection="row" marginTop={1} width="100%">
+          <Box flexDirection="row">
+            <Box minWidth={2}>
+              <Text color="text">{BLACK_CIRCLE}</Text>
+            </Box>
+            <Box flexDirection="column">
+              <StreamingMarkdown>{streamingText}</StreamingMarkdown>
+            </Box>
+          </Box>
+        </Box>}
+
+      {isStreamingThinkingVisible && streamingThinking && !isBriefOnly && <Box marginTop={1}>
+          <AssistantThinkingMessage param={{
+        type: 'thinking',
+        thinking: streamingThinking.thinking
+      }} addMargin={false} isTranscriptMode={true} verbose={verbose} hideInTranscript={false} />
+        </Box>}
+    </>;
+};
+
+/** Key for click-to-expand: tool_use_id where available (so tool_use + its
+ *  tool_result expand together), else uuid for groups/thinking. */
+function expandKey(msg: RenderableMessage): string {
+  return (msg.type === 'assistant' || msg.type === 'user' ? getToolUseID(msg) : null) ?? msg.uuid;
+}
+
+// Custom comparator to prevent unnecessary re-renders during streaming.
+// Default React.memo does shallow comparison which fails when:
+// 1. onOpenRateLimitOptions callback is recreated (doesn't affect render output)
+// 2. streamingToolUses array is recreated on every delta, but only contentBlock matters for rendering
+// 3. streamingThinking changes on every delta - we DO want to re-render for this
+function setsEqual<T>(a: Set<T>, b: Set<T>): boolean {
+  if (a.size !== b.size) return false;
+  for (const item of a) {
+    if (!b.has(item)) return false;
+  }
+  return true;
+}
+export const Messages = React.memo(MessagesImpl, (prev, next) => {
+  const keys = Object.keys(prev) as (keyof typeof prev)[];
+  for (const key of keys) {
+    if (key === 'onOpenRateLimitOptions' || key === 'scrollRef' || key === 'trackStickyPrompt' || key === 'setCursor' || key === 'cursorNavRef' || key === 'jumpRef' || key === 'onSearchMatchesChange' || key === 'scanElement' || key === 'setPositions') continue;
+    if (prev[key] !== next[key]) {
+      if (key === 'streamingToolUses') {
+        const p = prev.streamingToolUses;
+        const n = next.streamingToolUses;
+        if (p.length === n.length && p.every((item, i) => item.contentBlock === n[i]?.contentBlock)) {
+          continue;
+        }
+      }
+      if (key === 'inProgressToolUseIDs') {
+        if (setsEqual(prev.inProgressToolUseIDs, next.inProgressToolUseIDs)) {
+          continue;
+        }
+      }
+      if (key === 'unseenDivider') {
+        const p = prev.unseenDivider;
+        const n = next.unseenDivider;
+        if (p?.firstUnseenUuid === n?.firstUnseenUuid && p?.count === n?.count) {
+          continue;
+        }
+      }
+      if (key === 'tools') {
+        const p = prev.tools;
+        const n = next.tools;
+        if (p.length === n.length && p.every((tool, i) => tool.name === n[i]?.name)) {
+          continue;
+        }
+      }
+      // streamingThinking changes frequently - always re-render when it changes
+      // (no special handling needed, default behavior is correct)
+      return false;
+    }
+  }
+  return true;
+});
+export function shouldRenderStatically(message: RenderableMessage, streamingToolUseIDs: Set<string>, inProgressToolUseIDs: Set<string>, siblingToolUseIDs: ReadonlySet<string>, screen: Screen, lookups: ReturnType<typeof buildMessageLookups>): boolean {
+  if (screen === 'transcript') {
+    return true;
+  }
+  switch (message.type) {
+    case 'attachment':
+    case 'user':
+    case 'assistant':
+      {
+        if (message.type === 'assistant') {
+          const block = message.message.content[0];
+          if (block?.type === 'server_tool_use') {
+            return lookups.resolvedToolUseIDs.has(block.id);
+          }
+        }
+        const toolUseID = getToolUseID(message);
+        if (!toolUseID) {
+          return true;
+        }
+        if (streamingToolUseIDs.has(toolUseID)) {
+          return false;
+        }
+        if (inProgressToolUseIDs.has(toolUseID)) {
+          return false;
+        }
+
+        // Check if there are any unresolved PostToolUse hooks for this tool use
+        // If so, keep the message transient so the HookProgressMessage can update
+        if (hasUnresolvedHooksFromLookup(toolUseID, 'PostToolUse', lookups)) {
+          return false;
+        }
+        return every(siblingToolUseIDs, lookups.resolvedToolUseIDs);
+      }
+    case 'system':
+      {
+        // api errors always render dynamically, since we hide
+        // them as soon as we see another non-error message.
+        return message.subtype !== 'api_error';
+      }
+    case 'grouped_tool_use':
+      {
+        const allResolved = message.messages.every(msg => {
+          const content = msg.message.content[0];
+          return content?.type === 'tool_use' && lookups.resolvedToolUseIDs.has(content.id);
+        });
+        return allResolved;
+      }
+    case 'collapsed_read_search':
+      {
+        // In prompt mode, never mark as static to prevent flicker between API turns
+        // (In transcript mode, we already returned true at the top of this function)
+        return false;
+      }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","UUID","RefObject","React","useCallback","useEffect","useMemo","useRef","useState","every","getIsRemoteMode","Command","BLACK_CIRCLE","useTerminalSize","ScrollBoxHandle","useTerminalNotification","Box","Text","useShortcutDisplay","Screen","Tools","findToolByName","AgentDefinitionsResult","Message","MessageType","NormalizedMessage","ProgressMessage","ProgressMessageType","RenderableMessage","AdvisorBlock","isAdvisorBlock","collapseBackgroundBashNotifications","collapseHookSummaries","collapseReadSearchGroups","collapseTeammateShutdowns","getGlobalConfig","isEnvTruthy","isFullscreenEnvEnabled","applyGrouping","buildMessageLookups","createAssistantMessage","deriveUUID","getMessagesAfterCompactBoundary","getToolUseID","getToolUseIDs","hasUnresolvedHooksFromLookup","isNotEmptyMessage","normalizeMessages","reorderMessagesInUI","StreamingThinking","StreamingToolUse","shouldShowUserMessage","plural","renderableSearchText","Divider","UnseenDivider","LogoV2","StreamingMarkdown","hasContentAfterIndex","MessageRow","InVirtualListContext","MessageActionsNav","MessageActionsSelectedContext","MessageActionsState","AssistantThinkingMessage","isNullRenderingAttachment","OffscreenFreeze","ToolUseConfirm","StatusNotices","JumpHandle","LogoHeader","memo","t0","$","_c","agentDefinitions","t1","Symbol","for","t2","proactiveModule","require","BRIEF_TOOL_NAME","SEND_USER_FILE_TOOL_NAME","VirtualMessageList","filterForBriefTool","type","subtype","isMeta","isApiErrorMessage","message","content","Array","name","tool_use_id","attachment","origin","commandMode","messages","T","briefToolNames","nameSet","Set","briefToolUseIDs","filter","msg","block","has","add","id","undefined","att","dropTextInBriefTurns","turnsWithBrief","textIndexToTurn","turn","i","length","size","_","t","Props","tools","commands","verbose","toolJSX","jsx","ReactNode","shouldHidePromptInput","shouldContinueAnimation","toolUseConfirmQueue","inProgressToolUseIDs","isMessageSelectorVisible","conversationId","screen","streamingToolUses","showAllInTranscript","onOpenRateLimitOptions","hideLogo","isLoading","hidePastThinking","streamingThinking","streamingText","isBriefOnly","unseenDivider","scrollRef","trackStickyPrompt","jumpRef","onSearchMatchesChange","count","current","scanElement","el","DOMElement","MatchPosition","setPositions","state","positions","rowOffset","currentIdx","disableRenderCap","cursor","setCursor","cursorNavRef","Ref","renderRange","start","end","MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE","MAX_MESSAGES_WITHOUT_VIRTUALIZATION","MESSAGE_CAP_STEP","SliceAnchor","uuid","idx","computeSliceStart","collapsed","ReadonlyArray","anchorRef","cap","step","anchor","anchorIdx","findIndex","m","Math","min","max","msgAtStart","MessagesImpl","columns","toggleShowAllShortcut","normalizedMessages","isStreamingThinkingVisible","isStreaming","streamingEndedAt","Date","now","lastThinkingBlockId","j","hasToolResult","some","latestBashOutputUUID","text","startsWith","normalizedToolUseIDs","streamingToolUsesWithoutInProgress","stu","contentBlock","syntheticStreamingToolUseMessages","flatMap","streamingToolUse","isTranscriptMode","disableVirtualScroll","process","env","CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL","virtualScrollRuntimeGate","shouldTruncate","sliceAnchorRef","lookups","hasTruncatedMessages","hiddenMessageCount","compactAwareMessages","includeSnipped","messagesToShowNotTruncated","Exclude","n","dropTextToolNames","briefFiltered","messagesToShow","slice","groupedMessages","renderableMessages","capApplies","sliceStart","streamingToolUseIDs","map","dividerBeforeIndex","prefix","firstUnseenUuid","selectedIdx","expandedKeys","setExpandedKeys","ReadonlySet","onItemClick","k","expandKey","prev","next","delete","isItemExpanded","lookupsRef","isItemClickable","b","is_error","toolUseResult","toolUseByToolUseID","get","tool","isResultTruncated","canAnimate","hasToolsInProgress","progress","prevProgressState","progressEnabled","terminalProgressBarEnabled","isProactiveActive","messageKey","renderMessageRow","index","prevType","isUserContinuation","hasContentAfter","row","expanded","wrapped","searchTextCache","WeakMap","extractSearchText","cached","isArray","tr","find","tu","extracted","lowered","toLowerCase","set","bold","thinking","setsEqual","a","item","Messages","keys","Object","key","p","shouldRenderStatically","siblingToolUseIDs","ReturnType","resolvedToolUseIDs","toolUseID","allResolved"],"sources":["Messages.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport type { UUID } from 'crypto'\nimport type { RefObject } from 'react'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { every } from 'src/utils/set.js'\nimport { getIsRemoteMode } from '../bootstrap/state.js'\nimport type { Command } from '../commands.js'\nimport { BLACK_CIRCLE } from '../constants/figures.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport { useTerminalNotification } from '../ink/useTerminalNotification.js'\nimport { Box, Text } from '../ink.js'\nimport { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js'\nimport type { Screen } from '../screens/REPL.js'\nimport type { Tools } from '../Tool.js'\nimport { findToolByName } from '../Tool.js'\nimport type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js'\nimport type {\n  Message as MessageType,\n  NormalizedMessage,\n  ProgressMessage as ProgressMessageType,\n  RenderableMessage,\n} from '../types/message.js'\nimport { type AdvisorBlock, isAdvisorBlock } from '../utils/advisor.js'\nimport { collapseBackgroundBashNotifications } from '../utils/collapseBackgroundBashNotifications.js'\nimport { collapseHookSummaries } from '../utils/collapseHookSummaries.js'\nimport { collapseReadSearchGroups } from '../utils/collapseReadSearch.js'\nimport { collapseTeammateShutdowns } from '../utils/collapseTeammateShutdowns.js'\nimport { getGlobalConfig } from '../utils/config.js'\nimport { isEnvTruthy } from '../utils/envUtils.js'\nimport { isFullscreenEnvEnabled } from '../utils/fullscreen.js'\nimport { applyGrouping } from '../utils/groupToolUses.js'\nimport {\n  buildMessageLookups,\n  createAssistantMessage,\n  deriveUUID,\n  getMessagesAfterCompactBoundary,\n  getToolUseID,\n  getToolUseIDs,\n  hasUnresolvedHooksFromLookup,\n  isNotEmptyMessage,\n  normalizeMessages,\n  reorderMessagesInUI,\n  type StreamingThinking,\n  type StreamingToolUse,\n  shouldShowUserMessage,\n} from '../utils/messages.js'\nimport { plural } from '../utils/stringUtils.js'\nimport { renderableSearchText } from '../utils/transcriptSearch.js'\nimport { Divider } from './design-system/Divider.js'\nimport type { UnseenDivider } from './FullscreenLayout.js'\nimport { LogoV2 } from './LogoV2/LogoV2.js'\nimport { StreamingMarkdown } from './Markdown.js'\nimport { hasContentAfterIndex, MessageRow } from './MessageRow.js'\nimport {\n  InVirtualListContext,\n  type MessageActionsNav,\n  MessageActionsSelectedContext,\n  type MessageActionsState,\n} from './messageActions.js'\nimport { AssistantThinkingMessage } from './messages/AssistantThinkingMessage.js'\nimport { isNullRenderingAttachment } from './messages/nullRenderingAttachments.js'\nimport { OffscreenFreeze } from './OffscreenFreeze.js'\nimport type { ToolUseConfirm } from './permissions/PermissionRequest.js'\nimport { StatusNotices } from './StatusNotices.js'\nimport type { JumpHandle } from './VirtualMessageList.js'\n\n// Memoed logo header: this box is the FIRST sibling before all MessageRows\n// in main-screen mode. If it becomes dirty on every Messages re-render,\n// renderChildren's seenDirtyChild cascade disables prevScreen (blit) for\n// ALL subsequent siblings — every MessageRow re-writes from scratch instead\n// of blitting. In long sessions (~2800 messages) this is 150K+ writes/frame\n// and pegs CPU at 100%. Memo on agentDefinitions so a new messages array\n// doesn't invalidate the logo subtree. LogoV2/StatusNotices internally\n// subscribe to useAppState/useSettings for their own updates.\nconst LogoHeader = React.memo(function LogoHeader({\n  agentDefinitions,\n}: {\n  agentDefinitions: AgentDefinitionsResult | undefined\n}): React.ReactNode {\n  // LogoV2 has its own internal OffscreenFreeze (catches its useAppState\n  // re-renders). This outer freeze catches agentDefinitions changes and any\n  // future StatusNotices subscriptions while the header is in scrollback.\n  return (\n    <OffscreenFreeze>\n      <Box flexDirection=\"column\" gap={1}>\n        <LogoV2 />\n        <React.Suspense fallback={null}>\n          <StatusNotices agentDefinitions={agentDefinitions} />\n        </React.Suspense>\n      </Box>\n    </OffscreenFreeze>\n  )\n})\n\n// Dead code elimination: conditional import for proactive mode\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? require('../proactive/index.js')\n    : null\nconst BRIEF_TOOL_NAME: string | null =\n  feature('KAIROS') || feature('KAIROS_BRIEF')\n    ? (\n        require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')\n      ).BRIEF_TOOL_NAME\n    : null\nconst SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS')\n  ? (\n      require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')\n    ).SEND_USER_FILE_TOOL_NAME\n  : null\n\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { VirtualMessageList } from './VirtualMessageList.js'\n\n/**\n * In brief-only mode, filter messages to show ONLY Brief tool_use blocks,\n * their tool_results, and real user input. All assistant text is dropped —\n * if the model forgets to call Brief, the user sees nothing for that turn.\n * That's on the model to get right; the filter does not second-guess it.\n */\nexport function filterForBriefTool<\n  T extends {\n    type: string\n    subtype?: string\n    isMeta?: boolean\n    isApiErrorMessage?: boolean\n    message?: {\n      content: Array<{\n        type: string\n        name?: string\n        tool_use_id?: string\n      }>\n    }\n    attachment?: {\n      type: string\n      isMeta?: boolean\n      origin?: unknown\n      commandMode?: string\n    }\n  },\n>(messages: T[], briefToolNames: string[]): T[] {\n  const nameSet = new Set(briefToolNames)\n  // tool_use always precedes its tool_result in the array, so we can collect\n  // IDs and match against them in a single pass.\n  const briefToolUseIDs = new Set<string>()\n  return messages.filter(msg => {\n    // System messages (attach confirmation, remote errors, compact boundaries)\n    // must stay visible — dropping them leaves the viewer with no feedback.\n    // Exception: api_metrics is per-turn debug noise (TTFT, config writes,\n    // hook timing) that defeats the point of brief mode. Still visible in\n    // transcript mode (ctrl+o) which bypasses this filter.\n    if (msg.type === 'system') return msg.subtype !== 'api_metrics'\n    const block = msg.message?.content[0]\n    if (msg.type === 'assistant') {\n      // API error messages (auth failures, rate limits, etc.) must stay visible\n      if (msg.isApiErrorMessage) return true\n      // Keep Brief tool_use blocks (renders with standard tool call chrome,\n      // and must be in the list so buildMessageLookups can resolve tool results)\n      if (block?.type === 'tool_use' && block.name && nameSet.has(block.name)) {\n        if ('id' in block) {\n          briefToolUseIDs.add((block as { id: string }).id)\n        }\n        return true\n      }\n      return false\n    }\n    if (msg.type === 'user') {\n      if (block?.type === 'tool_result') {\n        return (\n          block.tool_use_id !== undefined &&\n          briefToolUseIDs.has(block.tool_use_id)\n        )\n      }\n      // Real user input only — drop meta/tick messages.\n      return !msg.isMeta\n    }\n    if (msg.type === 'attachment') {\n      // Human input drained mid-turn arrives as a queued_command attachment\n      // (query.ts mid-chain drain → getQueuedCommandAttachments). Keep it —\n      // it's what the user typed. commandMode === 'prompt' positively\n      // identifies human-typed input; task-notification callers set\n      // mode: 'task-notification' but not origin/isMeta, so the positive\n      // commandMode check is required to exclude them.\n      const att = msg.attachment\n      return (\n        att?.type === 'queued_command' &&\n        att.commandMode === 'prompt' &&\n        !att.isMeta &&\n        att.origin === undefined\n      )\n    }\n    return false\n  })\n}\n\n/**\n * Full-transcript companion to filterForBriefTool. When the Brief tool is\n * in use, the model's text output is redundant with the SendUserMessage\n * content it wrote right after — drop the text so only the SendUserMessage\n * block shows. Tool calls and their results stay visible.\n *\n * Per-turn: only drops text in turns that actually called Brief. If the\n * model forgets, text still shows — otherwise the user would see nothing.\n */\nexport function dropTextInBriefTurns<\n  T extends {\n    type: string\n    isMeta?: boolean\n    message?: { content: Array<{ type: string; name?: string }> }\n  },\n>(messages: T[], briefToolNames: string[]): T[] {\n  const nameSet = new Set(briefToolNames)\n  // First pass: find which turns (bounded by non-meta user messages) contain\n  // a Brief tool_use. Tag each assistant text block with its turn index.\n  const turnsWithBrief = new Set<number>()\n  const textIndexToTurn: number[] = []\n  let turn = 0\n  for (let i = 0; i < messages.length; i++) {\n    const msg = messages[i]!\n    const block = msg.message?.content[0]\n    if (msg.type === 'user' && block?.type !== 'tool_result' && !msg.isMeta) {\n      turn++\n      continue\n    }\n    if (msg.type === 'assistant') {\n      if (block?.type === 'text') {\n        textIndexToTurn[i] = turn\n      } else if (\n        block?.type === 'tool_use' &&\n        block.name &&\n        nameSet.has(block.name)\n      ) {\n        turnsWithBrief.add(turn)\n      }\n    }\n  }\n  if (turnsWithBrief.size === 0) return messages\n  // Second pass: drop text blocks whose turn called Brief.\n  return messages.filter((_, i) => {\n    const t = textIndexToTurn[i]\n    return t === undefined || !turnsWithBrief.has(t)\n  })\n}\n\ntype Props = {\n  messages: MessageType[]\n  tools: Tools\n  commands: Command[]\n  verbose: boolean\n  toolJSX: {\n    jsx: React.ReactNode | null\n    shouldHidePromptInput: boolean\n    shouldContinueAnimation?: true\n  } | null\n  toolUseConfirmQueue: ToolUseConfirm[]\n  inProgressToolUseIDs: Set<string>\n  isMessageSelectorVisible: boolean\n  conversationId: string\n  screen: Screen\n  streamingToolUses: StreamingToolUse[]\n  showAllInTranscript?: boolean\n  agentDefinitions?: AgentDefinitionsResult\n  onOpenRateLimitOptions?: () => void\n  /** Hide the logo/header - used for subagent zoom view */\n  hideLogo?: boolean\n  isLoading: boolean\n  /** In transcript mode, hide all thinking blocks except the last one */\n  hidePastThinking?: boolean\n  /** Streaming thinking content (live updates, not frozen) */\n  streamingThinking?: StreamingThinking | null\n  /** Streaming text preview (rendered as last item so transition to final message is positionally seamless) */\n  streamingText?: string | null\n  /** When true, only show Brief tool output (hide everything else) */\n  isBriefOnly?: boolean\n  /** Fullscreen-mode \"─── N new ───\" divider. Renders before the first\n   *  renderableMessage derived from firstUnseenUuid (matched by the 24-char\n   *  prefix that deriveUUID preserves). */\n  unseenDivider?: UnseenDivider\n  /** Fullscreen-mode ScrollBox handle. Enables React-level virtualization when present. */\n  scrollRef?: RefObject<ScrollBoxHandle | null>\n  /** Fullscreen-mode: enable sticky-prompt tracking (writes via ScrollChromeContext). */\n  trackStickyPrompt?: boolean\n  /** Transcript search: jump-to-index + setSearchQuery/nextMatch/prevMatch. */\n  jumpRef?: RefObject<JumpHandle | null>\n  /** Transcript search: fires when match count/position changes. */\n  onSearchMatchesChange?: (count: number, current: number) => void\n  /** Paint an existing DOM subtree to fresh Screen, scan. Element comes\n   *  from the main tree (all real providers). Message-relative positions. */\n  scanElement?: (\n    el: import('../ink/dom.js').DOMElement,\n  ) => import('../ink/render-to-screen.js').MatchPosition[]\n  /** Position-based CURRENT highlight. positions stable (msg-relative),\n   *  rowOffset tracks scroll. null clears. */\n  setPositions?: (\n    state: {\n      positions: import('../ink/render-to-screen.js').MatchPosition[]\n      rowOffset: number\n      currentIdx: number\n    } | null,\n  ) => void\n  /** Bypass MAX_MESSAGES_WITHOUT_VIRTUALIZATION. For one-shot headless renders\n   *  (e.g. /export via renderToString) where the memory concern doesn't apply\n   *  and the \"already in scrollback\" justification doesn't hold. */\n  disableRenderCap?: boolean\n  /** In-transcript cursor; expanded overrides verbose for selected message. */\n  cursor?: MessageActionsState | null\n  setCursor?: (cursor: MessageActionsState | null) => void\n  /** Passed through to VirtualMessageList (heightCache owns visibility). */\n  cursorNavRef?: React.Ref<MessageActionsNav>\n  /** Render only collapsed.slice(start, end). For chunked headless export\n   *  (streamRenderedMessages in exportRenderer.tsx): prep runs on the FULL\n   *  messages array so grouping/lookups are correct, but only this slice\n   *  chunk instead of the full session. The logo renders only for chunk 0\n   *  (start === 0); later chunks are mid-stream continuations.\n   *  Measured Mar 2026: 538-msg session, 20 slices → −55% plateau RSS. */\n  renderRange?: readonly [start: number, end: number]\n}\n\nconst MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE = 30\n\n// Safety cap for the non-virtualized render path (fullscreen off or\n// explicitly disabled). Ink mounts a full fiber tree per message (~250 KB\n// RSS each); yoga layout height grows unbounded; the screen buffer is sized\n// to fit every line. At ~2000 messages this is ~3000-line screens, ~500 MB\n// of fibers, and per-frame write costs that push the process into a GC\n// death spiral (observed: 59 GB RSS, 14k mmap/munmap/sec). Content dropped\n// from this slice has already been printed to terminal scrollback — users\n// can still scroll up natively. VirtualMessageList (the default ant path)\n// bypasses this cap entirely. Headless one-shot renders (e.g. /export)\n// pass disableRenderCap to opt out — they have no scrollback and the\n// memory concern doesn't apply to renderToString.\n//\n// The slice boundary is tracked as a UUID anchor, not a count-derived\n// index. Count-based slicing (slice(-200)) drops one message from the\n// front on every append, shifting scrollback content and forcing a full\n// terminal reset per turn (CC-941). Quantizing to 50-message steps\n// (CC-1154) helped but still shifted on compaction and collapse regrouping\n// since those change collapsed.length without adding messages. The UUID\n// anchor only advances when rendered count genuinely exceeds CAP+STEP —\n// immune to length churn from grouping/compaction (CC-1174).\n//\n// The anchor stores BOTH uuid and index. Some uuids are unstable between\n// renders: collapseHookSummaries derives the merged uuid from the first\n// summary in a group, but reorderMessagesInUI reshuffles hook adjacency\n// as tool results stream in, changing which summary is first. When the\n// uuid vanishes, falling back to the stored index (clamped) keeps the\n// slice roughly where it was instead of resetting to 0 — which would\n// jump from ~200 rendered messages to the full history, orphaning\n// in-progress badge snapshots in scrollback.\nconst MAX_MESSAGES_WITHOUT_VIRTUALIZATION = 200\nconst MESSAGE_CAP_STEP = 50\n\nexport type SliceAnchor = { uuid: string; idx: number } | null\n\n/** Exported for testing. Mutates anchorRef when the window needs to advance. */\nexport function computeSliceStart(\n  collapsed: ReadonlyArray<{ uuid: string }>,\n  anchorRef: { current: SliceAnchor },\n  cap = MAX_MESSAGES_WITHOUT_VIRTUALIZATION,\n  step = MESSAGE_CAP_STEP,\n): number {\n  const anchor = anchorRef.current\n  const anchorIdx = anchor\n    ? collapsed.findIndex(m => m.uuid === anchor.uuid)\n    : -1\n  // Anchor found → use it. Anchor lost → fall back to stored index\n  // (clamped) so collapse-regrouping uuid churn doesn't reset to 0.\n  let start =\n    anchorIdx >= 0\n      ? anchorIdx\n      : anchor\n        ? Math.min(anchor.idx, Math.max(0, collapsed.length - cap))\n        : 0\n  if (collapsed.length - start > cap + step) {\n    start = collapsed.length - cap\n  }\n  // Refresh anchor from whatever lives at the current start — heals a\n  // stale uuid after fallback and captures a new one after advancement.\n  const msgAtStart = collapsed[start]\n  if (\n    msgAtStart &&\n    (anchor?.uuid !== msgAtStart.uuid || anchor.idx !== start)\n  ) {\n    anchorRef.current = { uuid: msgAtStart.uuid, idx: start }\n  } else if (!msgAtStart && anchor) {\n    anchorRef.current = null\n  }\n  return start\n}\n\nconst MessagesImpl = ({\n  messages,\n  tools,\n  commands,\n  verbose,\n  toolJSX,\n  toolUseConfirmQueue,\n  inProgressToolUseIDs,\n  isMessageSelectorVisible,\n  conversationId,\n  screen,\n  streamingToolUses,\n  showAllInTranscript = false,\n  agentDefinitions,\n  onOpenRateLimitOptions,\n  hideLogo = false,\n  isLoading,\n  hidePastThinking = false,\n  streamingThinking,\n  streamingText,\n  isBriefOnly = false,\n  unseenDivider,\n  scrollRef,\n  trackStickyPrompt,\n  jumpRef,\n  onSearchMatchesChange,\n  scanElement,\n  setPositions,\n  disableRenderCap = false,\n  cursor = null,\n  setCursor,\n  cursorNavRef,\n  renderRange,\n}: Props): React.ReactNode => {\n  const { columns } = useTerminalSize()\n  const toggleShowAllShortcut = useShortcutDisplay(\n    'transcript:toggleShowAll',\n    'Transcript',\n    'Ctrl+E',\n  )\n\n  const normalizedMessages = useMemo(\n    () => normalizeMessages(messages).filter(isNotEmptyMessage),\n    [messages],\n  )\n\n  // Check if streaming thinking should be visible (streaming or within 30s timeout)\n  const isStreamingThinkingVisible = useMemo(() => {\n    if (!streamingThinking) return false\n    if (streamingThinking.isStreaming) return true\n    if (streamingThinking.streamingEndedAt) {\n      return Date.now() - streamingThinking.streamingEndedAt < 30000\n    }\n    return false\n  }, [streamingThinking])\n\n  // Find the last thinking block (message UUID + content index) for hiding past thinking in transcript mode\n  // When streaming thinking is visible, use a special ID that won't match any completed thinking block\n  // With adaptive thinking, only consider thinking blocks from the current turn and stop searching once we\n  // hit the last user message.\n  const lastThinkingBlockId = useMemo(() => {\n    if (!hidePastThinking) return null\n    // If streaming thinking is visible, hide all completed thinking blocks by using a non-matching ID\n    if (isStreamingThinkingVisible) return 'streaming'\n    // Iterate backwards to find the last message with a thinking block\n    for (let i = normalizedMessages.length - 1; i >= 0; i--) {\n      const msg = normalizedMessages[i]\n      if (msg?.type === 'assistant') {\n        const content = msg.message.content\n        // Find the last thinking block in this message\n        for (let j = content.length - 1; j >= 0; j--) {\n          if (content[j]?.type === 'thinking') {\n            return `${msg.uuid}:${j}`\n          }\n        }\n      } else if (msg?.type === 'user') {\n        const hasToolResult = msg.message.content.some(\n          block => block.type === 'tool_result',\n        )\n        if (!hasToolResult) {\n          // Reached a previous user turn so don't show stale thinking from before\n          return 'no-thinking'\n        }\n      }\n    }\n    return null\n  }, [normalizedMessages, hidePastThinking, isStreamingThinkingVisible])\n\n  // Find the latest user bash output message (from ! commands)\n  // This allows us to show full output for the most recent bash command\n  const latestBashOutputUUID = useMemo(() => {\n    // Iterate backwards to find the last user message with bash output\n    for (let i = normalizedMessages.length - 1; i >= 0; i--) {\n      const msg = normalizedMessages[i]\n      if (msg?.type === 'user') {\n        const content = msg.message.content\n        // Check if any text content is bash output\n        for (const block of content) {\n          if (block.type === 'text') {\n            const text = block.text\n            if (\n              text.startsWith('<bash-stdout') ||\n              text.startsWith('<bash-stderr')\n            ) {\n              return msg.uuid\n            }\n          }\n        }\n      }\n    }\n    return null\n  }, [normalizedMessages])\n\n  // streamingToolUses updates on every input_json_delta while normalizedMessages\n  // stays stable — precompute the Set so the filter is O(k) not O(n×k) per chunk.\n  const normalizedToolUseIDs = useMemo(\n    () => getToolUseIDs(normalizedMessages),\n    [normalizedMessages],\n  )\n\n  const streamingToolUsesWithoutInProgress = useMemo(\n    () =>\n      streamingToolUses.filter(\n        stu =>\n          !inProgressToolUseIDs.has(stu.contentBlock.id) &&\n          !normalizedToolUseIDs.has(stu.contentBlock.id),\n      ),\n    [streamingToolUses, inProgressToolUseIDs, normalizedToolUseIDs],\n  )\n\n  const syntheticStreamingToolUseMessages = useMemo(\n    () =>\n      streamingToolUsesWithoutInProgress.flatMap(streamingToolUse => {\n        const msg = createAssistantMessage({\n          content: [streamingToolUse.contentBlock],\n        })\n        // Override randomUUID with deterministic value derived from content\n        // block ID to prevent React key changes on every memo recomputation.\n        // Same class of bug fixed in normalizeMessages (commit 383326e613):\n        // fresh randomUUID → unstable React keys → component remounts →\n        // Ink rendering corruption (overlapping text from stale DOM nodes).\n        msg.uuid = deriveUUID(streamingToolUse.contentBlock.id as UUID, 0)\n        return normalizeMessages([msg])\n      }),\n    [streamingToolUsesWithoutInProgress],\n  )\n\n  const isTranscriptMode = screen === 'transcript'\n  // Hoisted to mount-time — this component re-renders on every scroll.\n  const disableVirtualScroll = useMemo(\n    () => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL),\n    [],\n  )\n  // Virtual scroll replaces the transcript cap: everything is scrollable and\n  // memory is bounded by the mounted-item count, not the total. scrollRef is\n  // only passed when isFullscreenEnvEnabled() is true (REPL.tsx gates it),\n  // so scrollRef's presence is the signal.\n  const virtualScrollRuntimeGate = scrollRef != null && !disableVirtualScroll\n  const shouldTruncate =\n    isTranscriptMode && !showAllInTranscript && !virtualScrollRuntimeGate\n\n  // Anchor for the first rendered message in the non-virtualized cap slice.\n  // Monotonic advance only — mutation during render is idempotent (safe\n  // under StrictMode double-render). See MAX_MESSAGES_WITHOUT_VIRTUALIZATION\n  // comment above for why this replaced count-based slicing.\n  const sliceAnchorRef = useRef<SliceAnchor>(null)\n\n  // Expensive message transforms — filter, reorder, group, collapse, lookups.\n  // All O(n) over 27k messages. Split from the renderRange slice so scrolling\n  // (which only changes renderRange) doesn't re-run these. Previously this\n  // useMemo included renderRange → every scroll rebuilt 6 Maps over 27k\n  // messages + 4 filter/map passes = ~50ms alloc per scroll → GC pressure →\n  // 100-173ms stop-the-world pauses on the 1GB heap.\n  const { collapsed, lookups, hasTruncatedMessages, hiddenMessageCount } =\n    useMemo(() => {\n      // In fullscreen mode the alt buffer has no native scrollback, so the\n      // compact-boundary filter just hides history the ScrollBox could\n      // otherwise scroll to. Main-screen mode keeps the filter — pre-compact\n      // rows live above the viewport in native scrollback there, and\n      // re-rendering them triggers full resets.\n      // includeSnipped: UI rendering keeps snipped messages for scrollback\n      // (this PR's core goal — full history in UI, filter only for the model).\n      // Also avoids a UUID mismatch: normalizeMessages derives new UUIDs, so\n      // projectSnippedView's check against original removedUuids would fail.\n      const compactAwareMessages =\n        verbose || isFullscreenEnvEnabled()\n          ? normalizedMessages\n          : getMessagesAfterCompactBoundary(normalizedMessages, {\n              includeSnipped: true,\n            })\n\n      const messagesToShowNotTruncated = reorderMessagesInUI(\n        compactAwareMessages\n          .filter(\n            (msg): msg is Exclude<NormalizedMessage, ProgressMessageType> =>\n              msg.type !== 'progress',\n          )\n          // CC-724: drop attachment messages that AttachmentMessage renders as\n          // null (hook_success, hook_additional_context, hook_cancelled, etc.)\n          // BEFORE counting/slicing so they don't inflate the \"N messages\"\n          // count in ctrl-o or consume slots in the 200-message render cap.\n          .filter(msg => !isNullRenderingAttachment(msg))\n          .filter(_ => shouldShowUserMessage(_, isTranscriptMode)),\n        syntheticStreamingToolUseMessages,\n      )\n      // Three-tier filtering. Transcript mode (ctrl+o screen) is truly unfiltered.\n      // Brief-only: SendUserMessage + user input only. Default: drop redundant\n      // assistant text in turns where SendUserMessage was called (the model's\n      // text is working-notes that duplicate the SendUserMessage content).\n      const briefToolNames = [BRIEF_TOOL_NAME, SEND_USER_FILE_TOOL_NAME].filter(\n        (n): n is string => n !== null,\n      )\n      // dropTextInBriefTurns should only trigger on SendUserMessage turns —\n      // SendUserFile delivers a file without replacement text, so dropping\n      // assistant text for file-only turns would leave the user with no context.\n      const dropTextToolNames = [BRIEF_TOOL_NAME].filter(\n        (n): n is string => n !== null,\n      )\n      const briefFiltered =\n        briefToolNames.length > 0 && !isTranscriptMode\n          ? isBriefOnly\n            ? filterForBriefTool(messagesToShowNotTruncated, briefToolNames)\n            : dropTextToolNames.length > 0\n              ? dropTextInBriefTurns(\n                  messagesToShowNotTruncated,\n                  dropTextToolNames,\n                )\n              : messagesToShowNotTruncated\n          : messagesToShowNotTruncated\n\n      const messagesToShow = shouldTruncate\n        ? briefFiltered.slice(-MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE)\n        : briefFiltered\n\n      const hasTruncatedMessages =\n        shouldTruncate &&\n        briefFiltered.length > MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE\n\n      const { messages: groupedMessages } = applyGrouping(\n        messagesToShow,\n        tools,\n        verbose,\n      )\n\n      const collapsed = collapseBackgroundBashNotifications(\n        collapseHookSummaries(\n          collapseTeammateShutdowns(\n            collapseReadSearchGroups(groupedMessages, tools),\n          ),\n        ),\n        verbose,\n      )\n\n      const lookups = buildMessageLookups(normalizedMessages, messagesToShow)\n\n      const hiddenMessageCount =\n        messagesToShowNotTruncated.length -\n        MAX_MESSAGES_TO_SHOW_IN_TRANSCRIPT_MODE\n\n      return {\n        collapsed,\n        lookups,\n        hasTruncatedMessages,\n        hiddenMessageCount,\n      }\n    }, [\n      verbose,\n      normalizedMessages,\n      isTranscriptMode,\n      syntheticStreamingToolUseMessages,\n      shouldTruncate,\n      tools,\n      isBriefOnly,\n    ])\n\n  // Cheap slice — only runs when scroll range or slice config changes.\n  const renderableMessages = useMemo(() => {\n    // Safety cap for the non-virtualized render path. Applied here (not at\n    // the JSX site) so renderMessageRow's index-based lookups and\n    // dividerBeforeIndex compute on the same array. VirtualMessageList\n    // never sees this slice — virtualScrollRuntimeGate is constant for the\n    // component's lifetime (scrollRef is either always passed or never).\n    // renderRange is first: the chunked export path slices the\n    // post-grouping array so each chunk gets correct tool-call grouping.\n    const capApplies = !virtualScrollRuntimeGate && !disableRenderCap\n    const sliceStart = capApplies\n      ? computeSliceStart(collapsed, sliceAnchorRef)\n      : 0\n    return renderRange\n      ? collapsed.slice(renderRange[0], renderRange[1])\n      : sliceStart > 0\n        ? collapsed.slice(sliceStart)\n        : collapsed\n  }, [collapsed, renderRange, virtualScrollRuntimeGate, disableRenderCap])\n\n  const streamingToolUseIDs = useMemo(\n    () => new Set(streamingToolUses.map(_ => _.contentBlock.id)),\n    [streamingToolUses],\n  )\n\n  // Divider insertion point: first renderableMessage whose uuid shares the\n  // 24-char prefix with firstUnseenUuid (deriveUUID keeps the first 24\n  // chars of the source message uuid, so this matches any block from it).\n  const dividerBeforeIndex = useMemo(() => {\n    if (!unseenDivider) return -1\n    const prefix = unseenDivider.firstUnseenUuid.slice(0, 24)\n    return renderableMessages.findIndex(m => m.uuid.slice(0, 24) === prefix)\n  }, [unseenDivider, renderableMessages])\n\n  const selectedIdx = useMemo(() => {\n    if (!cursor) return -1\n    return renderableMessages.findIndex(m => m.uuid === cursor.uuid)\n  }, [cursor, renderableMessages])\n\n  // Fullscreen: click a message to toggle verbose rendering for it. Keyed by\n  // tool_use_id where available so a tool_use and its tool_result (separate\n  // rows) expand together; falls back to uuid for groups/thinking. Stale keys\n  // are harmless — they never match anything in renderableMessages.\n  const [expandedKeys, setExpandedKeys] = useState<ReadonlySet<string>>(\n    () => new Set(),\n  )\n  const onItemClick = useCallback((msg: RenderableMessage) => {\n    const k = expandKey(msg)\n    setExpandedKeys(prev => {\n      const next = new Set(prev)\n      if (next.has(k)) next.delete(k)\n      else next.add(k)\n      return next\n    })\n  }, [])\n  const isItemExpanded = useCallback(\n    (msg: RenderableMessage) =>\n      expandedKeys.size > 0 && expandedKeys.has(expandKey(msg)),\n    [expandedKeys],\n  )\n  // Only hover/click messages where the verbose toggle reveals more:\n  // collapsed read/search groups, or tool results that self-report truncation\n  // via isResultTruncated. Callback must be stable across message updates: if\n  // its identity (or return value) flips during streaming, onMouseEnter\n  // attaches after the mouse is already inside → hover never fires. tools is\n  // session-stable; lookups is read via ref so the callback doesn't churn on\n  // every new message.\n  const lookupsRef = useRef(lookups)\n  lookupsRef.current = lookups\n  const isItemClickable = useCallback(\n    (msg: RenderableMessage): boolean => {\n      if (msg.type === 'collapsed_read_search') return true\n      if (msg.type === 'assistant') {\n        const b = msg.message.content[0] as unknown as AdvisorBlock | undefined\n        return (\n          b != null &&\n          isAdvisorBlock(b) &&\n          b.type === 'advisor_tool_result' &&\n          b.content.type === 'advisor_result'\n        )\n      }\n      if (msg.type !== 'user') return false\n      const b = msg.message.content[0]\n      if (b?.type !== 'tool_result' || b.is_error || !msg.toolUseResult)\n        return false\n      const name = lookupsRef.current.toolUseByToolUseID.get(\n        b.tool_use_id,\n      )?.name\n      const tool = name ? findToolByName(tools, name) : undefined\n      return tool?.isResultTruncated?.(msg.toolUseResult as never) ?? false\n    },\n    [tools],\n  )\n\n  const canAnimate =\n    (!toolJSX || !!toolJSX.shouldContinueAnimation) &&\n    !toolUseConfirmQueue.length &&\n    !isMessageSelectorVisible\n\n  const hasToolsInProgress = inProgressToolUseIDs.size > 0\n\n  // Report progress to terminal (for terminals that support OSC 9;4)\n  const { progress } = useTerminalNotification()\n  const prevProgressState = useRef<string | null>(null)\n  const progressEnabled =\n    getGlobalConfig().terminalProgressBarEnabled &&\n    !getIsRemoteMode() &&\n    !(proactiveModule?.isProactiveActive() ?? false)\n  useEffect(() => {\n    const state = progressEnabled\n      ? hasToolsInProgress\n        ? 'indeterminate'\n        : 'completed'\n      : null\n    if (prevProgressState.current === state) return\n    prevProgressState.current = state\n    progress(state)\n  }, [progress, progressEnabled, hasToolsInProgress])\n  useEffect(() => {\n    return () => progress(null)\n  }, [progress])\n\n  const messageKey = useCallback(\n    (msg: RenderableMessage) => `${msg.uuid}-${conversationId}`,\n    [conversationId],\n  )\n\n  const renderMessageRow = (msg: RenderableMessage, index: number) => {\n    const prevType = index > 0 ? renderableMessages[index - 1]?.type : undefined\n    const isUserContinuation = msg.type === 'user' && prevType === 'user'\n    // hasContentAfter is only consumed for collapsed_read_search groups;\n    // skip the scan for everything else. streamingText is rendered as a\n    // sibling after this map, so it's never in renderableMessages — OR it\n    // in explicitly so the group flips to past tense as soon as text starts\n    // streaming instead of waiting for the block to finalize.\n    const hasContentAfter =\n      msg.type === 'collapsed_read_search' &&\n      (!!streamingText ||\n        hasContentAfterIndex(\n          renderableMessages,\n          index,\n          tools,\n          streamingToolUseIDs,\n        ))\n\n    const k = messageKey(msg)\n    const row = (\n      <MessageRow\n        key={k}\n        message={msg}\n        isUserContinuation={isUserContinuation}\n        hasContentAfter={hasContentAfter}\n        tools={tools}\n        commands={commands}\n        verbose={\n          verbose ||\n          isItemExpanded(msg) ||\n          (cursor?.expanded === true && index === selectedIdx)\n        }\n        inProgressToolUseIDs={inProgressToolUseIDs}\n        streamingToolUseIDs={streamingToolUseIDs}\n        screen={screen}\n        canAnimate={canAnimate}\n        onOpenRateLimitOptions={onOpenRateLimitOptions}\n        lastThinkingBlockId={lastThinkingBlockId}\n        latestBashOutputUUID={latestBashOutputUUID}\n        columns={columns}\n        isLoading={isLoading}\n        lookups={lookups}\n      />\n    )\n\n    // Per-row Provider — only 2 rows re-render on selection change.\n    // Wrapped BEFORE divider branch so both return paths get it.\n    const wrapped = (\n      <MessageActionsSelectedContext.Provider\n        key={k}\n        value={index === selectedIdx}\n      >\n        {row}\n      </MessageActionsSelectedContext.Provider>\n    )\n\n    if (unseenDivider && index === dividerBeforeIndex) {\n      return [\n        <Box key=\"unseen-divider\" marginTop={1}>\n          <Divider\n            title={`${unseenDivider.count} new ${plural(unseenDivider.count, 'message')}`}\n            width={columns}\n            color=\"inactive\"\n          />\n        </Box>,\n        wrapped,\n      ]\n    }\n    return wrapped\n  }\n\n  // Search indexing: for tool_result messages, look up the Tool and use\n  // its extractSearchText — tool-owned, precise, matches what\n  // renderToolResultMessage shows. Falls back to renderableSearchText\n  // (duck-types toolUseResult) for tools that haven't implemented it,\n  // and for all non-tool-result message types. The drift-catcher test\n  // (toolSearchText.test.tsx) renders + compares to keep these in sync.\n  //\n  // A second-React-root reconcile approach was tried and ruled out\n  // (measured 3.1ms/msg, growing — flushSyncWork processes all roots;\n  // component hooks mutate shared state → main root accumulates updates).\n  const searchTextCache = useRef(new WeakMap<RenderableMessage, string>())\n  const extractSearchText = useCallback(\n    (msg: RenderableMessage): string => {\n      const cached = searchTextCache.current.get(msg)\n      if (cached !== undefined) return cached\n      let text = renderableSearchText(msg)\n      // If this is a tool_result message and the tool implements\n      // extractSearchText, prefer that — it's precise (tool-owned)\n      // vs renderableSearchText's field-name heuristic.\n      if (\n        msg.type === 'user' &&\n        msg.toolUseResult &&\n        Array.isArray(msg.message.content)\n      ) {\n        const tr = msg.message.content.find(b => b.type === 'tool_result')\n        if (tr && 'tool_use_id' in tr) {\n          const tu = lookups.toolUseByToolUseID.get(tr.tool_use_id)\n          const tool = tu && findToolByName(tools, tu.name)\n          const extracted = tool?.extractSearchText?.(\n            msg.toolUseResult as never,\n          )\n          // undefined = tool didn't implement → keep heuristic. Empty\n          // string = tool says \"nothing to index\" → respect that.\n          if (extracted !== undefined) text = extracted\n        }\n      }\n      // Cache LOWERED: setSearchQuery's hot loop indexOfs per keystroke.\n      // Lowering here (once, at warm) vs there (every keystroke) trades\n      // ~same steady-state memory for zero per-keystroke alloc. Cache\n      // GC's with messages on transcript exit. Tool methods return raw;\n      // renderableSearchText already lowercases (redundant but cheap).\n      const lowered = text.toLowerCase()\n      searchTextCache.current.set(msg, lowered)\n      return lowered\n    },\n    [tools, lookups],\n  )\n\n  return (\n    <>\n      {/* Logo */}\n      {!hideLogo && !(renderRange && renderRange[0] > 0) && (\n        <LogoHeader agentDefinitions={agentDefinitions} />\n      )}\n\n      {/* Truncation indicator */}\n      {hasTruncatedMessages && (\n        <Divider\n          title={`${toggleShowAllShortcut} to show ${chalk.bold(hiddenMessageCount)} previous messages`}\n          width={columns}\n        />\n      )}\n\n      {/* Show all indicator */}\n      {isTranscriptMode &&\n        showAllInTranscript &&\n        hiddenMessageCount > 0 &&\n        // disableRenderCap (e.g. [ dump-to-scrollback) means we're uncapped\n        // as a one-shot escape hatch, not a toggle — ctrl+e is dead and\n        // nothing is actually \"hidden\" to restore.\n        !disableRenderCap && (\n          <Divider\n            title={`${toggleShowAllShortcut} to hide ${chalk.bold(hiddenMessageCount)} previous messages`}\n            width={columns}\n          />\n        )}\n\n      {/* Messages - rendered as memoized MessageRow components.\n          flatMap inserts the unseen-divider as a separate keyed sibling so\n          (a) non-fullscreen renders pay no per-message Fragment wrap, and\n          (b) divider toggle in fullscreen preserves all MessageRows by key.\n          Pre-compute derived values instead of passing renderableMessages to\n          each row - React Compiler pins props in the fiber's memoCache, so\n          passing the array would accumulate every historical version\n          (~1-2MB over a 7-turn session). */}\n      {virtualScrollRuntimeGate ? (\n        <InVirtualListContext.Provider value={true}>\n          <VirtualMessageList\n            messages={renderableMessages}\n            scrollRef={scrollRef}\n            columns={columns}\n            itemKey={messageKey}\n            renderItem={renderMessageRow}\n            onItemClick={onItemClick}\n            isItemClickable={isItemClickable}\n            isItemExpanded={isItemExpanded}\n            trackStickyPrompt={trackStickyPrompt}\n            selectedIndex={selectedIdx >= 0 ? selectedIdx : undefined}\n            cursorNavRef={cursorNavRef}\n            setCursor={setCursor}\n            jumpRef={jumpRef}\n            onSearchMatchesChange={onSearchMatchesChange}\n            scanElement={scanElement}\n            setPositions={setPositions}\n            extractSearchText={extractSearchText}\n          />\n        </InVirtualListContext.Provider>\n      ) : (\n        renderableMessages.flatMap(renderMessageRow)\n      )}\n\n      {streamingText && !isBriefOnly && (\n        <Box\n          alignItems=\"flex-start\"\n          flexDirection=\"row\"\n          marginTop={1}\n          width=\"100%\"\n        >\n          <Box flexDirection=\"row\">\n            <Box minWidth={2}>\n              <Text color=\"text\">{BLACK_CIRCLE}</Text>\n            </Box>\n            <Box flexDirection=\"column\">\n              <StreamingMarkdown>{streamingText}</StreamingMarkdown>\n            </Box>\n          </Box>\n        </Box>\n      )}\n\n      {isStreamingThinkingVisible && streamingThinking && !isBriefOnly && (\n        <Box marginTop={1}>\n          <AssistantThinkingMessage\n            param={{\n              type: 'thinking',\n              thinking: streamingThinking.thinking,\n            }}\n            addMargin={false}\n            isTranscriptMode={true}\n            verbose={verbose}\n            hideInTranscript={false}\n          />\n        </Box>\n      )}\n    </>\n  )\n}\n\n/** Key for click-to-expand: tool_use_id where available (so tool_use + its\n *  tool_result expand together), else uuid for groups/thinking. */\nfunction expandKey(msg: RenderableMessage): string {\n  return (\n    (msg.type === 'assistant' || msg.type === 'user'\n      ? getToolUseID(msg)\n      : null) ?? msg.uuid\n  )\n}\n\n// Custom comparator to prevent unnecessary re-renders during streaming.\n// Default React.memo does shallow comparison which fails when:\n// 1. onOpenRateLimitOptions callback is recreated (doesn't affect render output)\n// 2. streamingToolUses array is recreated on every delta, but only contentBlock matters for rendering\n// 3. streamingThinking changes on every delta - we DO want to re-render for this\nfunction setsEqual<T>(a: Set<T>, b: Set<T>): boolean {\n  if (a.size !== b.size) return false\n  for (const item of a) {\n    if (!b.has(item)) return false\n  }\n  return true\n}\n\nexport const Messages = React.memo(MessagesImpl, (prev, next) => {\n  const keys = Object.keys(prev) as (keyof typeof prev)[]\n  for (const key of keys) {\n    if (\n      key === 'onOpenRateLimitOptions' ||\n      key === 'scrollRef' ||\n      key === 'trackStickyPrompt' ||\n      key === 'setCursor' ||\n      key === 'cursorNavRef' ||\n      key === 'jumpRef' ||\n      key === 'onSearchMatchesChange' ||\n      key === 'scanElement' ||\n      key === 'setPositions'\n    )\n      continue\n    if (prev[key] !== next[key]) {\n      if (key === 'streamingToolUses') {\n        const p = prev.streamingToolUses\n        const n = next.streamingToolUses\n        if (\n          p.length === n.length &&\n          p.every((item, i) => item.contentBlock === n[i]?.contentBlock)\n        ) {\n          continue\n        }\n      }\n      if (key === 'inProgressToolUseIDs') {\n        if (setsEqual(prev.inProgressToolUseIDs, next.inProgressToolUseIDs)) {\n          continue\n        }\n      }\n      if (key === 'unseenDivider') {\n        const p = prev.unseenDivider\n        const n = next.unseenDivider\n        if (\n          p?.firstUnseenUuid === n?.firstUnseenUuid &&\n          p?.count === n?.count\n        ) {\n          continue\n        }\n      }\n      if (key === 'tools') {\n        const p = prev.tools\n        const n = next.tools\n        if (\n          p.length === n.length &&\n          p.every((tool, i) => tool.name === n[i]?.name)\n        ) {\n          continue\n        }\n      }\n      // streamingThinking changes frequently - always re-render when it changes\n      // (no special handling needed, default behavior is correct)\n      return false\n    }\n  }\n  return true\n})\n\nexport function shouldRenderStatically(\n  message: RenderableMessage,\n  streamingToolUseIDs: Set<string>,\n  inProgressToolUseIDs: Set<string>,\n  siblingToolUseIDs: ReadonlySet<string>,\n  screen: Screen,\n  lookups: ReturnType<typeof buildMessageLookups>,\n): boolean {\n  if (screen === 'transcript') {\n    return true\n  }\n  switch (message.type) {\n    case 'attachment':\n    case 'user':\n    case 'assistant': {\n      if (message.type === 'assistant') {\n        const block = message.message.content[0]\n        if (block?.type === 'server_tool_use') {\n          return lookups.resolvedToolUseIDs.has(block.id)\n        }\n      }\n      const toolUseID = getToolUseID(message)\n      if (!toolUseID) {\n        return true\n      }\n      if (streamingToolUseIDs.has(toolUseID)) {\n        return false\n      }\n      if (inProgressToolUseIDs.has(toolUseID)) {\n        return false\n      }\n\n      // Check if there are any unresolved PostToolUse hooks for this tool use\n      // If so, keep the message transient so the HookProgressMessage can update\n      if (hasUnresolvedHooksFromLookup(toolUseID, 'PostToolUse', lookups)) {\n        return false\n      }\n\n      return every(siblingToolUseIDs, lookups.resolvedToolUseIDs)\n    }\n    case 'system': {\n      // api errors always render dynamically, since we hide\n      // them as soon as we see another non-error message.\n      return message.subtype !== 'api_error'\n    }\n    case 'grouped_tool_use': {\n      const allResolved = message.messages.every(msg => {\n        const content = msg.message.content[0]\n        return (\n          content?.type === 'tool_use' &&\n          lookups.resolvedToolUseIDs.has(content.id)\n        )\n      })\n      return allResolved\n    }\n    case 'collapsed_read_search': {\n      // In prompt mode, never mark as static to prevent flicker between API turns\n      // (In transcript mode, we already returned true at the top of this function)\n      return false\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}