@bubblebrain-ai/bubble 0.0.25 → 0.0.26

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

@@ -16,7 +16,6 @@ import { createPastedContentMarker, expandPastedContentMarkers, shouldCollapsePa
 import { imageDisplayLabel } from "../tui/image-display.js";
 const MIN_VISIBLE_LINES = 3;
 const MAX_VISIBLE_LINES = 6;
-const CURSOR_BLINK_INTERVAL_MS = 530;
 const PADDING_X = 1;
 const PROMPT = " > ";
 const MAX_VISIBLE_SUGGESTIONS = 8;
@@ -44,6 +43,9 @@ export function isCtrlCInput(input, key) {
 export function shouldUseLineComposerFrame(_background) {
     return true;
 }
+export function composerSurfaceBackground(lineFrame, background, inputBg) {
+    return lineFrame ? background : inputBg;
+}
 export function shouldUseHardwareComposerCursor(env = process.env) {
     return env.BUBBLE_HARDWARE_CURSOR === "1";
 }
@@ -903,23 +905,24 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, cursorRes
     const displayText = imageInlinePrefix + text;
     const displayCursor = cursor + imageInlinePrefix.length;
     const displayCursorToSourceCursor = (value) => Math.max(0, Math.min(text.length, value - imageInlinePrefix.length));
+    // Steady (non-blinking) cursor on purpose. The composer lives in the live
+    // (repainting) region; a blink timer would rewrite these rows ~twice a second
+    // even at idle, and the terminal drops any in-progress text selection every
+    // time the underlying cells are rewritten — which is why composer text could
+    // not be highlighted/copied while agent answers (committed to <Static>, never
+    // repainted) could. Keeping the cursor steady leaves the idle composer frame
+    // static, so native selection works. We still hide it while disabled.
     useEffect(() => {
-        if (disabled) {
-            setSoftwareCursorVisible(false);
-            return;
-        }
-        setSoftwareCursorVisible(true);
-        const timer = setInterval(() => {
-            setSoftwareCursorVisible((visible) => !visible);
-        }, CURSOR_BLINK_INTERVAL_MS);
-        return () => clearInterval(timer);
-    }, [disabled, displayCursor, displayText]);
+        setSoftwareCursorVisible(!disabled);
+    }, [disabled]);
     const visualLines = useMemo(() => computeVisualLines(displayText, lineWidth), [displayText, lineWidth]);
     const { row: cursorVisualRow, col: cursorVisualCol } = cursorToVisual(visualLines, displayCursor);
-    // ---- Wheel-vs-keyboard classification for Up/Down arrows ----
+    // ---- Up/Down arrow handling in the composer ----
     //
-    // Up/Down reaching the composer are keyboard navigation: move within
-    // multiline input first, then browse prompt history at the top/bottom edge.
+    // Scrolling is the terminal's job now (native scrollback), so the composer
+    // owns Up/Down unconditionally: move within multiline input first, then
+    // browse prompt history at the top edge (Up → previous sent message) or the
+    // bottom edge (Down → next message, then back to the in-progress draft).
     const performVerticalArrowRef = useRef(() => { });
     performVerticalArrowRef.current = (direction) => {
         if (direction === "up") {
@@ -1086,6 +1089,7 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, cursorRes
     // Reference cursorTick so the effect re-runs on the forced render pass.
     void cursorTick;
     const inputBg = disabled ? theme.inputBgDisabled : theme.inputBg;
+    const composerBg = composerSurfaceBackground(lineFrame, theme.background, inputBg);
     const rowBg = lineFrame ? undefined : inputBg;
     const cursorFg = lineFrame ? theme.background : inputBg;
     const cursorCellStyle = resolveSoftwareCursorCellStyle({
@@ -1100,7 +1104,7 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, cursorRes
         const visibleWidth = stringWidth(value);
         return value + " ".repeat(Math.max(0, contentWidth - visibleWidth));
     };
-    return (_jsxs(Box, { flexDirection: "column", width: width, backgroundColor: theme.background, children: [lineFrame && (_jsx(Box, { paddingX: PADDING_X, children: _jsx(Text, { color: theme.border, children: "─".repeat(contentWidth) }) })), _jsxs(Box, { flexDirection: "column", paddingX: PADDING_X, width: width, backgroundColor: inputBg, children: [hasMoreAbove && (_jsx(Text, { backgroundColor: rowBg, color: theme.muted, dimColor: true, children: filledLine(` ↑ ${scrollOffset} more`) })), displayedLines.map((row) => {
+    return (_jsxs(Box, { flexDirection: "column", width: width, backgroundColor: theme.background, children: [lineFrame && (_jsx(Box, { paddingX: PADDING_X, children: _jsx(Text, { color: theme.border, children: "─".repeat(contentWidth) }) })), _jsxs(Box, { flexDirection: "column", paddingX: PADDING_X, width: width, backgroundColor: composerBg, children: [hasMoreAbove && (_jsx(Text, { backgroundColor: rowBg, color: theme.muted, dimColor: true, children: filledLine(` ↑ ${scrollOffset} more`) })), displayedLines.map((row) => {
                         if (row.kind === "pad") {
                             return (_jsx(Text, { backgroundColor: rowBg, children: " ".repeat(contentWidth) }, row.key));
                         }
@@ -1121,7 +1125,7 @@ export function InputBox({ onSubmit, onQueue, onPasteNotice, disabled, cursorRes
                         });
                         const renderedLine = renderedSegments.map((segment) => segment.text).join("");
                         const fill = " ".repeat(Math.max(0, lineWidth - stringWidth(renderedLine)));
-                        return (_jsxs(Box, { height: 1, overflow: "hidden", backgroundColor: inputBg, ref: isCursorLine
+                        return (_jsxs(Box, { height: 1, overflow: "hidden", backgroundColor: composerBg, ref: isCursorLine
                                 ? (el) => {
                                     cursorLineRef.current = el;
                                 }

package/dist/tui-ink/message-list.d.ts

@@ -25,6 +25,22 @@ interface MessageListProps {
     nowTick?: number;
     /** Optional banner rendered as the first item in the app-controlled transcript. */
     welcomeBanner?: React.ReactNode;
+    /**
+     * Bumped whenever the settled transcript is rebuilt non-monotonically
+     * (/clear, /compact, /rewind, session switch). Used as the <Static> key so
+     * Ink discards its already-printed rows and re-prints the rebuilt list onto
+     * a freshly-cleared screen instead of appending duplicates.
+     */
+    staticGeneration?: number;
+    /** Horizontal padding applied inside each committed/streaming row. */
+    paddingX?: number;
+    /**
+     * Maximum height (rows) for the live/dynamic region. The in-progress turn is
+     * clipped to this and pinned to the bottom (tail view) so the live frame
+     * never exceeds the viewport — a taller-than-pane frame breaks Ink's redraw
+     * under tmux. The full turn still lands in <Static> scrollback on commit.
+     */
+    maxStreamRows?: number;
 }
-export declare function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking, expandedToolOutput, verboseTrace, pendingApproval, nowTick, welcomeBanner, }: MessageListProps): import("react/jsx-runtime").JSX.Element;
+export declare function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking, expandedToolOutput, verboseTrace, pendingApproval, nowTick, welcomeBanner, staticGeneration, paddingX, maxStreamRows, }: MessageListProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import React from "react";
-import { Box, Text } from "ink";
+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";
@@ -11,7 +11,7 @@ import { formatSubagentRoute } from "../agent/subagent-route-format.js";
 import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
 import { splitImageDisplayContent } from "../tui/image-display.js";
 const EXECUTE_COMMAND_BLOCK_MAX_LINES = 4;
-export function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking = false, expandedToolOutput = false, verboseTrace, pendingApproval, nowTick, welcomeBanner, }) {
+export function MessageList({ messages, streamingContent, streamingReasoning, streamingTools, streamingParts, terminalColumns, showThinking = false, expandedToolOutput = false, verboseTrace, pendingApproval, nowTick, welcomeBanner, staticGeneration = 0, paddingX = 1, maxStreamRows, }) {
     const theme = useTheme();
     const hasStreaming = !!(streamingContent ||
         streamingReasoning ||
@@ -35,12 +35,63 @@ export function MessageList({ messages, streamingContent, streamingReasoning, st
             separateFromPrevious: msg.role === "user" && regularMessages[i - 1]?.role === "user",
         });
     }
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [staticItems.map((item) => {
-                if (item.kind === "welcome") {
-                    return _jsx(React.Fragment, { children: welcomeBanner }, item.key);
-                }
-                return (_jsx(MessageItem, { message: item.message, terminalColumns: terminalColumns, showThinking: showThinking, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, showExpandHint: item.showExpandHint, separateFromPrevious: item.separateFromPrevious, nowTick: item.showExpandHint ? nowTick : undefined }, item.key));
-            }), hasStreaming && (_jsx(StreamingMessage, { content: streamingContent, reasoning: streamingReasoning, tools: streamingTools, parts: streamingParts, terminalColumns: terminalColumns, showThinking: showThinking, expandedToolOutput: expandedToolOutput, 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 }))] }));
+    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, children: welcomeBanner }, item.key));
+                    }
+                    return (_jsx(Box, { flexDirection: "column", paddingX: paddingX, children: _jsx(MessageItem, { message: item.message, terminalColumns: terminalColumns, showThinking: showThinking, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, showExpandHint: item.showExpandHint, separateFromPrevious: item.separateFromPrevious }) }, item.key));
+                } }, `transcript-${staticGeneration}`), hasDynamic && (_jsxs(DynamicClamp, { maxRows: clampDynamic ? maxStreamRows : undefined, paddingX: paddingX, children: [hasStreaming && (_jsx(StreamingMessage, { content: streamingContent, reasoning: streamingReasoning, tools: streamingTools, parts: streamingParts, terminalColumns: terminalColumns, showThinking: showThinking, expandedToolOutput: expandedToolOutput, 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, 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, ...(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
@@ -62,13 +113,16 @@ const MessageItem = React.memo(function MessageItem({ message, terminalColumns,
         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" })] }));
     }
     const visibleReasoning = sanitizeInternalReminderBlocks(message.reasoning ?? "").trim();
-    const hasVisibleAssistantContent = !!message.content ||
+    // 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 ?? "");
+    const hasVisibleAssistantContent = !!visibleContent.trim() ||
         (message.toolCalls?.length ?? 0) > 0 ||
         (message.parts?.length ?? 0) > 0 ||
         (!!visibleReasoning && (showThinking || verboseTrace));
     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, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), message.content && _jsx(MarkdownContent, { content: message.content })] })), verboseTrace && message.toolCalls && message.toolCalls.length > 0 && (_jsx(TurnDigest, { toolCalls: message.toolCalls })), message.taskElapsedMs !== undefined && (_jsx(TaskDurationLine, { elapsedMs: message.taskElapsedMs }))] }));
+    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, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), visibleContent.trim() && _jsx(MarkdownContent, { content: visibleContent })] })), 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, expandedToolOutput, verboseTrace, pendingApproval, nowTick, }) {
     const deferredContent = React.useDeferredValue(content);
@@ -105,13 +159,19 @@ function findLastTextPartIndex(parts) {
 }
 function TimelineText({ content, compactTop, terminalColumns, streaming = false, }) {
     const theme = useTheme();
-    if (!content.trim())
+    // 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;
     // marginLeft (2) + "●  " marker (3 visual cells) = 5 cells consumed by the
     // timeline gutter; pass the remaining width so wide blocks like tables size
     // themselves against the actual content area instead of the raw terminal.
     const available = terminalColumns ? Math.max(20, terminalColumns - 5) : undefined;
-    const trimmed = content.trim();
+    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 })) : (_jsx(MarkdownContent, { content: trimmed, maxWidth: available })) })] }));
 }
 function ToolsPart({ toolCalls, terminalColumns, expandedToolOutput, verboseTrace, pendingApproval, showExpandHint, compactTop = false, nowTick, showActivity = false, }) {
@@ -254,7 +314,8 @@ function UserMessageBlock({ content, terminalColumns, inputStatus, separateFromP
     const { bodyLines, referenceLines } = splitImageDisplayContent(content);
     const wrappedLines = bodyLines
         .flatMap((line) => wrapByVisualWidth(line, bubbleTextWidth));
-    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: index === 0 ? "▌ " : "  " }), _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: `  ${line}` }) }, `attachment-${index}`)))] }));
+    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}`)))] }));
 }
 function PendingInputMessagesBlock({ messages, terminalColumns, title, hint, bulletColor, }) {
     const theme = useTheme();

package/dist/tui-ink/model-picker.d.ts

@@ -31,8 +31,8 @@ export declare function modelPickerBodyRows(termHeight: number): number;
 export declare function clampPickerIndex(index: number, length: number): number;
 export declare function pickerWindowStart(selectedIndex: number, length: number, visibleRows: number): number;
 export declare function padPickerRows(rows: string[], bodyRows: number, width: number): string[];
-export declare function formatReasoningLevelsLabel(levels: readonly ThinkingLevel[]): string;
-export declare function formatModelPickerRow(option: Pick<ModelPickerOption, "label" | "providerBadge" | "reasoningLevels">, options: {
+export declare function formatReasoningLevelsLabel(levels: readonly ThinkingLevel[], asToggle?: boolean): string;
+export declare function formatModelPickerRow(option: Pick<ModelPickerOption, "id" | "label" | "providerBadge" | "reasoningLevels">, options: {
     selected: boolean;
     current: boolean;
     width: number;
@@ -40,6 +40,7 @@ export declare function formatModelPickerRow(option: Pick<ModelPickerOption, "la
 export declare function formatEffortPickerRow(level: ThinkingLevel, options: {
     selected: boolean;
     width: number;
+    asToggle?: boolean;
 }): string;
 export declare function formatNoModelResultsRow(query: string, width: number): string;
 export declare function preferredEffortIndex(option: Pick<ModelPickerOption, "reasoningLevels">, currentThinkingLevel: ThinkingLevel): number;

package/dist/tui-ink/model-picker.js

@@ -78,8 +78,17 @@ export function padPickerRows(rows, bodyRows, width) {
     }
     return padded;
 }
-export function formatReasoningLevelsLabel(levels) {
+// MiniMax models expose thinking as a binary on/off switch (the API's `thinking`
+// param is disabled|adaptive — there's no graded effort), so render the "on"
+// level as on/off instead of our internal "medium". Scoped to MiniMax only —
+// other 2-level models (e.g. GLM toggles) keep their effort labels.
+function isMiniMaxToggleModel(modelId) {
+    return modelId.toLowerCase().includes("minimax");
+}
+export function formatReasoningLevelsLabel(levels, asToggle = false) {
     const normalized = levels.length > 0 ? levels : ["off"];
+    if (asToggle)
+        return "thinking on/off";
     return `effort ${normalized.join("/")}`;
 }
 export function formatModelPickerRow(option, options) {
@@ -87,7 +96,7 @@ export function formatModelPickerRow(option, options) {
     const marker = options.selected ? "> " : "  ";
     const label = option.label.replace(/\s+/g, " ").trim();
     const provider = option.providerBadge.replace(/\s+/g, " ").trim();
-    const effort = formatReasoningLevelsLabel(option.reasoningLevels);
+    const effort = formatReasoningLevelsLabel(option.reasoningLevels, isMiniMaxToggleModel(option.id));
     const current = options.current ? " ●" : "";
     const providerWidth = Math.max(6, Math.min(16, Math.floor(width * 0.18)));
     const effortWidth = Math.max(12, Math.min(30, Math.floor(width * 0.32)));
@@ -106,7 +115,8 @@ export function formatModelPickerRow(option, options) {
 export function formatEffortPickerRow(level, options) {
     const width = Math.max(24, options.width);
     const marker = options.selected ? "> " : "  ";
-    const row = `${marker}${level}  ${effortDescription(level)}`;
+    const name = options.asToggle ? (level === "off" ? "off" : "on") : level;
+    const row = `${marker}${name}  ${effortDescription(level, options.asToggle)}`;
     return padVisual(truncateVisual(row, width), width);
 }
 export function formatNoModelResultsRow(query, width) {
@@ -125,7 +135,9 @@ export function preferredEffortIndex(option, currentThinkingLevel) {
 export function shouldOpenEffortPicker(option) {
     return option.reasoningLevels.length > 1;
 }
-function effortDescription(level) {
+function effortDescription(level, asToggle) {
+    if (asToggle)
+        return level === "off" ? "thinking disabled" : "thinking enabled";
     switch (level) {
         case "off":
             return "no reasoning effort";
@@ -343,6 +355,7 @@ function EffortPickerView({ model, selectedIndex, bodyRows, rowWidth, }) {
         row: formatEffortPickerRow(level, {
             selected: index === safeSelectedIndex,
             width: rowWidth,
+            asToggle: isMiniMaxToggleModel(model.id),
         }),
         selected: index === safeSelectedIndex,
     }));

package/dist/tui-ink/question-dialog.js

@@ -15,17 +15,27 @@ export function QuestionDialog({ request, onSubmit, onCancel }) {
     const canUseCustom = question?.custom !== false;
     const isMultiple = question?.multiple === true;
     const totalTabs = request.questions.length;
+    // The "Custom: type to answer" row is the last navigable item (when custom is
+    // allowed), so Up/Down can reach and highlight it just like an option.
+    const customIndex = canUseCustom ? options.length : -1;
+    const navCount = options.length + (canUseCustom ? 1 : 0);
+    const isCustomSelected = canUseCustom && selected === customIndex;
     const currentAnswer = useMemo(() => answers[index] ?? [], [answers, index]);
     const commitQuestion = () => {
-        const option = options[selected]?.label;
         const customAnswer = custom.trim();
-        const nextAnswer = customAnswer
-            ? [customAnswer]
+        // Submit what is actually selected: the Custom row submits the typed text;
+        // an option row submits that option (a stale custom buffer no longer wins).
+        const nextAnswer = isCustomSelected
+            ? customAnswer
+                ? [customAnswer]
+                : []
             : isMultiple
                 ? currentAnswer
-                : option
-                    ? [option]
-                    : [];
+                : options[selected]?.label
+                    ? [options[selected].label]
+                    : customAnswer
+                        ? [customAnswer]
+                        : [];
         const nextAnswers = answers.map((answer, i) => i === index ? nextAnswer : answer);
         if (index < request.questions.length - 1) {
             setAnswers(nextAnswers);
@@ -82,11 +92,24 @@ export function QuestionDialog({ request, onSubmit, onCancel }) {
             return;
         }
         if (key.downArrow) {
-            setSelected((i) => Math.min(Math.max(0, options.length - 1), i + 1));
+            setSelected((i) => Math.min(Math.max(0, navCount - 1), i + 1));
+            return;
+        }
+        // Tab toggles a checkbox; only meaningful while an option row is selected.
+        if (key.tab) {
+            if (!isCustomSelected)
+                toggleCurrentOption();
             return;
         }
-        if (key.tab || input === " ") {
-            toggleCurrentOption();
+        if (input === " ") {
+            // Space toggles the highlighted option, but on the Custom row it types a
+            // literal space into the answer instead of swallowing the keystroke.
+            if (isCustomSelected) {
+                setCustom((value) => value + " ");
+            }
+            else {
+                toggleCurrentOption();
+            }
             return;
         }
         if (key.return) {
@@ -97,7 +120,10 @@ export function QuestionDialog({ request, onSubmit, onCancel }) {
             setCustom((value) => value.slice(0, -1));
             return;
         }
+        // Any printable key starts/continues the custom answer and moves the
+        // highlight onto the Custom row, so typing and arrow navigation agree.
         if (canUseCustom && input && !key.ctrl && !key.meta) {
+            setSelected(customIndex);
             setCustom((value) => value + input);
         }
     });
@@ -105,5 +131,5 @@ export function QuestionDialog({ request, onSubmit, onCancel }) {
                     const isSelected = optionIndex === selected;
                     const isChecked = currentAnswer.includes(option.label);
                     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: isSelected ? theme.accent : undefined, children: [isSelected ? "> " : "  ", isMultiple ? `[${isChecked ? "x" : " "}] ` : "", option.label] }), option.description && (_jsx(Box, { marginLeft: 4, children: _jsx(Text, { color: theme.muted, dimColor: true, children: option.description }) }))] }, `${option.label}-${optionIndex}`));
-                }) }), canUseCustom && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: custom ? undefined : theme.muted, children: ["Custom: ", custom || "type to answer..."] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "\u2191\u2193 choose \u00B7 Tab/Space toggle \u00B7 Enter submit \u00B7 Esc dismiss" }) })] }));
+                }) }), canUseCustom && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: isCustomSelected ? theme.accent : custom ? undefined : theme.muted, children: [isCustomSelected ? "> " : "  ", "Custom: ", custom || "type to answer…"] }) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["\u2191\u2193 choose \u00B7 ", isMultiple ? "Space toggle · " : "", "type for Custom \u00B7 Enter submit \u00B7 Esc dismiss"] }) })] }));
 }

package/dist/tui-ink/run.js

@@ -1,23 +1,23 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
 import { App } from "./app.js";
-import { ALTERNATE_SCROLL_DISABLE, MOUSE_REPORTING_DISABLE, MOUSE_REPORTING_ENABLE, } from "./terminal-mouse.js";
 import { warmHighlighter } from "./code-highlight.js";
 export function createInkAppElement(agent, args, options, onExit) {
     return (_jsx(App, { agent: agent, args: args, sessionManager: options.sessionManager, switchSession: options.switchSession, createProvider: options.createProvider, registry: options.registry, skillRegistry: options.skillRegistry, planHandlerRef: options.planHandlerRef, approvalHandlerRef: options.approvalHandlerRef, questionController: options.questionController, bashAllowlist: options.bashAllowlist, settingsManager: options.settingsManager, lspService: options.lspService, mcpManager: options.mcpManager, goalStore: options.goalStore, themeMode: options.themeMode, themeOverrides: options.themeOverrides, detectedTheme: options.detectedTheme, onThemeModeChange: options.onThemeModeChange, flushMemory: options.flushMemory, runMemoryCompaction: options.runMemoryCompaction, runMemorySummary: options.runMemorySummary, runMemoryRefresh: options.runMemoryRefresh, bypassEnabled: options.bypassEnabled, updateNotice: options.updateNotice, updateNoticeRefresh: options.updateNoticeRefresh, hookController: options.hookController, onExit: onExit }));
 }
 /**
- * Best-effort terminal restore for abnormal exits. DECSET mouse modes are
- * global terminal state — if the process dies without disabling them, the
- * user's shell receives \x1b[<35;… garbage on every mouse move. The alt-screen
- * and cursor writes are defensive duplicates of Ink's own teardown (idempotent
- * when Ink already ran; load-bearing when it didn't).
+ * 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).
  */
 function restoreTerminal() {
     if (!process.stdout.isTTY)
         return;
     try {
-        process.stdout.write(ALTERNATE_SCROLL_DISABLE + MOUSE_REPORTING_DISABLE + "\x1b[?1049l\x1b[?25h");
+        process.stdout.write("\x1b[?25h");
     }
     catch {
         // stdout may already be destroyed during shutdown
@@ -65,26 +65,18 @@ export async function runTui(agent, args, options = {}) {
             // reportEventTypes keeps release events out of text input.
             flags: ["disambiguateEscapeCodes", "reportEventTypes"],
         },
-        // The whole point of the Ink migration: render into the 1049 alternate
-        // screen so streaming repaints never touch the user's shell scrollback.
-        // Ink degrades this to false automatically when stdout is not a TTY.
-        alternateScreen: true,
+        // Render into the primary screen (NOT the 1049 alternate screen): settled
+        // transcript rows are committed once via Ink's <Static> region so they
+        // flow into the terminal's native scrollback. That gives flicker-free
+        // native scroll + text selection + copy (and tmux copy-mode) for free,
+        // 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,
     });
-    // Keep alternate-scroll disabled so wheel events do not alias keyboard
-    // arrows. Enable SGR mouse reporting after alt-screen entry so wheel events
-    // scroll the transcript through a distinct input channel.
-    if (process.stdout.isTTY) {
-        process.stdout.write(ALTERNATE_SCROLL_DISABLE + MOUSE_REPORTING_ENABLE);
-    }
     try {
         await instance.waitUntilExit();
     }
     finally {
-        // Reset mouse reporting before anything is printed to the primary screen;
-        // Ink has already left the alt screen by the time waitUntilExit() resolves.
-        if (process.stdout.isTTY) {
-            process.stdout.write(ALTERNATE_SCROLL_DISABLE + MOUSE_REPORTING_DISABLE);
-        }
         process.off("uncaughtException", onFatalError);
         process.off("SIGTERM", onSigterm);
     }

package/dist/tui-ink/terminal-mouse.d.ts

@@ -2,6 +2,16 @@ export declare const ALTERNATE_SCROLL_ENABLE = "\u001B[?1007h";
 export declare const ALTERNATE_SCROLL_DISABLE = "\u001B[?1007l";
 export declare const MOUSE_REPORTING_ENABLE = "\u001B[?1000h\u001B[?1006h";
 export declare const MOUSE_REPORTING_DISABLE = "\u001B[?1003l\u001B[?1002l\u001B[?1000l\u001B[?1005l\u001B[?1006l\u001B[?1015l";
+interface TerminalMouseEnv {
+    BUBBLE_ENABLE_MOUSE?: string;
+    BUBBLE_TUI_MOUSE?: string;
+}
+/**
+ * Terminal mouse reporting captures drag events before the host terminal can
+ * create a native text selection. Keep it opt-in until Bubble owns a full
+ * renderer-level selection/copy pipeline.
+ */
+export declare function isTerminalMouseReportingEnabled(env?: TerminalMouseEnv): boolean;
 export type MouseWheelDirection = "up" | "down";
 export interface TerminalMouseInput {
     strippedInput: string;
@@ -15,3 +25,4 @@ export declare function transcriptScrollLinesFromMouseInput(mouseInput: Terminal
 export declare function stripTerminalMouseSequences(input: string): string;
 export declare function hasTerminalMouseSequence(input: string): boolean;
 export declare function parseTerminalMouseWheel(input: string): MouseWheelDirection[];
+export {};

package/dist/tui-ink/terminal-mouse.js

@@ -10,6 +10,19 @@ export const MOUSE_REPORTING_ENABLE = "\x1b[?1000h\x1b[?1006h";
 // Disable every common tracking mode defensively in case a crash or another
 // renderer left the terminal in a reporting state.
 export const MOUSE_REPORTING_DISABLE = "\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1005l\x1b[?1006l\x1b[?1015l";
+function envValueEnabled(value) {
+    if (!value)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+/**
+ * Terminal mouse reporting captures drag events before the host terminal can
+ * create a native text selection. Keep it opt-in until Bubble owns a full
+ * renderer-level selection/copy pipeline.
+ */
+export function isTerminalMouseReportingEnabled(env = process.env) {
+    return envValueEnabled(env.BUBBLE_ENABLE_MOUSE) || envValueEnabled(env.BUBBLE_TUI_MOUSE);
+}
 const ESCAPED_MOUSE_SEQUENCE_RE = /\x1b(?:\[<(\d+);\d+;\d+([mM])|\[M([\s\S])[\s\S]{2})/g;
 const RAW_SGR_MOUSE_SEQUENCE_RE = /\[?<(\d+);\d+;\d+([mM])/g;
 const RAW_SGR_MOUSE_INPUT_RE = /^(?:\[?<\d+;\d+;\d+[mM])+$/;

package/dist/tui-ink/welcome.js

@@ -31,12 +31,22 @@ export function WelcomeBanner({ terminalColumns, tips, updateNotice, cwd, provid
 }
 export function formatModelLine({ providerId, modelLabel, thinkingLabel, tips, }) {
     const parts = [];
-    if (modelLabel)
-        parts.push(thinkingLabel ? `${modelLabel} with ${thinkingLabel} effort` : modelLabel);
+    // MiniMax thinking is a binary toggle (adaptive thinking), so label it
+    // "thinking mode" rather than "<level> effort"; and its provider id
+    // ("minimax-anthropic") is redundant with the model name, so omit it.
+    const isMiniMax = (providerId || "").toLowerCase().includes("minimax");
+    if (modelLabel) {
+        if (thinkingLabel && isMiniMax)
+            parts.push(modelLabel, "thinking mode");
+        else if (thinkingLabel)
+            parts.push(`${modelLabel} with ${thinkingLabel} effort`);
+        else
+            parts.push(modelLabel);
+    }
     const readyTip = tips.find((item) => item.startsWith("Ready with"));
     if (!modelLabel && readyTip)
         parts.push(readyTip.replace(/^Ready with\s+/, ""));
-    if (providerId)
+    if (providerId && !isMiniMax)
         parts.push(providerId);
     return parts.join(" · ");
 }

package/dist/variant/variant-resolver.js

@@ -1,10 +1,13 @@
-import { getBuiltinModel } from "../model-catalog.js";
+import { getBuiltinModel, getModelDefaultReasoningLevel } from "../model-catalog.js";
 import { clampThinkingLevel } from "./thinking-level.js";
 export function getAvailableThinkingLevels(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
 }
 export function getDefaultThinkingLevel(providerId, modelId) {
     const levels = getAvailableThinkingLevels(providerId, modelId);
+    const explicitDefault = getModelDefaultReasoningLevel(providerId, modelId);
+    if (explicitDefault && levels.includes(explicitDefault))
+        return explicitDefault;
     return levels.includes("medium") ? "medium" : levels[0] || "off";
 }
 export function normalizeThinkingLevel(level, supportedLevels) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {

package/dist/tui/transcript-scroll.d.ts

@@ -1,25 +0,0 @@
-/**
- * Transcript scroll-follow policy.
- *
- * The transcript snaps to the bottom ("follows") while the user is at the
- * bottom, and stays put while they read older history. Two events override a
- * scrolled-up position and re-engage following:
- *   - the user sends a message (explicit intent to watch the newest turn)
- *   - an approval prompt appears (requires the user's attention)
- *
- * Those renders set `forcePending`, which must survive until the deferred
- * scroll actually runs: streaming redraws in the interim recompute the follow
- * flag from the (still unscrolled) position and would otherwise cancel the
- * snap. A user mouse scroll clears the pending force — their latest gesture
- * always wins.
- */
-export interface TranscriptScrollState {
-    /** A forceFollow render is waiting for its deferred scroll to execute. */
-    forcePending: boolean;
-    /** The viewport was at the bottom when the update was scheduled. */
-    shouldFollow: boolean;
-    /** Live follow flag, recomputed from the viewport position on each render. */
-    following: boolean;
-}
-export type TranscriptScrollAction = "scroll-bottom" | "sync-position";
-export declare function resolveTranscriptScroll(state: TranscriptScrollState): TranscriptScrollAction;

package/dist/tui/transcript-scroll.js

@@ -1,20 +0,0 @@
-/**
- * Transcript scroll-follow policy.
- *
- * The transcript snaps to the bottom ("follows") while the user is at the
- * bottom, and stays put while they read older history. Two events override a
- * scrolled-up position and re-engage following:
- *   - the user sends a message (explicit intent to watch the newest turn)
- *   - an approval prompt appears (requires the user's attention)
- *
- * Those renders set `forcePending`, which must survive until the deferred
- * scroll actually runs: streaming redraws in the interim recompute the follow
- * flag from the (still unscrolled) position and would otherwise cancel the
- * snap. A user mouse scroll clears the pending force — their latest gesture
- * always wins.
- */
-export function resolveTranscriptScroll(state) {
-    if (state.forcePending)
-        return "scroll-bottom";
-    return state.shouldFollow && state.following ? "scroll-bottom" : "sync-position";
-}