@bubblebrain-ai/bubble 0.0.25 → 0.0.26

package/dist/provider.js

@@ -6,6 +6,7 @@
 import OpenAI from "openai";
 import { appendFileSync } from "node:fs";
 import { createAnthropicMessagesProvider } from "./provider-anthropic.js";
+import { createArkResponsesProvider } from "./provider-ark-responses.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
@@ -76,9 +77,13 @@ export function createUnavailableProvider(message) {
     return { streamChat, complete };
 }
 export function createProviderInstance(options) {
-    if (resolveProviderProtocol(options) === "anthropic-messages") {
+    const protocol = resolveProviderProtocol(options);
+    if (protocol === "anthropic-messages") {
         return createAnthropicMessagesProvider(options);
     }
+    if (protocol === "ark-responses") {
+        return createArkResponsesProvider(options);
+    }
     if (isOpenAICodexBaseUrl(options.baseURL)) {
         return createOpenAICodexProvider({
             ...options,
@@ -131,28 +136,39 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
+        const createCompletion = async (requestBody) => {
+            try {
+                return await client.chat.completions.create(requestBody, {
+                    signal: chatOptions.abortSignal,
+                    ...(chatOptions.rateLimitPolicy === "defer" ? { maxRetries: 0 } : {}),
+                });
+            }
+            catch (error) {
+                if (error?.status === 429) {
+                    const retryAfterHeader = error?.headers?.["retry-after"];
+                    const retryAfterSeconds = Number(retryAfterHeader);
+                    throw new RateLimitError(error?.message || "Rate limited (429)", {
+                        status: 429,
+                        retryAfterMs: Number.isFinite(retryAfterSeconds) ? Math.round(retryAfterSeconds * 1000) : undefined,
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+        };
+        if (shouldUseNonStreamingToolCalls(options, tools, chatOptions.toolChoice)) {
+            body.stream = false;
+            delete body.stream_options;
+            const response = await createCompletion(body);
+            yield* translateOpenAIFullResponse(response);
+            yield { type: "done" };
+            return;
+        }
         // Rate-limit contract (design §4.5): "defer" disables the SDK's own
         // retries so the caller is the single 429 backoff layer; either policy
         // surfaces a final 429 as a typed RateLimitError instead of a string.
         let stream;
-        try {
-            stream = (await client.chat.completions.create(body, {
-                signal: chatOptions.abortSignal,
-                ...(chatOptions.rateLimitPolicy === "defer" ? { maxRetries: 0 } : {}),
-            }));
-        }
-        catch (error) {
-            if (error?.status === 429) {
-                const retryAfterHeader = error?.headers?.["retry-after"];
-                const retryAfterSeconds = Number(retryAfterHeader);
-                throw new RateLimitError(error?.message || "Rate limited (429)", {
-                    status: 429,
-                    retryAfterMs: Number.isFinite(retryAfterSeconds) ? Math.round(retryAfterSeconds * 1000) : undefined,
-                    cause: error,
-                });
-            }
-            throw error;
-        }
+        stream = (await createCompletion(body));
         yield* translateOpenAIStream(stream, {
             toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
             reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),
@@ -194,6 +210,10 @@ function resolveProviderProtocol(options) {
         return options.protocol;
     const providerId = (options.providerId || "").toLowerCase();
     const baseURL = options.baseURL.toLowerCase();
+    if (providerId === "doubao"
+        && baseURL.replace(/\/+$/, "") === "https://ark.cn-beijing.volces.com/api/v3") {
+        return "ark-responses";
+    }
     if (providerId === "anthropic"
         || providerId.endsWith("-anthropic")
         || baseURL.includes("/anthropic")) {
@@ -221,6 +241,12 @@ function shouldRequestStreamUsage(options) {
         || providerId === "zai-coding-plan"
         || isMiniMaxOpenAICompatible(options);
 }
+function shouldUseNonStreamingToolCalls(options, tools, toolChoice) {
+    return (options.providerId || "").toLowerCase() === "doubao"
+        && !!tools
+        && tools.length > 0
+        && toolChoice !== "none";
+}
 export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
     if (!s) {
@@ -321,6 +347,101 @@ function extractBalancedJson(s, start) {
     }
     return null;
 }
+/**
+ * Convert a non-streaming OpenAI-compatible chat-completions response into the
+ * same chunk protocol used by the streaming adapter. This is used for provider
+ * tool-call paths where streamed function arguments are not reliable enough to
+ * execute safely.
+ */
+export async function* translateOpenAIFullResponse(response) {
+    const usageChunk = usageToStreamChunk(response?.usage);
+    if (usageChunk)
+        yield usageChunk;
+    const choice = response?.choices?.[0];
+    const finishReason = choice?.finish_reason;
+    const truncatedByLength = finishReason === "length";
+    const message = choice?.message;
+    if (!message)
+        return;
+    const reasoningDetails = extractReasoningDetailsText(message.reasoning_details);
+    const reasoning = reasoningDetails
+        ?? (typeof message.reasoning === "string" ? message.reasoning : undefined)
+        ?? (typeof message.thinking === "string" ? message.thinking : undefined)
+        ?? (typeof message.reasoning_content === "string" ? message.reasoning_content : undefined);
+    if (reasoning) {
+        yield { type: "reasoning_delta", content: reasoning };
+    }
+    if (typeof message.content === "string" && message.content) {
+        const textFilter = createProviderProtocolArtifactFilter();
+        const cleaned = textFilter.push(message.content) + textFilter.flush();
+        if (cleaned) {
+            yield { type: "text", content: cleaned };
+        }
+    }
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (let index = 0; index < toolCalls.length; index += 1) {
+        const toolCall = toolCalls[index];
+        const name = typeof toolCall?.function?.name === "string" ? toolCall.function.name : "";
+        if (!name)
+            continue;
+        const id = typeof toolCall?.id === "string" && toolCall.id
+            ? toolCall.id
+            : `call_${index}`;
+        const rawArgs = typeof toolCall?.function?.arguments === "string"
+            ? toolCall.function.arguments
+            : JSON.stringify(toolCall?.function?.arguments ?? {});
+        const normalized = normalizeToolArgsDetailed(rawArgs);
+        const corrupt = normalized.corrupt || truncatedByLength;
+        debugToolArgs({
+            stage: "full-response-tool-call",
+            id,
+            name,
+            entryArgs: rawArgs,
+            finalArgs: normalized.args,
+            finishReason,
+            corrupt,
+        });
+        yield { type: "tool_call", id, name, arguments: "", isStart: true, isEnd: false };
+        if (rawArgs) {
+            yield { type: "tool_call", id, name, arguments: rawArgs, isStart: false, isEnd: false };
+        }
+        yield {
+            type: "tool_call",
+            id,
+            name,
+            arguments: "",
+            argumentsFull: normalized.args,
+            argumentsCorrupt: corrupt || undefined,
+            isStart: false,
+            isEnd: true,
+        };
+    }
+}
+function usageToStreamChunk(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        type: "usage",
+        usage: {
+            promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+            completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+            promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number"
+                ? usage.prompt_cache_hit_tokens
+                : typeof usage.prompt_tokens_details?.cached_tokens === "number"
+                    ? usage.prompt_tokens_details.cached_tokens
+                    : undefined,
+            promptCacheMissTokens: typeof usage.prompt_cache_miss_tokens === "number"
+                ? usage.prompt_cache_miss_tokens
+                : typeof usage.prompt_tokens_details?.cached_tokens === "number" && typeof usage.prompt_tokens === "number"
+                    ? Math.max(0, usage.prompt_tokens - usage.prompt_tokens_details.cached_tokens)
+                    : undefined,
+            reasoningTokens: typeof usage.completion_tokens_details?.reasoning_tokens === "number"
+                ? usage.completion_tokens_details.reasoning_tokens
+                : undefined,
+            totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : undefined,
+        },
+    };
+}
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
@@ -359,14 +480,15 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 }
             }
             const normalized = normalizeToolArgsDetailed(entry.args);
-            debugToolArgs({ stage: "flush-end", id: entry.id, name: entry.name, entryArgs: entry.args, finalArgs: normalized.args, corrupt: normalized.corrupt });
+            const corrupt = normalized.corrupt || !!entry.corrupt;
+            debugToolArgs({ stage: "flush-end", id: entry.id, name: entry.name, entryArgs: entry.args, finalArgs: normalized.args, corrupt });
             yield {
                 type: "tool_call",
                 id: entry.id,
                 name: entry.name,
                 arguments: "",
                 argumentsFull: normalized.args,
-                argumentsCorrupt: normalized.corrupt || undefined,
+                argumentsCorrupt: corrupt || undefined,
                 isStart: false,
                 isEnd: true,
             };
@@ -526,7 +648,13 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 }
             }
         }
-        if (finishReason === "tool_calls") {
+        if (finishReason === "length") {
+            for (const entry of toolCalls.values()) {
+                entry.corrupt = true;
+            }
+            yield* flushToolCalls();
+        }
+        else if (finishReason === "tool_calls") {
             yield* flushToolCalls();
         }
     }

package/dist/slash-commands/commands.js

@@ -8,6 +8,7 @@ import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 import { SessionManager } from "../session.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { normalizeSingleLine } from "../text-display.js";
+import { copyToClipboard } from "../clipboard.js";
 import { formatRelativeTime } from "../tui/recent-activity.js";
 import { HOOK_EVENT_NAMES, isHookEventName } from "../hooks/index.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
@@ -402,6 +403,27 @@ const builtinSlashCommandEntries = [
             ctx.clearMessages();
         },
     },
+    {
+        name: "copy",
+        description: "Copy the last assistant message to the system clipboard",
+        async handler(args, ctx) {
+            const lastAssistant = [...ctx.agent.messages]
+                .reverse()
+                .find((m) => m.role === "assistant" && typeof m.content === "string" && m.content.trim().length > 0);
+            if (!lastAssistant || typeof lastAssistant.content !== "string") {
+                return "No assistant message to copy yet.";
+            }
+            const text = lastAssistant.content;
+            try {
+                await copyToClipboard(text);
+            }
+            catch (err) {
+                return `Failed to copy to clipboard: ${err?.message || String(err)}`;
+            }
+            const chars = text.length;
+            return `Copied last assistant message to clipboard (${chars} character${chars === 1 ? "" : "s"}).`;
+        },
+    },
     {
         name: "rewind",
         description: "Rewind conversation and/or file edits to before an earlier message. Usage: /rewind [n] [--code|--chat]",

package/dist/tools/todo.js

@@ -13,50 +13,33 @@ export function createTodoTool(store) {
 
 ## When to use
 
-Use this tool proactively when any of these apply:
-1. Complex multi-step work — 3 or more distinct steps or file locations
-2. Non-trivial tasks requiring planning or coordination across multiple operations
-3. The user explicitly asks for a todo list
-4. The user provides a list of things to do (numbered, comma-separated, bulleted)
-5. New instructions arrive mid-session — capture them as todos before starting
-6. Starting work on a task — mark it in_progress BEFORE beginning. Only one item may be in_progress at a time
-7. Finishing a task — mark it completed immediately, don't batch completions
+Default to just doing the work. Reach for a list only when actively tracking progress would genuinely help you or the user follow it — never to pad simple work with filler steps or to state the obvious. When in doubt, skip the list and do the task; a list you never meaningfully update is just noise.
 
-## When NOT to use
+A list earns its place when:
+- The task is non-trivial and spans many actions across several areas of the codebase
+- There are non-obvious phases or dependencies you must hold in mind to avoid losing track (a plain read → edit → test sequence does not count)
+- The work is ambiguous and benefits from outlining the goals up front
+- The user asked for several distinct things in one prompt, or gave a numbered/bulleted list
+- The user explicitly asked for a todo list (aka TODOs)
+- You discover extra steps mid-task and intend to finish them before yielding
 
-Skip this tool when:
-1. There is a single, straightforward task
-2. The task is trivial and tracking provides no organizational benefit
-3. The work can be completed in fewer than 3 trivial steps
-4. The request is purely conversational or informational
+## Quality bar
 
-If there is only one trivial task, just do it — don't create a todo first.
+If you do make a list, make a good one: meaningful, logically ordered steps that are easy to verify as you go.
 
-## Examples
+Good — distinct, verifiable steps for genuinely multi-part work:
+1. Add CSS variables for the color palette
+2. Add the toggle with localStorage state
+3. Refactor components to use the variables
+4. Verify every view for readability
 
-<example>
-User: Add a dark mode toggle to the settings page, then run tests and build.
-Assistant: *creates a 5-item todo: toggle UI, theme state, CSS tokens, update components, run tests + build*
-<reasoning>Multiple distinct steps across UI, state, styles, and verification. User explicitly asked for tests + build.</reasoning>
-</example>
+Good — scope a search uncovers makes the list worth it:
+"Rename getCwd across the project" → grep finds 15 call sites in 8 files → one item per file so none are missed.
 
-<example>
-User: Rename getCwd to getCurrentWorkingDirectory across the project.
-Assistant: *greps, finds 15 call sites across 8 files, creates a per-file todo list*
-<reasoning>Scope discovered via grep shows many locations; a todo ensures each file is tracked and none are missed.</reasoning>
-</example>
+Bad — padding a task you could just do; do NOT create a list for this:
+"Fix the typo in the README title" → 1. Find typo  2. Open file  3. Fix it  4. Save. That is one edit — just make it.
 
-<example>
-User: How do I print "Hello World" in Python?
-Assistant: *answers in one sentence with a snippet — no todo*
-<reasoning>Informational, one-step, no tracking benefit.</reasoning>
-</example>
-
-<example>
-User: Add a comment to calculateTotal explaining what it does.
-Assistant: *calls edit directly — no todo*
-<reasoning>Single, localized change in one file.</reasoning>
-</example>
+Bad — vague, unverifiable filler: "Make it work", "Improve the styling", "Clean things up".
 
 ## Task states
 
@@ -73,7 +56,8 @@ Each item needs:
 - Update status in real time; mark completed IMMEDIATELY on finishing.
 - Never mark completed if tests are failing, implementation is partial, errors are unresolved, or needed files are missing — keep as in_progress.
 - When blocked, add a new task describing what must be resolved.
-- Remove items that are no longer relevant; don't leave stale entries.`,
+- Remove items that are no longer relevant; don't leave stale entries.
+- Do not re-send the list when nothing meaningful has changed since the last call; update only after real progress.`,
         parameters: {
             type: "object",
             properties: {

package/dist/tui-ink/app.js

@@ -32,11 +32,8 @@ import { collectFeedback } from "../feedback/collect.js";
 import { isKeyReleaseEvent } from "./key-events.js";
 import { errorMessage, formatModelSwitchError, switchAgentModel } from "../tui/model-switch.js";
 import { formatImageUserDisplayText, nextImageDisplayLabelStart } from "../tui/image-display.js";
-import { sanitizeTerminalMouseInput, transcriptScrollLinesFromMouseInput } from "./terminal-mouse.js";
-import { transcriptPageScrollDirection } from "./transcript-input.js";
 import { decideStartingSubmitFingerprint, submitPayloadFingerprint } from "./submit-dedupe.js";
 import { isQueuedInputForCurrentSession, queuedAndPendingDisplayKeys, } from "./input-queue.js";
-import { TranscriptViewport } from "./transcript-viewport.js";
 import { SessionPicker } from "./session-picker.js";
 import { sessionDisplayName } from "../tui/session-display.js";
 import { parseGoalCommand } from "../goal/command.js";
@@ -310,7 +307,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     const activeAbortRef = useRef(null);
     const exitRequestedRef = useRef(false);
     const sessionStartRef = useRef(Date.now());
-    const viewportRef = useRef(null);
+    // Bumped whenever the settled transcript is rebuilt non-monotonically
+    // (/clear, /compact, /rewind, session switch). Used as the <Static> key in
+    // MessageList so Ink discards its already-printed rows and re-prints the
+    // rebuilt list onto a freshly-cleared screen instead of appending duplicates.
+    const [staticGeneration, setStaticGeneration] = useState(0);
     // Steer/queue while the agent runs:
     // Enter steers the current run via the agent's input controller; Tab (or an
     // ineligible input) queues for the next turn. Both render placeholder user
@@ -492,14 +493,6 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         syncFirstPending();
         return unsubscribe;
     }, [questionController]);
-    // An approval or question demands the user's attention: re-engage
-    // bottom-follow even if they had scrolled up (second force trigger
-    // documented in transcript-scroll.ts).
-    useEffect(() => {
-        if (pendingApproval || pendingQuestion) {
-            viewportRef.current?.forceScrollToBottom();
-        }
-    }, [pendingApproval, pendingQuestion]);
     const rebuildSystemPrompt = useCallback((overrides) => {
         const modelParts = agent.model.includes(":")
             ? agent.model.split(":")
@@ -523,23 +516,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             requestExit();
             return;
         }
-        const overlayActive = !!(pickerMode || pendingPlan || pendingApproval || pendingQuestion || pendingFeedback || statsPanel);
-        const mouseInput = sanitizeTerminalMouseInput(input);
-        if (mouseInput.wheelDirections.length > 0) {
-            for (const lines of transcriptScrollLinesFromMouseInput(mouseInput, { overlayActive })) {
-                viewportRef.current?.scrollBy(lines);
-            }
-        }
-        if (mouseInput.hasMouse) {
-            if (!mouseInput.strippedInput)
-                return;
-            input = mouseInput.strippedInput;
-        }
-        const pageScrollDirection = transcriptPageScrollDirection(key, { overlayActive });
-        if (pageScrollDirection) {
-            viewportRef.current?.scrollPage(pageScrollDirection);
-            return;
-        }
+        // Scrolling is the terminal's job now: settled rows live in native
+        // scrollback (committed via <Static>), so the wheel, tmux copy-mode, and
+        // PageUp/PageDown scroll the real terminal with no app involvement and no
+        // flicker. Bubble no longer intercepts mouse reports or page keys, which
+        // also frees the arrow keys entirely for composer history.
         if (pendingPlan || pendingApproval || pendingQuestion || pendingFeedback || statsPanel)
             return;
         if (key.ctrl && input.toLowerCase() === "p" && !pickerMode && !activeAbortRef.current) {
@@ -608,9 +589,39 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
     const updateDisplayMessages = useCallback((updater) => {
         setMessages((prev) => compactDisplayMessages(updater(prev).map(withMessageKey)));
     }, []);
+    // Non-append transcript rebuilds (/clear, /compact, /rewind, session switch)
+    // replace the settled list rather than extending it. The rows already
+    // committed to the terminal's native scrollback (via <Static>) cannot be
+    // un-printed, so we wipe the screen + scrollback and bump the Static key:
+    // Ink then re-prints the rebuilt list fresh instead of appending duplicates.
+    const resetTranscript = useCallback((updater) => {
+        if (process.stdout.isTTY) {
+            process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+        }
+        setStaticGeneration((generation) => generation + 1);
+        updateDisplayMessages(updater);
+    }, [updateDisplayMessages]);
     const addMessage = useCallback((role, content) => {
         updateDisplayMessages((prev) => [...prev, withMessageKey({ role, content })]);
     }, [updateDisplayMessages]);
+    // Reflow on terminal resize. ink 7.0.3 only clears its dynamic frame when the
+    // terminal NARROWS (see its resized() handler); on widen / tmux split the
+    // stale frame is left behind and the working trace duplicates into
+    // scrollback. Dedicated scrollback renderers (pi-tui) handle this by doing a
+    // full clear + re-print on ANY width/height change so content rewraps
+    // cleanly — resetTranscript does exactly that here. Debounced so a drag
+    // coalesces into one reflow instead of flashing on every resize event.
+    const didMountSizeRef = useRef(false);
+    useEffect(() => {
+        if (!didMountSizeRef.current) {
+            didMountSizeRef.current = true;
+            return;
+        }
+        const timer = setTimeout(() => {
+            resetTranscript((prev) => prev);
+        }, 80);
+        return () => clearTimeout(timer);
+    }, [terminalColumns, terminalRows, resetTranscript]);
     useEffect(() => {
         if (!updateNoticeRefresh)
             return;
@@ -629,16 +640,15 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         };
     }, [addMessage, updateNoticeRefresh]);
     const clearMessages = useCallback(() => {
-        // The transcript lives entirely in React state now (alt-screen viewport,
-        // no terminal scrollback) — clearing state clears the screen. Writing
-        // \x1b[2J here would just flash a black frame before the next paint.
-        setMessages([]);
-    }, []);
+        // Settled rows live in the terminal's native scrollback now (committed via
+        // <Static>), so clearing React state is not enough — resetTranscript wipes
+        // the screen + scrollback and re-prints the (now empty) transcript.
+        resetTranscript(() => []);
+    }, [resetTranscript]);
     // Render a placeholder user row for input waiting to enter the run.
     const addStatusUserMessage = useCallback((content, status) => {
         const key = nextDisplayMessageKey("user");
         updateDisplayMessages((prev) => [...prev, { key, role: "user", content, inputStatus: status }]);
-        viewportRef.current?.forceScrollToBottom();
         return key;
     }, [updateDisplayMessages]);
     const prepareSubmitDisplay = useCallback((payload) => {
@@ -774,13 +784,12 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         clearComposerDraft();
         setSessionManager(result.manager);
         setTodos(agent.getTodos());
-        updateDisplayMessages(() => [
+        resetTranscript(() => [
             ...reconstructDisplayMessages(agent.messages).filter((message) => !queuedDisplayKeys.has(message.key ?? "")),
             withMessageKey({ role: "assistant", content: `⤷ Resumed session: ${sessionDisplayName(result.manager)}` }),
         ]);
-        viewportRef.current?.forceScrollToBottom();
         closePicker();
-    }, [addMessage, agent, clearComposerDraft, closePicker, setStartingSubmit, switchSession, updateDisplayMessages]);
+    }, [addMessage, agent, clearComposerDraft, closePicker, setStartingSubmit, switchSession, resetTranscript]);
     const handleModelSelect = useCallback((model, selectedThinkingLevel) => {
         const run = async () => {
             const nextThinkingLevel = await switchAgentModel({
@@ -795,8 +804,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                 setThinkingLevel,
                 sessionManager,
             });
+            // MiniMax thinking is a binary toggle (adaptive thinking), not a graded
+            // effort — show it as "thinking mode" rather than "medium effort".
+            const isMiniMaxModel = model.toLowerCase().includes("minimax");
             const effortNote = nextThinkingLevel && nextThinkingLevel !== "off"
-                ? ` with ${nextThinkingLevel} effort`
+                ? (isMiniMaxModel ? " in thinking mode" : ` with ${nextThinkingLevel} effort`)
                 : "";
             addMessage("assistant", `Model switched to ${displayModel(model)}${effortNote}.`);
             closePicker();
@@ -1006,9 +1018,8 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                         ...prev,
                         withMessageKey({ role: "user", content: displayContent }),
                     ]);
-                    // Sending is an explicit "watch the newest turn" intent: snap the
-                    // transcript back to the bottom even if the user had scrolled up.
-                    viewportRef.current?.forceScrollToBottom();
+                    // The new user row commits to native scrollback; the terminal keeps
+                    // the prompt in view, so there is no app-side "snap to bottom" to do.
                 }
                 setIsRunning(true);
                 runStartRef.current = Date.now();
@@ -1214,11 +1225,22 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                                 // boundary. Move it after the just-finished tool/assistant
                                 // turn instead of clearing the badge in its original
                                 // placeholder position.
+                                //
+                                // This move pulls the pending-steer block out of the live
+                                // (dynamic) region and re-commits it elsewhere in <Static>, so
+                                // the live frame SHRINKS and the block's old rows are vacated
+                                // with nothing taking their place. Ink's in-place redraw leaves
+                                // those rows behind under tmux (its cursor-up clear can't reach
+                                // a frame that has scrolled), which is the blank gap users see
+                                // after steering. A full reprint (resetTranscript) rewrites the
+                                // transcript cleanly with no leftover — the same fix the resize
+                                // path uses. Unlike a turn settling (content moves in place),
+                                // this reorder is rare, so the reprint cost is acceptable.
                                 const steer = pendingSteersRef.current.get(event.id);
                                 if (steer) {
                                     pendingSteersRef.current.delete(event.id);
                                     setPendingSteerCount(pendingSteersRef.current.size);
-                                    updateDisplayMessages((prev) => moveStatusMessageToEnd(prev, steer.displayKey));
+                                    resetTranscript((prev) => moveStatusMessageToEnd(prev, steer.displayKey));
                                 }
                                 break;
                             }
@@ -1267,7 +1289,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                     commitAssistantMessage();
                     if (err instanceof AgentAbortError || err?.name === "AbortError") {
                         runCancelled = true;
-                        updateDisplayMessages(() => reconstructDisplayMessages(agent.messages));
+                        resetTranscript(() => reconstructDisplayMessages(agent.messages));
                     }
                     else {
                         runErrored = true;
@@ -1535,7 +1557,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                         // card; otherwise the pre-compaction history would keep rendering.
                         if (result.startsWith("✓ Compaction complete")) {
                             const summary = latestCompactionSummary(agent.messages);
-                            updateDisplayMessages(() => [
+                            resetTranscript(() => [
                                 ...reconstructDisplayMessages(agent.messages),
                                 {
                                     role: "assistant",
@@ -1548,7 +1570,7 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                         else if (result.startsWith("⏪")) {
                             // /rewind truncated agent.messages — rebuild the transcript from
                             // the rewound state before appending the summary.
-                            updateDisplayMessages(() => [
+                            resetTranscript(() => [
                                 ...reconstructDisplayMessages(agent.messages),
                                 { role: "assistant", content: result },
                             ]);
@@ -1638,23 +1660,23 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             return null;
         })()
         : null;
-    const showThinkingLabel = getAvailableThinkingLevels(agent.providerId, agent.apiModel).length > 2
-        && thinkingLevel
-        && thinkingLevel !== "off";
+    // MiniMax has only off/on, so the graded ">2 levels" gate would hide its label;
+    // surface it too (rendered as "thinking mode" by formatModelLine).
+    const isMiniMaxProvider = (agent.providerId || "").toLowerCase().includes("minimax");
+    const showThinkingLabel = Boolean(thinkingLevel)
+        && thinkingLevel !== "off"
+        && (isMiniMaxProvider || getAvailableThinkingLevels(agent.providerId, agent.apiModel).length > 2);
     const welcomeBannerNode = showWelcome ? (_jsx(WelcomeBanner, { terminalColumns: terminalColumns, tips: buildTips(agent, safeRegistry), updateNotice: currentUpdateNotice, cwd: friendlyCwd(args.cwd), providerId: agent.providerId || safeRegistry.getDefault()?.id, modelLabel: agent.model ? displayModel(agent.model) : undefined, thinkingLabel: showThinkingLabel ? thinkingLevel : undefined })) : null;
     const commandPaletteItems = useMemo(() => buildCommandPaletteItems(safeSkillRegistry), [safeSkillRegistry]);
     const mcpReconnectItems = useMemo(() => buildMcpReconnectItems(mcpManager), [mcpManager]);
-    // One row shorter than the terminal on purpose. A frame that exactly fills
-    // the screen makes Ink omit the trailing newline ("fullscreen" mode), and
-    // Ink's cursor-only repositioning (buildReturnToBottom) miscalculates by one
-    // row for such frames — the composer cursor lands one row above the prompt
-    // after any cursor-only update (e.g. restoreLastOutput following an external
-    // stdout write). Keeping every frame below viewport height keeps all of
-    // Ink's cursor paths on the consistent trailing-newline math.
-    const frameRows = Math.max(4, terminalRows - 1);
+    // No fixed-height frame: settled rows flow into the terminal's native
+    // scrollback via <Static>, and only the dynamic bottom stack (streaming
+    // tail, pickers, composer, footer) occupies the live region. Letting it size
+    // to its content keeps the composer pinned just below the latest output the
+    // way ordinary shell programs do.
     const sidebarWidth = sidebarVisible ? Math.min(42, Math.max(28, Math.floor(terminalColumns * 0.34))) : 0;
     const mainWidth = Math.max(40, terminalColumns - sidebarWidth);
-    return (_jsx(ThemeProvider, { value: palette, children: _jsxs(Box, { flexDirection: "row", width: terminalColumns, height: frameRows, backgroundColor: palette.background, children: [_jsxs(Box, { flexDirection: "column", width: mainWidth, height: frameRows, backgroundColor: palette.background, children: [_jsx(TranscriptViewport, { ref: viewportRef, children: _jsx(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, flexShrink: 0, children: _jsx(MessageList, { messages: messages, streamingContent: streamingContent, streamingReasoning: streamingReasoning, streamingTools: streamingTools, streamingParts: streamingParts, terminalColumns: mainWidth, showThinking: showThinking, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: approvalHint, nowTick: nowTick, welcomeBanner: welcomeBannerNode }) }) }), pickerMode === "model" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ModelPicker, { registry: safeRegistry, current: agent.model, currentThinkingLevel: thinkingLevel, recent: userConfig.getRecentModels(), onSelect: handleModelSelect, onCancel: closePicker }) })), pickerMode === "provider" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ProviderPicker, { providers: BUILTIN_PROVIDERS
+    return (_jsx(ThemeProvider, { value: palette, children: _jsxs(Box, { flexDirection: "row", width: terminalColumns, backgroundColor: palette.background, children: [_jsxs(Box, { flexDirection: "column", width: mainWidth, backgroundColor: palette.background, children: [_jsx(MessageList, { messages: messages, streamingContent: streamingContent, streamingReasoning: streamingReasoning, streamingTools: streamingTools, streamingParts: streamingParts, terminalColumns: mainWidth, showThinking: showThinking, expandedToolOutput: expandedToolOutput, verboseTrace: verboseTrace, pendingApproval: approvalHint, nowTick: nowTick, welcomeBanner: welcomeBannerNode, staticGeneration: staticGeneration, paddingX: 1, maxStreamRows: Math.max(6, terminalRows - 10) }), pickerMode === "model" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ModelPicker, { registry: safeRegistry, current: agent.model, currentThinkingLevel: thinkingLevel, recent: userConfig.getRecentModels(), onSelect: handleModelSelect, onCancel: closePicker }) })), pickerMode === "provider" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ProviderPicker, { providers: BUILTIN_PROVIDERS
                                     .filter((p) => isUserVisibleProvider(p.id))
                                     .map((p) => {
                                     const configured = safeRegistry.getConfigured().find((item) => item.id === p.id);

package/dist/tui-ink/input-box.d.ts

@@ -45,6 +45,7 @@ export declare function isCtrlCInput(input: string, key: {
     ctrl?: boolean;
 }): boolean;
 export declare function shouldUseLineComposerFrame(_background: string): boolean;
+export declare function composerSurfaceBackground(lineFrame: boolean, background: string, inputBg: string): string;
 export declare function shouldUseHardwareComposerCursor(env?: Record<string, string | undefined>): boolean;
 export declare function composerVerticalArrowDirection(key: {
     upArrow?: boolean;