@bubblebrain-ai/bubble 0.0.46 → 0.0.48

package/dist/tui-ink/app.js

@@ -2,14 +2,14 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import { AgentAbortError, INTERRUPTED_ASSISTANT_CONTENT } from "../agent.js";
-import { isHiddenToolMetadata } from "../agent/discovery-barrier.js";
+import { isHiddenToolMetadata } from "../agent/tool-visibility.js";
 import { SessionManager } from "../session.js";
 import { registry as slashRegistry } from "../slash-commands/index.js";
 import { UserConfig, maskKey } from "../config.js";
 import { InputBox, isCtrlCInput, isCtrlLetterInput, } from "./input-box.js";
 import { MessageList } from "./message-list.js";
 import { isMultiplexedTerminal } from "./terminal-env.js";
-import { appendTextPart, appendToolPart, compactDisplayMessages, contentFromParts, latestCompactionSummary, moveStatusMessageToEnd, nextDisplayMessageKey, setUserInputStatus, snapshotDisplayParts, stripInterruptedAssistantMarker, toolCallsFromParts, } from "./display-history.js";
+import { appendTextPart, appendToolPart, contentFromParts, latestCompactionSummary, moveStatusMessageToEnd, nextDisplayMessageKey, setUserInputStatus, snapshotDisplayParts, stripInterruptedAssistantMarker, toolCallsFromParts, } from "./display-history.js";
 import { AgentRunInputQueue } from "../agent/input-controller.js";
 import { canvasBackgroundFor, paletteFor, ThemeProvider, useTheme } from "./theme.js";
 import { isPrintablePickerInput, ModelPicker, ProviderPicker, KeyPicker, SkillPicker } from "./model-picker.js";
@@ -45,7 +45,7 @@ import { continuationPrompt, initialPrompt } from "../goal/prompts.js";
 import { shouldContinueGoal, stopReasonNotice } from "../goal/engine.js";
 import { goalCompleteNotice, goalIndicatorLine, goalSummaryText } from "../goal/format.js";
 import { tokenUsageTotal } from "../goal/usage.js";
-import { formatInternalContextBlock } from "../agent/internal-reminder-sanitizer.js";
+import { formatInternalContextBlock, isInternalBlockOnlyContent } from "../agent/internal-reminder-sanitizer.js";
 import { MAX_ACTIVE_LOOPS, decideLoopFiring, formatInterval, formatLoopList, parseLoopCommand, } from "../loop/engine.js";
 import { TaskWakeCoalescer, findDanglingTaskStarts, formatTaskWakeSummary, isPidAlive, shouldFireTaskWake, taskEligibleForWake, } from "../tasks/wake.js";
 const TASK_WAKE_DEBOUNCE_MS = 2000;
@@ -87,17 +87,9 @@ function buildTips(agent, registry, grokActive = false) {
 function slashResultNoticeKind(result) {
     return /^(Grok m|M)odel switched to /.test(result) ? "ui_notice" : undefined;
 }
-/**
- * True when a user message is nothing but harness-injected internal blocks
- * (goal kicks, task wakes) — hidden live, so hidden on reconstruction too.
- */
-export function isInternalBlockOnlyContent(content) {
-    if (typeof content !== "string")
-        return false;
-    const trimmed = content.trim();
-    return /^<bubble_internal_(?:context|reminder)\b/.test(trimmed)
-        && /<\/bubble_internal_(?:context|reminder)>$/.test(trimmed);
-}
+// Canonical implementation lives in the sanitizer module so non-TUI surfaces
+// (session pickers, desktop host) share it; re-exported here for existing users.
+export { isInternalBlockOnlyContent };
 /** Status-row summary for running background tasks (design §2.5). */
 function taskRowSummary(tasks, nowTick) {
     const first = tasks[0];
@@ -298,7 +290,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     const themePickerRevertRef = useRef("auto");
     const themeResolved = themeMode === "auto" ? autoResolved : themeMode;
     const { exit } = useApp();
-    const [messages, setMessages] = useState(() => compactDisplayMessages(reconstructDisplayMessages(agent.messages)));
+    const [messages, setMessages] = useState(() => reconstructDisplayMessages(agent.messages));
     const nextImageDisplayLabelStartRef = useRef(nextImageDisplayLabelStart(messages));
     const [isRunning, setIsRunning] = useState(false);
     const [streamingContent, setStreamingContent] = useState("");
@@ -733,9 +725,10 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         // <system-reminder>, so we do not rebuild the cache-friendly system prompt here.
         if (key.tab && key.shift && !pickerMode) {
             const nextMode = getNextPermissionMode(agent.mode);
+            // setMode fires onModeUpdate, which is the single writer of the
+            // mode_switch marker — appending here too double-logs every switch.
             agent.setMode(nextMode);
             setPermissionMode(nextMode);
-            sessionManager?.appendMarker("mode_switch", nextMode);
             return;
         }
         if (key.escape && !pickerMode) {
@@ -746,7 +739,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         }
     });
     const updateDisplayMessages = useCallback((updater) => {
-        setMessages((prev) => compactDisplayMessages(updater(prev).map(withMessageKey)));
+        setMessages((prev) => updater(prev).map(withMessageKey));
     }, []);
     // Non-append transcript rebuilds (/clear, /compact, /rewind, session switch)
     // replace the settled list rather than extending it. The rows already
@@ -1662,8 +1655,8 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                                 break;
                             }
                             case "mode_changed": {
+                                // Marker already persisted by onModeUpdate at setMode time.
                                 setPermissionMode(event.mode);
-                                sessionManager?.appendMarker("mode_switch", event.mode);
                                 break;
                             }
                             case "input_applied": {

package/dist/tui-ink/display-history.d.ts

@@ -49,7 +49,6 @@ export interface DisplayToolCall {
      */
     rawArguments?: string;
     result?: string;
-    resultCollapsed?: boolean;
     isError?: boolean;
     metadata?: ToolResultMetadata;
     /** Set when the tool_start event was received. Used to render elapsed time. */
@@ -61,7 +60,6 @@ export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: Di
 export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
 export declare function contentFromParts(parts: DisplayMessagePart[]): string;
 export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
-export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
 /**
  * Find the most recent compaction summary embedded in the agent's system
  * messages. Bubble's compaction step rewrites the system transcript so that

package/dist/tui-ink/display-history.js

@@ -87,64 +87,12 @@ export function contentFromParts(parts) {
 export function toolCallsFromParts(parts) {
     return parts.flatMap((part) => part.type === "tools" ? part.toolCalls : []);
 }
-const FULL_DETAIL_WINDOW = 24;
-// Folding policy: message text (content, reasoning) is NEVER rewritten or
-// truncated — what the user or the assistant said renders verbatim. All
-// messages stay in the list (the alt-screen viewport scrolls them); older
-// messages only collapse bulky tool-result bodies, which the UI re-expands
-// on demand.
-export function compactDisplayMessages(messages) {
-    if (messages.length === 0) {
-        return messages;
-    }
-    const visible = messages.filter((message) => message.syntheticKind !== "ui_summary");
-    const detailStart = Math.max(0, visible.length - FULL_DETAIL_WINDOW);
-    return visible.map((message, index) => (index < detailStart ? compactDisplayMessage(message) : message));
-}
-// Messages that already went through compaction. Re-compacting them would
-// produce equal-but-new objects on every transcript update, which defeats the
-// React.memo row cache in message-list.tsx — settled rows must keep identity.
-const compactedMessages = new WeakSet();
-function compactDisplayMessage(message) {
-    if (message.syntheticKind) {
-        return message;
-    }
-    if (compactedMessages.has(message)) {
-        return message;
-    }
-    const compacted = {
-        ...message,
-        toolCalls: message.toolCalls?.map(compactToolCall),
-        parts: message.parts?.map(compactDisplayPart),
-    };
-    compactedMessages.add(compacted);
-    return compacted;
-}
 function cloneToolCall(toolCall) {
     return {
         ...toolCall,
         args: { ...toolCall.args },
     };
 }
-function compactDisplayPart(part) {
-    if (part.type === "text") {
-        return part;
-    }
-    return {
-        type: "tools",
-        toolCalls: part.toolCalls.map(compactToolCall),
-    };
-}
-function compactToolCall(toolCall) {
-    if (toolCall.result === undefined) {
-        return toolCall;
-    }
-    return {
-        ...toolCall,
-        result: undefined,
-        resultCollapsed: true,
-    };
-}
 const PREVIOUS_SUMMARY_PREFIX = /^Previous conversation summary:\s*\n?([\s\S]*)$/;
 const TURN_SUMMARY_PREFIX = /^Earlier in this turn \(compacted to free context\):\s*\n?([\s\S]*)$/;
 /**

package/dist/tui-ink/footer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { useTheme } from "./theme.js";
 import { PERMISSION_MODE_INFO } from "../permission/mode.js";
@@ -30,7 +30,7 @@ function ModeBadge({ mode }) {
     const info = PERMISSION_MODE_INFO[mode];
     const color = theme[info.color] ?? theme.muted;
     const symbol = info.symbol ? `${info.symbol} ` : "";
-    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: color, bold: true, children: [symbol, info.shortTitle, " on"] }), _jsx(Text, { color: theme.muted, children: " \u21E7\u21E5" })] }));
+    return (_jsxs(Text, { color: color, bold: true, children: [symbol, info.shortTitle, " on"] }));
 }
 export function buildFooterData(input) {
     return input;

package/dist/tui-ink/input-box.js

@@ -8,7 +8,7 @@ import { useTheme } from "./theme.js";
 import { filterFileSuggestions, findAtContext, listProjectFiles } from "./file-mentions.js";
 import { bareImageFilenameFromPaste, extractImagePathTokens, ingestClipboardImage, ingestImagePath, isImageFilePath, isScreenshotTempPath, splitPastedPaths, } from "./image-paste.js";
 import { appendHistoryEntry, loadHistoryEntriesSync, pushHistoryEntry, stepHistory, } from "./input-history.js";
-import { cloneComposerBuffer, createComposerBuffer, deleteComposerBackward, deleteComposerForward, expandComposerBuffer, hasActiveComposerPastes, insertComposerPaste, insertComposerText, moveComposerCursor, replaceComposerRange, } from "./composer-buffer.js";
+import { cloneComposerBuffer, createComposerBuffer, deleteComposerBackward, deleteComposerForward, expandComposerBuffer, insertComposerPaste, insertComposerText, moveComposerCursor, replaceComposerRange, } from "./composer-buffer.js";
 import { isKeyReleaseEvent } from "./key-events.js";
 import { PasteOperationTracker } from "./paste-operation-tracker.js";
 import { stripTerminalMouseSequences } from "./terminal-mouse.js";
@@ -26,6 +26,18 @@ export function createComposerDraftSnapshot(input) {
         imageLabelStartOverride: input.imageLabelStartOverride,
     };
 }
+/**
+ * Rebuild a composer buffer from a persisted history entry. Text long enough to
+ * have been collapsed at paste time is collapsed again into a `[Pasted text #N …]`
+ * marker, but its full content is preserved in the buffer's paste spans so the
+ * composer stays compact, no content is lost, and the next submit re-expands it.
+ */
+function bufferFromHistoryText(text) {
+    if (shouldCollapsePastedContent(text)) {
+        return insertComposerPaste(createComposerBuffer(), text);
+    }
+    return createComposerBuffer(text);
+}
 /**
  * Browse persisted history without turning marker-shaped text into live paste
  * tokens, while preserving the exact unsent draft in memory for the final
@@ -68,7 +80,7 @@ export function stepComposerHistory(state, history, direction) {
         };
     }
     return {
-        buffer: createComposerBuffer(result.text),
+        buffer: bufferFromHistoryText(result.text),
         attachments: (result.images ?? []).map((attachment) => ({ ...attachment })),
         imageLabelStartOverride: result.imageDisplayStart ?? null,
         historyIndex: result.index,
@@ -716,10 +728,10 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, onArrowDo
             return;
         submittedPayloadFingerprintRef.current = fingerprint;
         deliver(payload);
-        // A collapsed text-paste marker cannot be safely replayed once its
-        // in-memory reference is gone; skip those. Image-label stripping is fine to
-        // replay (the attachments are stored on the history entry).
-        if (!hasActiveComposerPastes(submittedBuffer) && (expandedText.trim().length > 0 || attachments.length > 0)) {
+        // Always record the submitted text so ↑/↓ can recall it. The full expanded
+        // text is persisted (content is never lost); on recall, long text is
+        // re-collapsed into a paste marker that still carries its full content.
+        if (expandedText.trim().length > 0 || attachments.length > 0) {
             const historyEntry = {
                 text: expandedText,
                 images: attachments,

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

@@ -10,6 +10,7 @@ import { buildTraceGroups, executeCommandBlock, formatTracePath, shouldInlineExe
 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;
 /**
@@ -152,7 +153,9 @@ const MessageItem = React.memo(function MessageItem({ message, terminalColumns,
             : sanitizeInternalReminderBlocks(part.content).trim() !== "");
     const toolCallCount = message.toolCalls?.length ?? 0;
     const hasVisibleAssistantContent = (hasParts ? hasVisibleParts : (!!visibleContent.trim() || toolCallCount > 0)) ||
-        (!!visibleReasoning && (showThinking || verboseTrace)) ||
+        // 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
@@ -160,7 +163,7 @@ const MessageItem = React.memo(function MessageItem({ message, terminalColumns,
         message.taskElapsedMs !== undefined;
     if (!hasVisibleAssistantContent)
         return null;
-    return (_jsxs(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [visibleReasoning && (showThinking || verboseTrace) && _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning }), 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() && (
+    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.
@@ -174,7 +177,7 @@ function StreamingMessage({ content, reasoning, tools, parts, terminalColumns, s
     const visibleParts = deferredParts.length > 0
         ? deferredParts
         : fallbackStreamingParts(deferredContent, tools);
-    return (_jsxs(Box, { flexDirection: "column", children: [visibleReasoning && (showThinking || verboseTrace) && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning }) })), visibleParts.length > 0 && (
+    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
@@ -279,22 +282,33 @@ function TraceGroupBlock({ group, terminalColumns, pendingApproval, compactTop,
     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"
-            ? (shouldInlineExecuteCommand(group, commandWidth) ? group.command : undefined)
+            ? (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
+    const commandBlock = group.command && !inlineCommand && !collapsedExecute
         ? (group.kind === "execute"
             ? executeCommandBlock(group, EXECUTE_COMMAND_BLOCK_MAX_LINES)
             : { lines: [group.command], omitted: 0 })
         : null;
-    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"] }))] })), 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 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.traceDetail, children: ["... ", group.omitted, " more, Ctrl+O to view"] }) }))] }));
+    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();
@@ -336,12 +350,33 @@ function approvalMatchesTool(hint, tc) {
     return !hint.path || hint.path === tc.args.path;
 }
 function isToolPending(tool) {
-    return tool.result === undefined && tool.resultCollapsed !== true;
+    return tool.result === undefined;
 }
-function ReasoningTraceBlock({ reasoning }) {
+/** 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]);
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: theme.thinkingDim, dimColor: true, children: ["\u273B Reasoning trace", lines.length > 0 ? ` · ${lines.length} line${lines.length === 1 ? "" : "s"}` : ""] }), lines.map((line, i) => (_jsx(Text, { color: theme.thinkingDim, dimColor: true, italic: true, children: line }, i)))] }));
+    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();
@@ -351,22 +386,29 @@ function CompactionSummaryBlock({ message }) {
     // 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.
-    const summary = sanitizeInternalReminderBlocks(message.compactionSummary ?? "").trim() || undefined;
+    // 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);
-    // Rail and its right gutter must share the bubble background; otherwise the
-    // terminal background shows up as a dark seam between rail and message.
-    const railWidth = 2;
+    // 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 - railWidth - 2);
-    const { bodyLines, referenceLines } = splitImageDisplayContent(content);
+    const bubbleTextWidth = Math.max(1, horizontalRoom - leftPaddingWidth - rightPaddingWidth);
+    const { bodyLines, referenceLines } = splitImageDisplayContent(visibleContent);
     const wrappedLines = bodyLines
         .flatMap((line) => wrapByVisualWidth(line, bubbleTextWidth));
-    const attachmentReferenceIndent = " ".repeat(railWidth + 1);
-    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) => (_jsxs(Box, { children: [_jsx(Text, { backgroundColor: theme.userMessageBg, color: theme.userRail, children: "▌ " }), _jsx(Text, { backgroundColor: theme.userMessageBg, color: theme.userMessageText, children: ` ${padVisual(line || " ", bubbleTextWidth)} ` })] }, index))), referenceLines.map((line, index) => (_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: `${attachmentReferenceIndent}${line}` }) }, `attachment-${index}`)))] }));
+    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();
@@ -434,8 +476,6 @@ function getToolHeader(toolCall) {
     }
 }
 function summarizeToolResult(tc) {
-    if (tc.resultCollapsed)
-        return tc.isError ? "error output collapsed" : "result collapsed";
     if (tc.result === undefined)
         return "pending";
     const raw = tc.result.replace(/\r\n/g, "\n");
@@ -557,13 +597,12 @@ function ToolCallDisplay({ toolCall, isStreaming, verbose, terminalColumns, show
             summaryColor = theme.success;
     }
     const editDetails = getEditDiffDetails(toolCall);
-    const isEditDiff = editDetails !== null && toolCall.result !== undefined && !toolCall.resultCollapsed;
-    const showSummary = !toolCall.resultCollapsed || waitingApproval;
+    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 && !toolCall.resultCollapsed;
-    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, ")"] })] }), showSummary && (_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 }))] }));
+    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();

package/dist/tui-ink/run.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
+import { END_SYNC, wrapSynchronizedOutput } from "./sync-output.js";
 import { App } from "./app.js";
 import { warmHighlighter } from "./code-highlight.js";
 export function createInkAppElement(agent, args, options, onExit) {
@@ -8,16 +9,17 @@ export function createInkAppElement(agent, args, options, onExit) {
 /**
  * Best-effort terminal restore for abnormal exits. Bubble renders into the
  * primary screen (no alt-screen, no mouse reporting) so the transcript flows
- * into the terminal's native scrollback — there is no global mouse/alt-screen
- * state to undo. We only make sure the cursor is visible again, mirroring
- * Ink's own teardown (idempotent when Ink already ran; load-bearing when it
- * didn't).
+ * into the terminal's native scrollback. We end synchronized output first —
+ * a crash between a frame's ?2026h and ?2026l would otherwise leave the
+ * terminal buffering until its own timeout — then restore the cursor,
+ * mirroring Ink's teardown (idempotent when Ink already ran; load-bearing
+ * when it didn't).
  */
 function restoreTerminal() {
     if (!process.stdout.isTTY)
         return;
     try {
-        process.stdout.write("\x1b[?25h");
+        process.stdout.write(`${END_SYNC}\x1b[?25h`);
     }
     catch {
         // stdout may already be destroyed during shutdown
@@ -77,6 +79,9 @@ export async function runTui(agent, args, options = {}) {
         // and frees the arrow keys for composer history. Only the streaming tail
         // and the composer live in the repainting region at the bottom.
         alternateScreen: false,
+        // Frames composite atomically via synchronized output (CSI ?2026) —
+        // kills erase-then-repaint flicker without alt-screen.
+        stdout: wrapSynchronizedOutput(process.stdout),
     });
     try {
         await instance.waitUntilExit();

package/dist/tui-ink/sync-output.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronized-output wrapper (CSI ?2026, "sync updates").
+ *
+ * Every frame Ink writes gets bracketed in begin/end synchronized-output so
+ * the terminal composites it atomically instead of painting mid-erase state —
+ * the primary source of visible flicker during streaming. This is exactly
+ * what pi's main-screen renderer does per paint batch; alt-screen is NOT
+ * required for it.
+ *
+ * Terminals that don't implement mode 2026 ignore unknown DEC private modes,
+ * so emitting unconditionally is safe; BUBBLE_NO_SYNC_OUTPUT=1 is the escape
+ * hatch for anything that misbehaves. Only string chunks are bracketed —
+ * Ink writes frames as strings; binary writes pass through untouched.
+ */
+export declare const BEGIN_SYNC = "\u001B[?2026h";
+export declare const END_SYNC = "\u001B[?2026l";
+export declare function wrapSynchronizedOutput(stream: NodeJS.WriteStream): NodeJS.WriteStream;

package/dist/tui-ink/sync-output.js

@@ -0,0 +1,35 @@
+/**
+ * Synchronized-output wrapper (CSI ?2026, "sync updates").
+ *
+ * Every frame Ink writes gets bracketed in begin/end synchronized-output so
+ * the terminal composites it atomically instead of painting mid-erase state —
+ * the primary source of visible flicker during streaming. This is exactly
+ * what pi's main-screen renderer does per paint batch; alt-screen is NOT
+ * required for it.
+ *
+ * Terminals that don't implement mode 2026 ignore unknown DEC private modes,
+ * so emitting unconditionally is safe; BUBBLE_NO_SYNC_OUTPUT=1 is the escape
+ * hatch for anything that misbehaves. Only string chunks are bracketed —
+ * Ink writes frames as strings; binary writes pass through untouched.
+ */
+export const BEGIN_SYNC = "\x1b[?2026h";
+export const END_SYNC = "\x1b[?2026l";
+export function wrapSynchronizedOutput(stream) {
+    if (!stream.isTTY || process.env.BUBBLE_NO_SYNC_OUTPUT === "1")
+        return stream;
+    return new Proxy(stream, {
+        get(target, prop) {
+            if (prop === "write") {
+                return (chunk, ...rest) => typeof chunk === "string" && chunk.length > 0
+                    ? target.write(BEGIN_SYNC + chunk + END_SYNC, ...rest)
+                    : target.write(chunk, ...rest);
+            }
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+        set(target, prop, value) {
+            Reflect.set(target, prop, value);
+            return true;
+        },
+    });
+}

package/dist/tui-ink/theme.d.ts

@@ -56,7 +56,6 @@ export interface Theme {
     userMessageBorder: string;
     userMessageBg: string;
     userMessageText: string;
-    userRail: string;
     /** Painted band backgrounds for diff lines inside user-message cards. */
     diffAdd: string;
     diffRemove: string;

package/dist/tui-ink/theme.js

@@ -46,7 +46,6 @@ export const darkTheme = {
     userMessageBorder: "#8A7FC6",
     userMessageBg: "#2a2a34",
     userMessageText: "#f3f3f7",
-    userRail: "#8A7FC6",
     diffAdd: "#1a3d1a",
     diffRemove: "#3d1a1a",
     diffAddFg: "green",
@@ -95,7 +94,6 @@ export const lightTheme = {
     userMessageBorder: "#356FD2",
     userMessageBg: "#F1F3F0",
     userMessageText: "#234B93",
-    userRail: "#356FD2",
     diffAdd: "#D7E8D8",
     diffRemove: "#F7DADC",
     diffAddFg: "#2F7D4A",

package/dist/tui-ink/trace-groups.js

@@ -387,7 +387,7 @@ function isFailedSubagent(subagent) {
     return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
 }
 function isToolPending(tool) {
-    return tool.result === undefined && tool.resultCollapsed !== true;
+    return tool.result === undefined;
 }
 function isDirectoryLikeGlob(pattern) {
     const normalized = pattern.trim();

package/dist/types.d.ts

@@ -130,7 +130,6 @@ export interface ToolResultMetadata {
     searchSignature?: string;
     searchFamily?: string;
     reason?: string;
-    arbiterNote?: string;
     diff?: string;
     addedLines?: number;
     removedLines?: number;
@@ -235,6 +234,15 @@ export interface ToolRegistryEntry extends ToolDefinition {
      * fan-out never share it (design v2 §2). Tools without it are shared as-is.
      */
     cloneForChild?: () => ToolRegistryEntry;
+    /**
+     * Optional availability predicate, evaluated on EVERY model call. When it
+     * returns false the tool is omitted from the provider's function list
+     * entirely — the model cannot see or call it — and reappears on the next
+     * call once the predicate flips. For state-gated tools (e.g. update_goal
+     * without an active goal) this removes the affordance itself instead of
+     * relying on description wording, which strong models ignore.
+     */
+    enabled?: () => boolean;
     /** Optional one-line summary for the Available tools section. */
     promptSnippet?: string;
     /** Optional tool-specific rules appended to the system prompt when this tool is active. */
@@ -314,6 +322,17 @@ export interface TokenUsage {
     reasoningTokens?: number;
     totalTokens?: number;
 }
+/**
+ * Priced token usage (see model-pricing.ts). Lives here rather than in
+ * model-pricing.ts because turn_end events carry it and model-pricing
+ * already imports from this module.
+ */
+export interface UsageCost {
+    currency: "USD" | "CNY";
+    cost: number;
+    /** True when the provider gave no cache breakdown and everything was billed at the miss rate. */
+    estimated: boolean;
+}
 export interface Provider {
     streamChat(messages: ProviderMessage[], options: {
         model: string;
@@ -410,6 +429,7 @@ export type AgentEvent = {
 } | {
     type: "turn_end";
     usage?: TokenUsage;
+    cost?: UsageCost;
     willContinue?: boolean;
 } | {
     type: "context_recovered";