@bubblebrain-ai/bubble 0.0.45 → 0.0.47

package/dist/slash-commands/commands.js

@@ -987,7 +987,7 @@ const builtinSlashCommandEntries = [
     },
     {
         name: "mcp",
-        description: "Manage MCP servers. Usage: /mcp [list|reconnect <name>]",
+        description: "Manage MCP servers. Usage: /mcp [list|tools <name>|reconnect <name>]",
         async handler(args, ctx) {
             const tokens = args.trim().split(/\s+/).filter(Boolean);
             const sub = tokens[0] ?? "list";
@@ -1009,46 +1009,60 @@ const builtinSlashCommandEntries = [
                 }
                 return `${name}: ${state.status.kind}`;
             }
+            if (sub === "tools") {
+                const name = tokens[1];
+                if (!name)
+                    return "Usage: /mcp tools <server-name>";
+                const state = ctx.mcpManager.getStates().find((s) => s.name === name);
+                if (!state)
+                    return `Unknown MCP server: ${name}`;
+                if (state.status.kind !== "connected") {
+                    return `${name} is not connected — no tools to list. Try /mcp reconnect ${name}.`;
+                }
+                const lines = [`Tools from ${name} (${state.status.tools.length}):`, ""];
+                for (const tool of state.status.tools) {
+                    lines.push(`- \`${tool.name}\`${tool.description ? ` — ${tool.description.replace(/\s+/g, " ").slice(0, 100)}` : ""}`);
+                }
+                return lines.join("\n");
+            }
             if (sub !== "list" && sub !== "") {
-                return `Unknown /mcp subcommand "${sub}". Use /mcp list or /mcp reconnect <name>.`;
+                return `Unknown /mcp subcommand "${sub}". Use /mcp list, /mcp tools <name>, or /mcp reconnect <name>.`;
             }
             const states = ctx.mcpManager.getStates();
             if (states.length === 0) {
                 return "No MCP servers configured. Add entries under `mcpServers` in ~/.bubble/settings.json or <cwd>/.bubble/settings.json.";
             }
+            // Rendered as markdown in the TUI: each server is its own paragraph,
+            // failures are bold + uppercase so they stand apart from healthy rows,
+            // and tool lists stay collapsed behind /mcp tools <name>.
             const lines = ["MCP servers:"];
             for (const state of states) {
-                const transport = state.config.type;
-                const scope = state.scope;
+                const meta = `${state.scope}/${state.config.type}`;
+                lines.push("");
                 if (state.status.kind === "connected") {
-                    const info = state.status.serverInfo ? ` ${state.status.serverInfo.name}@${state.status.serverInfo.version}` : "";
+                    const info = state.status.serverInfo ? ` · ${state.status.serverInfo.name}@${state.status.serverInfo.version}` : "";
                     const tn = state.status.tools.length;
                     const pn = state.status.prompts.length;
                     const counts = [`${tn} tool${tn === 1 ? "" : "s"}`];
                     if (pn > 0)
                         counts.push(`${pn} prompt${pn === 1 ? "" : "s"}`);
-                    lines.push(`  ✔ ${state.name} [${scope}/${transport}]${info} — ${counts.join(", ")}`);
-                    for (const tool of state.status.tools) {
-                        lines.push(`      · ${tool.name}${tool.description ? ` — ${tool.description.replace(/\s+/g, " ").slice(0, 80)}` : ""}`);
-                    }
+                    lines.push(`✔ ${state.name} — connected · ${counts.join(" · ")} (${meta}${info})`);
                     if (pn > 0) {
-                        lines.push(`    prompts (invoke as /<name>):`);
-                        for (const p of state.status.prompts) {
-                            const argSig = p.arguments?.length
-                                ? ` <${p.arguments.map((a) => (a.required ? a.name : `${a.name}?`)).join("> <")}>`
-                                : "";
-                            const cmdName = normalizeNameForMCP(p.name);
-                            lines.push(`      · /${cmdName}${argSig}${p.description ? ` — ${p.description.replace(/\s+/g, " ").slice(0, 70)}` : ""}`);
-                        }
+                        const prompts = state.status.prompts.map((p) => `/${normalizeNameForMCP(p.name)}`);
+                        lines.push(`    prompts: ${prompts.join(", ")}`);
                     }
                 }
                 else if (state.status.kind === "failed") {
-                    lines.push(`  ✘ ${state.name} [${scope}/${transport}] — ${state.status.error}`);
+                    lines.push(`**✘ ${state.name} — UNABLE TO CONNECT** (${meta})`);
+                    lines.push(`    ${state.status.error.replace(/\s+/g, " ").slice(0, 200)}`);
+                    lines.push(`    retry: /mcp reconnect ${state.name}`);
                 }
                 else {
-                    lines.push(`  ○ ${state.name} [${scope}/${transport}] — disabled`);
+                    lines.push(`○ ${state.name} — disabled (${meta})`);
                 }
             }
+            lines.push("");
+            lines.push("Details: /mcp tools <name> · /mcp reconnect <name>");
             return lines.join("\n");
         },
     },

package/dist/tools/exit-plan-mode.js

@@ -11,6 +11,14 @@ export function createExitPlanModeTool(controller) {
         readOnly: true,
         effect: "read",
         requiresApproval: true,
+        // Outside plan mode the tool is not just useless, it is bait: models call
+        // it to "wrap up" an ordinary turn despite the description below saying
+        // not to (same failure seen with update_goal — wording loses to the
+        // trained close-out prior). Gating it out of the provider's function list
+        // removes the affordance; the predicate re-runs every model call, so
+        // entering plan mode surfaces it immediately. The runtime no-op in
+        // agent.ts stays as a backstop for a mode flip mid-turn.
+        enabled: () => controller.getMode() === "plan",
         description: "ONLY call this tool when the harness has told you via a runtime reminder that plan mode is ACTIVE. " +
             "Do NOT call it during ordinary work — in default mode you should just use the regular tools directly. " +
             "In plan mode: after investigating, call this with a concrete step-by-step plan so the user can approve, edit, or reject. " +

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

@@ -1,3 +1,4 @@
 export type ResolvedTheme = "light" | "dark";
 export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;
+export declare function parseColorFgBg(value: string | undefined): ResolvedTheme | null;
 export declare function themeFromMacOsAppearance(output: string | null | undefined): ResolvedTheme;

package/dist/tui/detect-theme.js

@@ -1,19 +1,25 @@
 import { execFileSync } from "node:child_process";
-export async function detectTerminalTheme(timeoutMs = 150) {
-    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
-    if (fromEnv)
-        return fromEnv;
+export async function detectTerminalTheme(timeoutMs = 300) {
+    // OSC 11 asks the terminal for its actual background color right now — the
+    // only signal that tracks a theme switched after the shell started. The
+    // launch-time signals below are tie-breakers for terminals that don't
+    // answer: COLORFGBG is frozen at shell startup (and propagated stale by
+    // tmux/ssh), and the OS appearance describes the system, not the terminal
+    // profile. Ordering OSC 11 first is what keeps "auto" matching reality.
     if (process.stdout.isTTY && process.stdin.isTTY) {
         const fromOsc = await queryOsc11(timeoutMs);
         if (fromOsc)
             return fromOsc;
     }
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
     const fromOs = detectOsAppearanceTheme();
     if (fromOs)
         return fromOs;
     return "dark";
 }
-function parseColorFgBg(value) {
+export function parseColorFgBg(value) {
     if (!value)
         return null;
     const parts = value.split(";");

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

@@ -15,6 +15,7 @@ import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ExternalHookController } from "../hooks/controller.js";
 import type { GoalStore } from "../goal/store.js";
+import { isInternalBlockOnlyContent } from "../agent/internal-reminder-sanitizer.js";
 import type { ProcessManager } from "../tasks/manager.js";
 import type { PromotionChannel } from "../tasks/promotion.js";
 import type { ExternalRuntimeManager } from "../external-runtime/types.js";
@@ -70,11 +71,7 @@ export interface ExitSummary {
     /** Wall-clock duration of the session, in milliseconds. */
     wallMs: number;
 }
-/**
- * True when a user message is nothing but harness-injected internal blocks
- * (goal kicks, task wakes) — hidden live, so hidden on reconstruction too.
- */
-export declare function isInternalBlockOnlyContent(content: Message["content"]): boolean;
+export { isInternalBlockOnlyContent };
 export declare function reconstructDisplayMessages(agentMessages: Message[]): DisplayMessage[];
 export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
     readonly name: "goal";
@@ -84,4 +81,3 @@ export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
     readonly description: "Run a prompt on a recurring interval (/loop 5m <prompt>|list|stop [id])";
 }];
 export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, processManager, tasksAutoResume, promotionChannel, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
-export {};

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/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;