@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/tui-ink/message-list.js

@@ -1,841 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Static, Text, measureElement } from "ink";
-import { useTheme } from "./theme.js";
-import { highlightCode, inferLang } from "./code-highlight.js";
-import { MarkdownContent, StreamingMarkdown } from "./markdown.js";
-import { visualWidth, graphemeWidth, ambiguousIsWide } from "./width.js";
-import { userInputStatusBadgeLabel, } from "./display-history.js";
-import { buildTraceGroups, executeCommandBlock, formatTracePath, shouldInlineExecuteCommand, traceGroupLabel, } from "./trace-groups.js";
-import { EDIT_COLLAPSED_DIFF_LINES, formatEditSuccessSummary, getEditDiffDetails } from "./edit-diff.js";
-import { latestSubagentNote, sortSubagents, subagentDescriptor, subagentLabel, subagentStatusColor, subagentSummary, } from "./subagent-view.js";
-import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
-import { stripFileBlocks } from "../context/compaction-files.js";
-import { splitImageDisplayContent } from "../tui/image-display.js";
-const EXECUTE_COMMAND_BLOCK_MAX_LINES = 4;
-/**
- * Every transcript row — each committed <Static> item and the DynamicClamp
- * live region — wraps its content in paddingX={1}: one column of inset on
- * EACH side. Any wrap budget derived from terminalColumns inside a row must
- * net out these two columns. Forgetting them hands the pre-wrapper a budget
- * two columns wider than the real room, and a dense CJK line that packs flush
- * against that budget renders past the terminal edge — the terminal then
- * hard-wraps the last glyph onto a stray row at column 0.
- */
-const TRANSCRIPT_ROW_PADDING = 2;
-export function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking = false, verboseTrace, pendingApproval, nowTick, welcomeBanner, staticGeneration = 0, paddingX = 1, maxStreamRows, }) {
-    const theme = useTheme();
-    const hasStreaming = !!(streamingContent ||
-        streamingReasoning ||
-        streamingTools.length > 0 ||
-        streamingParts.length > 0);
-    const regularMessages = messages.filter((message) => !message.inputStatus);
-    const pendingSteerMessages = messages.filter((message) => message.inputStatus === "pending_steer");
-    const queuedInputMessages = messages.filter((message) => message.inputStatus === "queued");
-    // While the transcript has no settled rows, the banner stays OUT of
-    // <Static> and renders in the live region instead, so it repaints on every
-    // commit — a /model switch on the fresh launch screen updates the banner in
-    // place. It is committed to scrollback together with the first settled row
-    // (same render commit, so the hand-off is seamless) and frozen from then on.
-    const bannerCommitted = regularMessages.length > 0;
-    const staticItems = [];
-    if (welcomeBanner && bannerCommitted) {
-        staticItems.push({ kind: "welcome", key: "welcome" });
-    }
-    const lastMessageIndex = regularMessages.length - 1;
-    for (let i = 0; i < regularMessages.length; i++) {
-        const msg = regularMessages[i];
-        staticItems.push({
-            kind: "message",
-            key: msg.key ?? `message-${i}`,
-            message: msg,
-            showExpandHint: !hasStreaming && i === lastMessageIndex,
-            separateFromPrevious: msg.role === "user" && regularMessages[i - 1]?.role === "user",
-        });
-    }
-    const hasDynamic = hasStreaming || pendingSteerMessages.length > 0 || queuedInputMessages.length > 0;
-    // The live region must never grow taller than the viewport: a frame taller
-    // than the pane breaks Ink's in-place redraw under tmux (the cursor-up clear
-    // can't reach scrolled-off rows), leaving large blank gaps + stray glyphs.
-    // Clip it to maxStreamRows and pin to the bottom so the user sees the latest
-    // output (tail view); the full turn lands in <Static> scrollback on commit.
-    const clampDynamic = typeof maxStreamRows === "number" && maxStreamRows > 0;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Static, { items: staticItems, children: (item) => {
-                    if (item.kind === "welcome") {
-                        return (_jsx(Box, { flexDirection: "column", paddingX: paddingX, backgroundColor: theme.background, children: welcomeBanner }, item.key));
-                    }
-                    return (_jsx(Box, { flexDirection: "column", paddingX: paddingX, backgroundColor: theme.background, children: _jsx(MessageItem, { message: item.message, terminalColumns: terminalColumns, showThinking: showThinking, verboseTrace: verboseTrace, showExpandHint: item.showExpandHint, separateFromPrevious: item.separateFromPrevious }) }, item.key));
-                } }, `transcript-${staticGeneration}`), welcomeBanner && !bannerCommitted && (_jsx(Box, { flexDirection: "column", paddingX: paddingX, backgroundColor: theme.background, children: welcomeBanner })), hasDynamic && (_jsxs(DynamicClamp, { maxRows: clampDynamic ? maxStreamRows : undefined, paddingX: paddingX, backgroundColor: theme.background, children: [hasStreaming && (_jsx(StreamingMessage, { content: streamingContent, reasoning: streamingReasoning, tools: streamingTools, parts: streamingParts, terminalColumns: terminalColumns, showThinking: showThinking, verboseTrace: verboseTrace, pendingApproval: pendingApproval, nowTick: nowTick })), pendingSteerMessages.length > 0 && (_jsx(PendingInputMessagesBlock, { messages: pendingSteerMessages, terminalColumns: terminalColumns, title: "Messages to steer at next model call", hint: "applies before the next provider request", bulletColor: theme.warning })), queuedInputMessages.length > 0 && (_jsx(PendingInputMessagesBlock, { messages: queuedInputMessages, terminalColumns: terminalColumns, title: "Messages queued for next turn", hint: "runs after the current answer", bulletColor: theme.muted }))] }))] }));
-}
-/**
- * Bounds the live (in-progress turn) region to at most `maxRows` rows, pinned
- * to the bottom so the user always sees the latest output (tail view). A live
- * frame taller than the terminal pane breaks Ink's in-place redraw under tmux
- * (the cursor-up clear can't reach rows that scrolled off), leaving large blank
- * gaps and stray glyphs. We measure the natural content height and only clip
- * when it actually exceeds `maxRows`, so short turns keep their natural height
- * (no reserved-space gap). The full turn still lands in <Static> scrollback the
- * moment it commits, so nothing is lost — only the live preview is windowed.
- */
-function DynamicClamp({ maxRows, paddingX, backgroundColor, children, }) {
-    const innerRef = React.useRef(null);
-    const [offset, setOffset] = React.useState(0);
-    const [clipHeight, setClipHeight] = React.useState(undefined);
-    // Re-measure after every commit (streaming changes height with each token).
-    // useLayoutEffect runs before Ink flushes the frame to the terminal, so the
-    // clamp is applied in the same paint — avoiding a one-frame overflow flash
-    // under tmux when a turn first grows past the pane. setState bails out via
-    // Object.is when nothing moved, so the steady state does not loop.
-    React.useLayoutEffect(() => {
-        if (!maxRows || !innerRef.current) {
-            if (offset !== 0)
-                setOffset(0);
-            if (clipHeight !== undefined)
-                setClipHeight(undefined);
-            return;
-        }
-        const height = measureElement(innerRef.current).height;
-        if (height > maxRows) {
-            const nextOffset = -(height - maxRows);
-            if (nextOffset !== offset)
-                setOffset(nextOffset);
-            if (clipHeight !== maxRows)
-                setClipHeight(maxRows);
-        }
-        else {
-            if (offset !== 0)
-                setOffset(0);
-            if (clipHeight !== undefined)
-                setClipHeight(undefined);
-        }
-    });
-    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingX: paddingX, backgroundColor: backgroundColor, ...(clipHeight !== undefined ? { height: clipHeight, overflowY: "hidden" } : {}), children: _jsx(Box, { ref: innerRef, flexDirection: "column", flexShrink: 0, marginTop: offset, children: children }) }));
-}
-// Memoized: with no <Static> region, every transcript row re-renders on each
-// state change unless its props are referentially stable. Message objects are
-// append-only (compaction reuses already-compacted instances), keys are
-// stable, and nowTick is only threaded to the last row, so memo hits for all
-// settled history rows.
-const MessageItem = React.memo(function MessageItem({ message, terminalColumns, showThinking, verboseTrace, showExpandHint, separateFromPrevious, nowTick, }) {
-    const theme = useTheme();
-    if (message.role === "user") {
-        return (_jsx(UserMessageBlock, { content: message.content, terminalColumns: terminalColumns, inputStatus: message.inputStatus, separateFromPrevious: separateFromPrevious }));
-    }
-    if (message.role === "error") {
-        return (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Text, { color: theme.error, children: ["Error: ", message.content] }) }));
-    }
-    if (message.syntheticKind === "ui_compact_summary") {
-        return _jsx(CompactionSummaryBlock, { message: message });
-    }
-    if (message.syntheticKind === "ui_interrupt") {
-        return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: theme.error, children: "\u23F9 " }), _jsx(Text, { color: theme.muted, dimColor: true, children: message.content || "Interrupted by user" })] }));
-    }
-    // One-line status notices (model switch etc.): accent-colored so they read
-    // as UI feedback, not assistant prose.
-    if (message.syntheticKind === "ui_notice") {
-        return (_jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsxs(Text, { color: theme.accent, children: ["\u2726 ", message.content] }) }));
-    }
-    const visibleReasoning = sanitizeInternalReminderBlocks(message.reasoning ?? "").trim();
-    // Same defense as reasoning: strip any internal reminder markup the model
-    // echoed back into its visible answer so it never reaches the transcript.
-    const visibleContent = sanitizeInternalReminderBlocks(message.content ?? "");
-    // Decide visibility by what will ACTUALLY render below, not by raw array
-    // lengths. A turn whose only text part is an echoed <bubble_internal_*>
-    // reminder sanitizes to empty (TimelineText returns null), but the wrapper's
-    // marginTop/marginBottom would still emit a blank band — and long sessions
-    // inject more reminders, so consecutive empty turns stack into a large gap
-    // after the tool rows. Mirror the render: parts path → MessageParts; non-parts
-    // path → toolCalls/visibleContent; verbose adds a TurnDigest from toolCalls.
-    const hasParts = (message.parts?.length ?? 0) > 0;
-    const hasVisibleParts = hasParts &&
-        (message.parts ?? []).some((part) => part.type === "tools"
-            ? part.toolCalls.length > 0
-            : sanitizeInternalReminderBlocks(part.content).trim() !== "");
-    const toolCallCount = message.toolCalls?.length ?? 0;
-    const hasVisibleAssistantContent = (hasParts ? hasVisibleParts : (!!visibleContent.trim() || toolCallCount > 0)) ||
-        // Reasoning now always renders (collapsed by default), so its presence
-        // alone makes a turn visible.
-        !!visibleReasoning ||
-        // A finalized turn carries taskElapsedMs and renders a TaskDurationLine even
-        // when its text/parts are empty — mirror that so the duration isn't dropped.
-        // (The verbose TurnDigest needs no term: whenever it renders, the same
-        // toolCalls already make the turn visible via the parts/non-parts branch.)
-        message.taskElapsedMs !== undefined;
-    if (!hasVisibleAssistantContent)
-        return null;
-    return (_jsxs(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [visibleReasoning && (_jsx(ReasoningTraceBlock, { reasoning: visibleReasoning, expanded: showThinking || verboseTrace })), message.parts && message.parts.length > 0 ? (_jsx(MessageParts, { parts: message.parts, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), visibleContent.trim() && (
-                    // Thread the real terminal width down (minus the row's paddingX
-                    // inset); without it, width-aware blocks like tables fall back to
-                    // a stale/default useTerminalSize and mis-budget their columns.
-                    _jsx(MarkdownContent, { content: visibleContent, maxWidth: Math.max(20, terminalColumns - 4) }))] })), verboseTrace && message.toolCalls && message.toolCalls.length > 0 && (_jsx(TurnDigest, { toolCalls: message.toolCalls })), message.taskElapsedMs !== undefined && (_jsx(TaskDurationLine, { elapsedMs: message.taskElapsedMs }))] }));
-});
-function StreamingMessage({ content, reasoning, tools, parts, terminalColumns, showThinking, verboseTrace, pendingApproval, nowTick, }) {
-    const deferredContent = React.useDeferredValue(content);
-    const deferredReasoning = React.useDeferredValue(reasoning);
-    const deferredParts = React.useDeferredValue(parts);
-    const visibleReasoning = sanitizeInternalReminderBlocks(deferredReasoning).trim();
-    const visibleParts = deferredParts.length > 0
-        ? deferredParts
-        : fallbackStreamingParts(deferredContent, tools);
-    return (_jsxs(Box, { flexDirection: "column", children: [visibleReasoning && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning, expanded: showThinking || verboseTrace, streaming: true }) })), visibleParts.length > 0 && (
-            // marginTop=1 matches the committed MessageItem layout exactly, so the
-            // gap under the user message is identical while streaming and after the
-            // turn commits — no spacing jump at finalize time. (The old marginTop=0
-            // was a flicker mitigation for the main-screen <Static> renderer; the
-            // alt-screen viewport repaints frames atomically, so it's obsolete.)
-            _jsx(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: _jsx(MessageParts, { parts: visibleParts, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: pendingApproval, showExpandHint: true, nowTick: nowTick, showActivity: true, streaming: true }) }))] }));
-}
-function MessageParts({ parts, terminalColumns, verboseTrace, pendingApproval, showExpandHint, nowTick, showActivity = false, streaming = false, }) {
-    const lastToolsPartIndex = findLastToolsPartIndex(parts);
-    const lastTextPartIndex = findLastTextPartIndex(parts);
-    return (_jsx(Box, { flexDirection: "column", children: parts.map((part, idx) => {
-            if (part.type === "text") {
-                return (_jsx(TimelineText, { content: part.content, compactTop: idx === 0, terminalColumns: terminalColumns, streaming: streaming && idx === lastTextPartIndex }, `text-${idx}`));
-            }
-            return (_jsx(ToolsPart, { toolCalls: part.toolCalls, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: pendingApproval, showExpandHint: showExpandHint && idx === lastToolsPartIndex, compactTop: idx === 0, nowTick: nowTick, showActivity: showActivity && idx === lastToolsPartIndex }, `tools-${idx}`));
-        }) }));
-}
-function findLastTextPartIndex(parts) {
-    for (let i = parts.length - 1; i >= 0; i--) {
-        if (parts[i]?.type === "text")
-            return i;
-    }
-    return -1;
-}
-function TimelineText({ content, compactTop, terminalColumns, streaming = false, }) {
-    const theme = useTheme();
-    // Strip any internal reminder/context markup the model echoed back into its
-    // visible text — the reasoning path already does this. Without it, a model
-    // that parrots a <bubble_internal_*> block (e.g. an injected system reminder)
-    // leaks it straight into the transcript. The streaming sanitizer also holds a
-    // half-typed block until it closes, so partial markup never flashes.
-    const visible = sanitizeInternalReminderBlocks(content);
-    if (!visible.trim())
-        return null;
-    // Timeline gutter = marginLeft (2) + "●  " marker. The ● (U+25CF) is itself
-    // an ambiguous-width glyph, so the marker is 3 cells on a narrow terminal but
-    // 4 on an ambiguous-wide one — Ink lays it out as 3 either way (it measures
-    // ●=1), so on a wide terminal the first line of every message gets shoved 1
-    // cell right and would overflow. Reserve that extra cell up front so the
-    // pre-wrap never packs a line the terminal then hard-wraps.
-    const gutter = ambiguousIsWide() ? 6 : 5;
-    const available = terminalColumns
-        ? Math.max(20, terminalColumns - gutter - TRANSCRIPT_ROW_PADDING)
-        : undefined;
-    const trimmed = visible.trim();
-    return (_jsxs(Box, { marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsx(Text, { color: theme.agent, children: "\u25CF  " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: streaming ? (_jsx(StreamingMarkdown, { content: trimmed, maxWidth: available, flushTop: true })) : (_jsx(MarkdownContent, { content: trimmed, maxWidth: available, flushTop: true })) })] }));
-}
-function ToolsPart({ toolCalls, terminalColumns, verboseTrace, pendingApproval, showExpandHint, compactTop = false, nowTick, showActivity = false, }) {
-    if (toolCalls.length === 0)
-        return null;
-    if (!verboseTrace) {
-        return (_jsx(TraceGroupList, { toolCalls: toolCalls, terminalColumns: terminalColumns, pendingApproval: pendingApproval, nowTick: nowTick, compactTop: compactTop, showActivity: showActivity }));
-    }
-    const lastIdx = toolCalls.length - 1;
-    return (_jsx(Box, { flexDirection: "column", children: toolCalls.map((tc, idx) => {
-            const isWaitingApproval = isToolPending(tc) && !!pendingApproval && approvalMatchesTool(pendingApproval, tc);
-            return (_jsx(ToolCallDisplay, { toolCall: tc, isStreaming: isToolPending(tc), verbose: verboseTrace, terminalColumns: terminalColumns, showExpandHint: showExpandHint && idx === lastIdx, waitingApproval: isWaitingApproval, compactTop: idx === 0 && compactTop, nowTick: nowTick }, tc.id));
-        }) }));
-}
-function fallbackStreamingParts(content, tools) {
-    const parts = [];
-    if (tools.length > 0)
-        parts.push({ type: "tools", toolCalls: tools });
-    if (content)
-        parts.push({ type: "text", content });
-    return parts;
-}
-function findLastToolsPartIndex(parts) {
-    for (let i = parts.length - 1; i >= 0; i--) {
-        if (parts[i]?.type === "tools")
-            return i;
-    }
-    return -1;
-}
-function TraceGroupList({ toolCalls, terminalColumns, pendingApproval, nowTick, compactTop = false, showActivity = false, }) {
-    const groups = React.useMemo(() => buildTraceGroups(toolCalls), [toolCalls]);
-    const activeGroup = showActivity ? findActiveTraceGroup(groups, pendingApproval) : undefined;
-    if (groups.length === 0)
-        return null;
-    return (_jsxs(Box, { flexDirection: "column", children: [activeGroup && (_jsx(TraceActivityLine, { group: activeGroup, pendingApproval: pendingApproval, nowTick: nowTick, terminalColumns: terminalColumns })), groups.map((group, idx) => (_jsx(TraceGroupBlock, { group: group, terminalColumns: terminalColumns, pendingApproval: pendingApproval, compactTop: idx === 0 && compactTop, nowTick: nowTick }, group.raw.map((tool) => tool.id).join(":"))))] }));
-}
-function TraceActivityLine({ group, pendingApproval, nowTick, terminalColumns, }) {
-    const theme = useTheme();
-    const waiting = isTraceGroupWaitingForApproval(group, pendingApproval);
-    void nowTick;
-    const labelWidth = Math.max(20, terminalColumns - 26);
-    const label = truncateVisual(traceGroupLabel(group), labelWidth);
-    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: waiting ? theme.warning : theme.tracePending, children: "\u25CF " }), _jsxs(Text, { color: theme.traceDetail, children: [waiting ? "Waiting for approval" : "Working on", " "] }), _jsx(Text, { color: theme.traceAction, children: label })] }));
-}
-function TraceGroupBlock({ group, terminalColumns, pendingApproval, compactTop, nowTick, }) {
-    const theme = useTheme();
-    const waiting = isTraceGroupWaitingForApproval(group, pendingApproval);
-    const status = traceGroupStatus(group, waiting, theme, nowTick);
-    const editTool = group.kind === "edit" && group.raw.length === 1 ? group.raw[0] : undefined;
-    const editDetails = editTool && !group.pending && !group.hasError ? getEditDiffDetails(editTool) : null;
-    if (editTool && editDetails) {
-        return (_jsx(EditTraceBlock, { tool: editTool, details: editDetails, terminalColumns: terminalColumns, compactTop: compactTop, status: status }));
-    }
-    const allErrored = group.hasError && group.errorCount >= group.raw.length && !group.pending;
-    const titleColor = allErrored ? theme.error : theme.traceAction;
-    const detailColor = allErrored ? theme.error : theme.traceDetail;
-    const commandWidth = Math.max(14, terminalColumns - group.title.length - 20);
-    const detailWidth = Math.max(20, terminalColumns - 8);
-    const detailLines = group.previewLines.length > 0 ? group.previewLines : group.items;
-    // Finished, error-free Execute rows collapse to a one-line summary: the
-    // multi-line command body and stdout preview only earn space while running
-    // (you want to see what's executing) or on failure (you need the error).
-    // Ctrl+O (verbose trace) shows everything.
-    const collapsedExecute = group.kind === "execute" && !group.pending && !waiting && !group.hasError;
-    // A model-provided bash description owns the header slot; the command then
-    // always renders as a block below. Without one, single-line commands that
-    // fit stay inline; anything longer becomes a wrapped block preserving the
-    // command's own line structure — commands are never clipped mid-line.
-    // Collapsed rows always inline the (truncated) command instead of a block.
-    const showDescription = group.kind === "execute" && !!group.description;
-    const inlineCommand = !showDescription && group.command
-        ? (group.kind === "execute"
-            ? (collapsedExecute || shouldInlineExecuteCommand(group, commandWidth)
-                ? truncateVisual(group.command.replace(/\s+/g, " "), commandWidth)
-                : undefined)
-            : (visualWidth(group.command) <= commandWidth ? group.command : undefined))
-        : undefined;
-    const commandBlock = group.command && !inlineCommand && !collapsedExecute
-        ? (group.kind === "execute"
-            ? executeCommandBlock(group, EXECUTE_COMMAND_BLOCK_MAX_LINES)
-            : { lines: [group.command], omitted: 0 })
-        : null;
-    const collapsedOutputLines = group.previewLines.length + group.omitted;
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: titleColor, children: group.title }), showDescription ? (_jsxs(Text, { color: theme.traceDetail, children: [" ", truncateVisual(group.description, commandWidth)] })) : inlineCommand ? (_jsxs(Text, { color: theme.traceCommand, children: [" ", inlineCommand] })) : !group.command && group.count !== undefined && group.noun ? (_jsxs(Text, { color: theme.traceCount, children: [" ", group.count, " ", group.noun] })) : null, status && _jsxs(Text, { color: status.color, children: [" ", status.text] })] }), commandBlock && commandBlock.lines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [commandBlock.lines.flatMap((line, idx) => wrapByVisualWidth(line || " ", Math.max(10, detailWidth - 2)).map((seg, segIdx) => (_jsx(Text, { color: theme.traceCommand, children: seg }, `cmd-${idx}-${segIdx}`)))), commandBlock.omitted > 0 && (_jsxs(Text, { color: theme.traceDetail, children: ["\u2026 ", commandBlock.omitted, " more line", commandBlock.omitted === 1 ? "" : "s"] }))] })), collapsedExecute ? (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.traceDetail, children: ["\u23BF  ", collapsedOutputLines > 0
-                            ? `${collapsedOutputLines} line${collapsedOutputLines === 1 ? "" : "s"} output · Ctrl+O to view`
-                            : "no output"] }) })) : detailLines.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: detailLines.map((line, index) => (_jsxs(Box, { marginLeft: index === 0 ? 0 : 2, children: [index === 0 && _jsx(Text, { color: theme.traceDetail, children: "\u21B3 " }), _jsx(Text, { color: detailColor, children: truncateVisual(line, detailWidth - (index === 0 ? 2 : 0)) })] }, index))) })), group.errorLines.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: group.errorLines.map((line, index) => (_jsxs(Box, { marginLeft: index === 0 ? 0 : 2, children: [index === 0 && _jsx(Text, { color: theme.traceDetail, children: "\u21B3 " }), _jsx(Text, { color: theme.error, children: truncateVisual(line, detailWidth - (index === 0 ? 2 : 0)) })] }, `error-${index}`))) })), group.omitted > 0 && !collapsedExecute && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.traceDetail, children: ["... ", group.omitted, " more, Ctrl+O to view"] }) }))] }));
-}
-function EditTraceBlock({ tool, details, terminalColumns, compactTop, status, }) {
-    const theme = useTheme();
-    const path = formatTracePath(details.path ?? tool.args.path ?? "");
-    const pathWidth = Math.max(14, terminalColumns - 12);
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: theme.traceAction, children: "Edit" }), path && _jsxs(Text, { color: theme.traceCommand, children: [" ", truncateVisual(path, pathWidth)] }), status && _jsxs(Text, { color: status.color, children: [" ", status.text] })] }), _jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: theme.traceDetail, children: "\u23BF  " }), _jsx(Text, { color: theme.success, children: formatEditSuccessSummary(details) })] }), _jsx(DiffBlock, { diff: details.diff, terminalColumns: terminalColumns, maxLines: EDIT_COLLAPSED_DIFF_LINES, verbose: false, showExpandHint: true })] }));
-}
-function traceGroupStatus(group, waitingApproval, theme, nowTick) {
-    if (waitingApproval)
-        return { text: "waiting for approval", color: theme.warning };
-    if (group.pending) {
-        void nowTick;
-        return { text: "running", color: theme.tracePending };
-    }
-    if (group.hasError) {
-        const count = group.errorCount || 1;
-        return { text: count === 1 ? "1 error" : `${count} errors`, color: theme.error };
-    }
-    return null;
-}
-function findActiveTraceGroup(groups, pendingApproval) {
-    for (let i = groups.length - 1; i >= 0; i--) {
-        const group = groups[i];
-        if (isTraceGroupWaitingForApproval(group, pendingApproval) || group.pending) {
-            return group;
-        }
-    }
-    return undefined;
-}
-function isTraceGroupWaitingForApproval(group, pendingApproval) {
-    return !!pendingApproval && group.raw.some((tool) => isToolPending(tool) && approvalMatchesTool(pendingApproval, tool));
-}
-function approvalMatchesTool(hint, tc) {
-    if (hint.toolName !== tc.name)
-        return false;
-    if (hint.toolName === "bash") {
-        return !hint.command || hint.command === tc.args.command;
-    }
-    return !hint.path || hint.path === tc.args.path;
-}
-function isToolPending(tool) {
-    return tool.result === undefined;
-}
-/** Live rolling window size — enough to read the model's train of thought. */
-const REASONING_STREAM_WINDOW = 5;
-/** Lines kept when a finished turn's reasoning is collapsed. */
-const REASONING_COLLAPSED_LINES = 2;
-/**
- * Reasoning trace with three states, because a reasoning model can spend
- * minutes here (qwen3.8-max at high effort drafts entire files in thought):
- * hiding it looks like a hang, printing all of it buries the transcript.
- *
- *   streaming + compact  rolling last N lines, so there is always motion
- *   settled + compact    opening lines + "(ctrl+o to expand)"
- *   expanded             everything (Ctrl+T thinking, or Ctrl+O verbose)
- */
-function ReasoningTraceBlock({ reasoning, expanded = false, streaming = false, }) {
-    const theme = useTheme();
-    const lines = React.useMemo(() => reasoning.split("\n").filter((l) => l.trim() !== ""), [reasoning]);
-    if (lines.length === 0)
-        return null;
-    const visible = expanded
-        ? lines
-        : streaming
-            ? lines.slice(-REASONING_STREAM_WINDOW)
-            : lines.slice(0, REASONING_COLLAPSED_LINES);
-    const hidden = lines.length - visible.length;
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: theme.thinkingDim, dimColor: true, children: ["\u273B ", streaming && !expanded ? "Thinking…" : "Thinking"] }), visible.map((line, i) => (_jsx(Text, { color: theme.thinkingDim, dimColor: true, italic: true, children: line }, i))), hidden > 0 && (_jsx(Text, { color: theme.thinkingDim, dimColor: true, children: streaming ? "…" : "… (ctrl+o to expand)" }))] }));
-}
-function CompactionSummaryBlock({ message }) {
-    const theme = useTheme();
-    const rawStatus = message.content.replace(/^✓\s*/, "").trim();
-    const status = rawStatus.replace(/^Compaction complete\s*(?:·\s*)?/i, "").trim() || "Session compacted";
-    // Same defense as every other visible-text path: strip any internal reminder
-    // markup before rendering, so a summary that echoed it never reaches the
-    // transcript. Belt-and-suspenders — the summarizer is fed sanitized history,
-    // but the summary is model-generated and also re-injected as context.
-    // File-tracking blocks (<read-files>/<modified-files>) are model-facing
-    // bookkeeping welded onto the summary — never render them raw either.
-    const summary = stripFileBlocks(sanitizeInternalReminderBlocks(message.compactionSummary ?? "")).trim() || undefined;
-    return (_jsxs(Box, { marginTop: 1, marginBottom: 1, paddingX: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.borderActive, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.success, bold: true, children: "\u2713 " }), _jsx(Text, { color: theme.accent, bold: true, children: "Compaction checkpoint" }), _jsxs(Text, { color: theme.muted, children: [" \u00B7 ", status] })] }), summary && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.muted, dimColor: true, children: "Preserved context summary" }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: _jsx(MarkdownContent, { content: summary }) })] }))] }));
-}
-function UserMessageBlock({ content, terminalColumns, inputStatus, separateFromPrevious = false, }) {
-    const theme = useTheme();
-    const badge = userInputStatusBadgeLabel(inputStatus);
-    // Defense in depth: pure internal-block rows are dropped upstream
-    // (isInternalBlockOnlyContent), but a block with trailing text — or a
-    // truncated block — would slip that anchored filter. Never render markup.
-    const visibleContent = sanitizeInternalReminderBlocks(content);
-    // Preserve the message's existing text inset after removing the decorative
-    // rail: the former two rail columns become ordinary background padding.
-    const leftPaddingWidth = 3;
-    const rightPaddingWidth = 1;
-    const horizontalRoom = Math.max(20, terminalColumns - 2);
-    const bubbleTextWidth = Math.max(1, horizontalRoom - leftPaddingWidth - rightPaddingWidth);
-    const { bodyLines, referenceLines } = splitImageDisplayContent(visibleContent);
-    const wrappedLines = bodyLines
-        .flatMap((line) => wrapByVisualWidth(line, bubbleTextWidth));
-    const attachmentReferenceIndent = " ".repeat(leftPaddingWidth);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: separateFromPrevious ? 1 : 0, children: [badge && (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: inputStatus === "pending_steer" ? theme.warning : theme.muted, children: ` ${badge} ` }), _jsx(Text, { color: theme.dim, children: inputStatus === "pending_steer" ? "applies at the next model call" : "runs after this turn" })] })), wrappedLines.map((line, index) => (_jsx(Box, { children: _jsx(Text, { backgroundColor: theme.userMessageBg, color: theme.userMessageText, children: `${" ".repeat(leftPaddingWidth)}${padVisual(line || " ", bubbleTextWidth)}${" ".repeat(rightPaddingWidth)}` }) }, index))), referenceLines.map((line, index) => (_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: `${attachmentReferenceIndent}${line}` }) }, `attachment-${index}`)))] }));
-}
-function PendingInputMessagesBlock({ messages, terminalColumns, title, hint, bulletColor, }) {
-    const theme = useTheme();
-    // Inset per row: marginLeft (2) + "↳ " (2) + the transcript row padding.
-    const contentWidth = Math.max(20, terminalColumns - 4 - TRANSCRIPT_ROW_PADDING);
-    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: bulletColor, children: "\u2022 " }), _jsxs(Text, { bold: true, color: theme.inputText, children: [title, " "] }), _jsxs(Text, { color: theme.dim, children: ["(", hint, ")"] })] }), messages.flatMap((message, messageIndex) => {
-                const { bodyLines, referenceLines } = splitImageDisplayContent(message.content || " ");
-                const wrappedBody = bodyLines.flatMap((line) => wrapByVisualWidth(line || " ", contentWidth));
-                const bodyRows = wrappedBody.map((line, lineIndex) => (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: theme.dim, children: lineIndex === 0 ? "↳ " : "  " }), _jsx(Text, { color: theme.inputText, children: line })] }, `body-${message.key ?? messageIndex}-${lineIndex}`)));
-                const attachmentRows = referenceLines.map((line, lineIndex) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.dim, children: ["  ", line] }) }, `attachment-${message.key ?? messageIndex}-${lineIndex}`)));
-                return [...bodyRows, ...attachmentRows];
-            })] }));
-}
-const TOOL_DISPLAY_NAMES = {
-    read: "Read",
-    write: "Write",
-    edit: "Edit",
-    bash: "Bash",
-    grep: "Grep",
-    glob: "Glob",
-    web_fetch: "WebFetch",
-    web_search: "WebSearch",
-};
-const TOOL_GLYPHS = {
-    read: "⏺",
-    write: "✎",
-    edit: "✎",
-    bash: "▶",
-    grep: "⌕",
-    glob: "⌕",
-    web_fetch: "⇲",
-    web_search: "⌕",
-    task: "↳",
-    skill: "★",
-};
-function displayToolName(name) {
-    if (TOOL_DISPLAY_NAMES[name])
-        return TOOL_DISPLAY_NAMES[name];
-    return name.charAt(0).toUpperCase() + name.slice(1);
-}
-function toolGlyph(name) {
-    return TOOL_GLYPHS[name] ?? "●";
-}
-function getToolHeader(toolCall) {
-    const args = toolCall.args || {};
-    const trunc = (s, n = 50) => (s.length > n ? s.slice(0, n) + "..." : s);
-    switch (toolCall.name) {
-        case "read":
-        case "write":
-        case "edit":
-            return args.path ? trunc(String(args.path), 60) : undefined;
-        case "bash":
-            return args.command ? trunc(String(args.command).replace(/\n/g, " "), 60) : undefined;
-        case "grep":
-            return args.pattern ? trunc(String(args.pattern), 60) : undefined;
-        case "glob":
-            return args.pattern ? trunc(String(args.pattern), 60) : undefined;
-        case "web_fetch":
-            return args.url ? trunc(String(args.url), 60) : undefined;
-        case "web_search":
-            return args.query ? trunc(String(args.query), 60) : undefined;
-        default:
-            return undefined;
-    }
-}
-function summarizeToolResult(tc) {
-    if (tc.result === undefined)
-        return "pending";
-    const raw = tc.result.replace(/\r\n/g, "\n");
-    if (tc.isError) {
-        const firstLine = raw.split("\n").find((l) => l.trim() !== "") || "Error";
-        return firstLine.length > 80 ? firstLine.slice(0, 80) + "..." : firstLine;
-    }
-    const nonEmpty = raw.split("\n").filter((l) => l.trim() !== "");
-    const lineCount = nonEmpty.length;
-    const p = (n, singular, plural) => `${n} ${n === 1 ? singular : plural}`;
-    switch (tc.name) {
-        case "read":
-            return p(lineCount, "line", "lines");
-        case "write": {
-            const firstLine = raw.split("\n")[0] || "";
-            if (firstLine.startsWith("Wrote ") || firstLine.startsWith("Updated ")) {
-                return firstLine;
-            }
-            return "Wrote file";
-        }
-        case "edit": {
-            return formatEditSuccessSummary(getEditDiffDetails(tc));
-        }
-        case "bash":
-            return lineCount > 0 ? `${p(lineCount, "line", "lines")} output` : "Done";
-        case "grep":
-            return `Found ${p(lineCount, "match", "matches")}`;
-        case "glob":
-            return `Found ${p(lineCount, "file", "files")}`;
-        case "web_search":
-            return `${p(lineCount, "result", "results")}`;
-        case "web_fetch":
-            return p(lineCount, "line", "lines");
-        default:
-            return lineCount > 0 ? p(lineCount, "line", "lines") : "Done";
-    }
-}
-function subagentsFrom(toolCall) {
-    const raw = toolCall.metadata?.subagents;
-    if (!Array.isArray(raw))
-        return [];
-    return raw.filter((item) => typeof item === "object" && item !== null);
-}
-const COLLAPSED_PREVIEW_LINES = 10;
-const EXPANDED_PREVIEW_LINES = 50;
-function ToolCallDisplay({ toolCall, isStreaming, verbose, terminalColumns, showExpandHint = false, waitingApproval = false, compactTop = false, nowTick, }) {
-    const theme = useTheme();
-    if (toolCall.metadata?.kind === "subagent") {
-        return (_jsx(SubagentToolDisplay, { toolCall: toolCall, verbose: verbose, terminalColumns: terminalColumns, compactTop: compactTop }));
-    }
-    // Show raw output immediately, then upgrade to highlighted ANSI when shiki
-    // resolves. Avoids a noticeable "flash" where the line jumps from empty/raw
-    // to colorized after a tick.
-    const initialPreview = React.useMemo(() => {
-        if (toolCall.result === undefined || toolCall.isError)
-            return null;
-        return toolCall.result.replace(/\r\n/g, "\n");
-    }, [toolCall.result, toolCall.isError]);
-    const [highlighted, setHighlighted] = React.useState(initialPreview);
-    const header = getToolHeader(toolCall);
-    const maxLines = verbose ? EXPANDED_PREVIEW_LINES : COLLAPSED_PREVIEW_LINES;
-    React.useEffect(() => {
-        let cancelled = false;
-        if (toolCall.result === undefined || toolCall.isError) {
-            setHighlighted(null);
-            return;
-        }
-        const raw = toolCall.result.replace(/\r\n/g, "\n");
-        let lang = "text";
-        if (toolCall.name === "read")
-            lang = inferLang(toolCall.args.path);
-        else if (toolCall.name === "bash")
-            lang = "shell";
-        // Always seed with raw so the user sees content immediately.
-        setHighlighted(raw);
-        if (lang === "text") {
-            return;
-        }
-        highlightCode(raw, lang)
-            .then((out) => {
-            if (!cancelled)
-                setHighlighted(out);
-        })
-            .catch(() => {
-            if (!cancelled)
-                setHighlighted(raw);
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [toolCall.result, toolCall.name, toolCall.args.path, toolCall.isError]);
-    const glyph = toolGlyph(toolCall.name);
-    const bulletColor = toolCall.isError
-        ? theme.error
-        : waitingApproval
-            ? theme.warning
-            : isStreaming
-                ? theme.toolPending
-                : theme.user;
-    const name = displayToolName(toolCall.name);
-    // Compose summary: pending tools stay compact; waiting-for-approval gets an
-    // explicit badge so the trail survives the dialog closing.
-    let summary;
-    let summaryColor = theme.muted;
-    if (waitingApproval) {
-        summary = "⏸ waiting for approval";
-        summaryColor = theme.warning;
-    }
-    else if (isToolPending(toolCall) && toolCall.startedAt) {
-        void nowTick;
-        summary = "running";
-        summaryColor = theme.toolPending;
-    }
-    else {
-        summary = summarizeToolResult(toolCall);
-        if (toolCall.isError)
-            summaryColor = theme.error;
-        else if (toolCall.name === "edit" && toolCall.result !== undefined)
-            summaryColor = theme.success;
-    }
-    const editDetails = getEditDiffDetails(toolCall);
-    const isEditDiff = editDetails !== null && toolCall.result !== undefined;
-    // Only show the file preview once the tool actually executed. During the
-    // streaming-args phase, args.content is incomplete and re-rendering the
-    // entire body per delta both looks chaotic and breaks on partial escapes.
-    const isWritePreview = toolCall.name === "write" && !toolCall.isError && toolCall.result !== undefined;
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: bulletColor, children: [glyph, " "] }), _jsx(Text, { bold: true, color: theme.toolName, children: name }), header && _jsxs(Text, { color: theme.muted, children: ["(", header, ")"] })] }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: summaryColor, children: ["\u23BF  ", summary] }) }), toolCall.isError && toolCall.result && (_jsx(Box, { marginLeft: 4, flexDirection: "column", children: toolCall.result.replace(/\r\n/g, "\n").split("\n").slice(0, 6).map((line, i) => (_jsx(Text, { color: theme.error, children: line }, i))) })), isEditDiff && (_jsx(DiffBlock, { diff: editDetails.diff, terminalColumns: terminalColumns, maxLines: maxLines, verbose: verbose, showExpandHint: showExpandHint })), isWritePreview && (_jsx(WritePreview, { content: String(toolCall.args.content || ""), maxLines: maxLines, verbose: verbose, showExpandHint: showExpandHint })), !toolCall.isError && !isEditDiff && !isWritePreview && highlighted && (_jsx(OutputPreview, { text: highlighted, maxLines: maxLines, verbose: verbose, showExpandHint: showExpandHint }))] }));
-}
-function SubagentToolDisplay({ toolCall, verbose, terminalColumns, compactTop, }) {
-    const theme = useTheme();
-    const subagents = subagentsFrom(toolCall);
-    const hasError = toolCall.isError || subagents.some((subagent) => (subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled"));
-    const bulletColor = hasError ? theme.error : isToolPending(toolCall) ? theme.toolPending : theme.user;
-    const detailWidth = Math.max(24, terminalColumns - 10);
-    const rows = verbose ? sortSubagents(subagents) : sortSubagents(subagents).slice(0, 4);
-    const omitted = Math.max(0, subagents.length - rows.length);
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: compactTop ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: bulletColor, children: "\u21B3 " }), _jsx(Text, { bold: true, color: theme.toolName, children: "Subagents" }), subagents.length > 0 && _jsxs(Text, { color: theme.muted, children: [" ", subagentSummary(subagents)] })] }), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [rows.map((subagent, index) => {
-                        const status = subagent.status ?? "running";
-                        const label = padVisual(truncateVisual(subagentLabel(subagent), 10), 10);
-                        const descriptorWidth = verbose ? 42 : 32;
-                        const descriptor = padVisual(truncateVisual(subagentDescriptor(subagent), descriptorWidth), descriptorWidth);
-                        const note = truncateVisual(latestSubagentNote(subagent), Math.max(12, detailWidth - 16 - descriptorWidth - 10));
-                        return (_jsxs(Box, { children: [_jsx(Text, { color: subagentStatusColor(status, theme), children: label }), _jsxs(Text, { color: theme.traceAction, children: [" ", descriptor] }), _jsxs(Text, { color: subagentStatusColor(status, theme), children: [" ", padVisual(status, 9)] }), note && _jsxs(Text, { color: subagent.error ? theme.error : theme.traceDetail, children: [" ", note] })] }, subagent.subAgentId ?? `${subagentLabel(subagent)}-${index}`));
-                    }), omitted > 0 && (_jsxs(Text, { color: theme.muted, children: ["... ", omitted, " more \u00B7 Ctrl+O to expand \u00B7 \u2193 then Enter to inspect traces"] }))] })), subagents.length === 0 && toolCall.result && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: hasError ? theme.error : theme.muted, children: summarizeToolResult(toolCall) }) }))] }));
-}
-function TruncationHint({ remaining, verbose, showExpandHint, }) {
-    const theme = useTheme();
-    if (remaining <= 0)
-        return null;
-    const noun = `line${remaining === 1 ? "" : "s"}`;
-    if (verbose) {
-        return (_jsxs(Text, { color: theme.muted, children: ["... (", remaining, " more ", noun, ")"] }));
-    }
-    return (_jsxs(Text, { color: theme.muted, children: ["\u2026 +", remaining, " ", noun, showExpandHint ? " (ctrl+o to expand)" : ""] }));
-}
-function OutputPreview({ text, maxLines, verbose, showExpandHint, }) {
-    const theme = useTheme();
-    const lines = text.split("\n");
-    const shown = lines.slice(0, maxLines);
-    const remaining = Math.max(0, lines.length - maxLines);
-    if (shown.length === 0 || (shown.length === 1 && shown[0] === ""))
-        return null;
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [shown.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "\u2502 " }), _jsx(Text, { children: line })] }, i))), _jsx(TruncationHint, { remaining: remaining, verbose: verbose, showExpandHint: showExpandHint })] }));
-}
-function WritePreview({ content, maxLines, verbose, showExpandHint, }) {
-    const theme = useTheme();
-    const lines = content.split("\n");
-    const shown = lines.slice(0, maxLines);
-    const remaining = Math.max(0, lines.length - maxLines);
-    const numWidth = Math.max(2, String(lines.length).length);
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [shown.map((line, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: theme.muted, children: [String(i + 1).padStart(numWidth, " "), "  "] }), _jsx(Text, { children: line })] }, i))), _jsx(TruncationHint, { remaining: remaining, verbose: verbose, showExpandHint: showExpandHint })] }));
-}
-function parseDiffLines(body) {
-    const result = [];
-    let oldNum = 0;
-    let newNum = 0;
-    const rawLines = body.split("\n");
-    if (rawLines[rawLines.length - 1] === "")
-        rawLines.pop();
-    for (const raw of rawLines) {
-        if (raw.startsWith("+++") ||
-            raw.startsWith("---") ||
-            raw.startsWith("Index:") ||
-            raw.startsWith("==="))
-            continue;
-        if (raw.startsWith("@@")) {
-            const m = raw.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-            if (m) {
-                oldNum = parseInt(m[1], 10);
-                newNum = parseInt(m[2], 10);
-            }
-            continue;
-        }
-        if (raw.startsWith("+")) {
-            result.push({ type: "add", num: newNum, content: raw.slice(1) });
-            newNum++;
-        }
-        else if (raw.startsWith("-")) {
-            result.push({ type: "remove", num: oldNum, content: raw.slice(1) });
-            oldNum++;
-        }
-        else {
-            const content = raw.startsWith(" ") ? raw.slice(1) : raw;
-            result.push({ type: "context", num: newNum, content });
-            oldNum++;
-            newNum++;
-        }
-    }
-    return result;
-}
-function DiffBlock({ diff, terminalColumns, maxLines, verbose, showExpandHint, }) {
-    const theme = useTheme();
-    const lines = parseDiffLines(diff);
-    const shown = lines.slice(0, maxLines);
-    const remaining = Math.max(0, lines.length - maxLines);
-    const maxNum = lines.reduce((acc, l) => Math.max(acc, l.num), 0);
-    const numWidth = Math.max(2, String(maxNum).length);
-    const leftMargin = 2;
-    const prefixWidth = numWidth + 4; // " NUM ± "
-    // Reserve the full left-margin chain from terminal edge to diff content:
-    // app padding (1) + ToolCallDisplay marginLeft (2) + DiffBlock marginLeft (2)
-    // + right padding (1) + 1-col safety = 7. Without this, each row overflows
-    // by 1 column, the terminal auto-wraps, and every line renders with a blank
-    // row beneath it.
-    const bandWidth = Math.max(10, terminalColumns - 7);
-    const contentWidth = Math.max(1, bandWidth - prefixWidth);
-    const blankPrefix = " ".repeat(prefixWidth);
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: leftMargin, children: [shown.flatMap((line, i) => {
-                const bg = line.type === "add"
-                    ? theme.diffAdd
-                    : line.type === "remove"
-                        ? theme.diffRemove
-                        : undefined;
-                const sign = line.type === "add" ? "+" : line.type === "remove" ? "-" : " ";
-                const numStr = String(line.num).padStart(numWidth, " ");
-                // Soft-wrap long lines at the terminal-derived content width so narrow
-                // splits still show the full content. Continuation rows reuse the same
-                // background but blank out the gutter (no line number, no +/-) so a
-                // reader can tell at a glance which rows belong to the same logical
-                // diff line.
-                const segments = wrapByVisualWidth(line.content, contentWidth);
-                return segments.map((segment, segIdx) => {
-                    const padded = padVisual(segment, contentWidth);
-                    const prefix = segIdx === 0 ? ` ${numStr} ${sign} ` : blankPrefix;
-                    return (_jsx(Text, { backgroundColor: bg, color: theme.userMessageText, children: `${prefix}${padded}` }, `${i}-${segIdx}`));
-                });
-            }), _jsx(TruncationHint, { remaining: remaining, verbose: verbose, showExpandHint: showExpandHint })] }));
-}
-/**
- * "Edited 3 files (+42 -8) — a.ts, b.ts" digest below the assistant turn.
- * Surfaces only when there is at least one file-mutating tool call.
- */
-function TurnDigest({ toolCalls }) {
-    const theme = useTheme();
-    const digest = React.useMemo(() => buildDigest(toolCalls), [toolCalls]);
-    if (!digest)
-        return null;
-    return (_jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsx(Text, { color: theme.muted, dimColor: true, children: digest }) }));
-}
-function TaskDurationLine({ elapsedMs }) {
-    const theme = useTheme();
-    return (_jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsxs(Text, { color: theme.muted, dimColor: true, children: ["Task duration: ", formatDuration(elapsedMs)] }) }));
-}
-function buildDigest(toolCalls) {
-    const paths = new Set();
-    let added = 0;
-    let removed = 0;
-    let writes = 0;
-    let edits = 0;
-    for (const tc of toolCalls) {
-        if (tc.isError || !tc.result)
-            continue;
-        if (tc.name === "edit") {
-            const details = getEditDiffDetails(tc);
-            if (details) {
-                added += details.added;
-                removed += details.removed;
-            }
-            if (tc.args.path)
-                paths.add(String(tc.args.path));
-            edits += 1;
-        }
-        else if (tc.name === "write") {
-            if (tc.args.path)
-                paths.add(String(tc.args.path));
-            writes += 1;
-            const content = String(tc.args.content ?? "");
-            if (content)
-                added += content.split("\n").length;
-        }
-    }
-    const total = edits + writes;
-    if (total === 0 || paths.size === 0)
-        return null;
-    const verb = edits > 0 && writes === 0 ? "Edited" : writes > 0 && edits === 0 ? "Wrote" : "Touched";
-    const pathList = Array.from(paths);
-    const shownPaths = pathList.slice(0, 4).map((p) => p.split("/").pop() || p);
-    const extra = pathList.length - shownPaths.length;
-    const pathDisplay = shownPaths.join(", ") + (extra > 0 ? `, +${extra} more` : "");
-    const stats = added || removed
-        ? ` (${added ? `+${added}` : ""}${added && removed ? " " : ""}${removed ? `-${removed}` : ""})`
-        : "";
-    return `↳ ${verb} ${paths.size} file${paths.size === 1 ? "" : "s"}${stats} — ${pathDisplay}`;
-}
-function formatDuration(ms) {
-    if (!Number.isFinite(ms) || ms <= 0)
-        return "0s";
-    if (ms < 1000)
-        return `${Math.max(1, Math.round(ms))}ms`;
-    const seconds = ms / 1000;
-    if (seconds < 10)
-        return `${seconds.toFixed(1)}s`;
-    if (seconds < 60)
-        return `${Math.round(seconds)}s`;
-    let minutes = Math.floor(seconds / 60);
-    let remSec = Math.round(seconds - minutes * 60);
-    if (remSec >= 60) {
-        minutes += Math.floor(remSec / 60);
-        remSec %= 60;
-    }
-    return remSec === 0 ? `${minutes}m` : `${minutes}m ${remSec}s`;
-}
-function truncateVisual(str, maxWidth) {
-    if (maxWidth <= 0)
-        return "";
-    let out = "";
-    let width = 0;
-    for (const char of str) {
-        const w = graphemeWidth(char);
-        if (width + w > maxWidth)
-            break;
-        out += char;
-        width += w;
-    }
-    return out;
-}
-function padVisual(str, width) {
-    const currentWidth = visualWidth(str);
-    return str + " ".repeat(Math.max(0, width - currentWidth));
-}
-function wrapByVisualWidth(line, maxWidth) {
-    if (maxWidth <= 0)
-        return [line];
-    if (line === "")
-        return [""];
-    const result = [];
-    let current = "";
-    let currentWidth = 0;
-    for (const char of line) {
-        const w = graphemeWidth(char);
-        if (currentWidth + w > maxWidth) {
-            result.push(current);
-            current = char;
-            currentWidth = w;
-        }
-        else {
-            current += char;
-            currentWidth += w;
-        }
-    }
-    if (current !== "" || result.length === 0)
-        result.push(current);
-    return result;
-}