@bubblebrain-ai/bubble 0.0.22 → 0.0.24

package/dist/tui/run.js

@@ -38,6 +38,11 @@ import { getNextPermissionMode, PERMISSION_MODE_INFO } from "../permission/mode.
 import { getContextBudget } from "../context/budget.js";
 import { getLspService } from "../lsp/index.js";
 import { inferBashPrefix } from "../approval/session-cache.js";
+import { parseGoalCommand } from "../goal/command.js";
+import { continuationPrompt, initialPrompt } from "../goal/prompts.js";
+import { shouldContinueGoal, stopReasonNotice } from "../goal/engine.js";
+import { goalSummaryText, goalIndicatorLine, goalCompleteNotice } from "../goal/format.js";
+import { formatInternalContextBlock } from "../agent/internal-reminder-sanitizer.js";
 import { collectFeedback } from "../feedback/collect.js";
 import { submitFeedback, FeedbackSubmitError } from "../feedback/submit.js";
 import { createFrames } from "./opencode-spinner.js";
@@ -101,6 +106,7 @@ const DEFAULT_THEME = {
     toolRead: "#9d7cd8",
     toolWrite: "#f5a742",
     toolSearch: "#5c9cf5",
+    toolMcp: "#d479c9",
     diffAdded: "#7fd88f",
     diffRemoved: "#e06c75",
     diffContext: "#a6acb8",
@@ -145,6 +151,7 @@ const LIGHT_THEME = {
     toolRead: "#6F55AE",
     toolWrite: "#8B4A00",
     toolSearch: "#356FD2",
+    toolMcp: "#A03595",
     diffAdded: "#1E725C",
     diffRemoved: "#B62633",
     diffContext: "#6F7377",
@@ -166,6 +173,10 @@ const LOCAL_SLASH_COMMANDS = [
         name: "toggle-thinking",
         description: "Toggle thinking block visibility",
     },
+    {
+        name: "goal",
+        description: "Set/manage an autonomous goal (/goal <objective>|clear|pause|resume|edit)",
+    },
     {
         name: "trace",
         description: "Toggle verbose trace output",
@@ -514,6 +525,28 @@ function OpenTuiApp(props) {
     const [todos, setTodos] = createSignal(props.agent.getTodos());
     const [mode, setMode] = createSignal(props.agent.mode);
     const [notice, setNotice] = createSignal("");
+    // Autonomous-goal feature: shared store (also backs the get_goal/update_goal
+    // tools), a reactive indicator line, the consecutive auto-continuation
+    // counter, and a flag to suppress persistence while loading from the session.
+    const goalStore = props.options.goalStore;
+    const [goalLine, setGoalLine] = createSignal("");
+    let goalPersistSuspended = false;
+    if (goalStore) {
+        goalStore.onChange((goal) => {
+            setGoalLine(goal ? goalIndicatorLine(goal) : "");
+            syncSidebarGoal();
+            if (!goalPersistSuspended)
+                persistGoal(goal);
+        });
+        const persisted = props.options.sessionManager?.getMetadata().goal;
+        if (persisted) {
+            goalPersistSuspended = true;
+            // Resume-safety: a loaded active goal is parked as paused so it never
+            // silently resumes (and spends tokens) on session load. /goal resume runs it.
+            goalStore.loadFrom(persisted.status === "active" ? { ...persisted, status: "paused" } : persisted);
+            goalPersistSuspended = false;
+        }
+    }
     let copyToastClearTimer;
     let copyToastRoot;
     let copyToastText;
@@ -564,6 +597,9 @@ function OpenTuiApp(props) {
     let rootBox;
     let sidebarShell;
     let homeSurfaceShell;
+    let homeUpdateNotice = props.options.updateNotice;
+    let homeUpdateNoticeBox;
+    let homeUpdateNoticeText;
     let transcriptHost;
     const transcriptState = {
         entries: [],
@@ -665,6 +701,8 @@ function OpenTuiApp(props) {
     const sidebarTodoRows = [];
     const sidebarTodoMarkers = [];
     const sidebarTodoLabels = [];
+    let sidebarGoalSection;
+    let sidebarGoalText;
     const sidebarFileRows = [];
     const sidebarFileLabels = [];
     const sidebarFileAdditions = [];
@@ -971,6 +1009,29 @@ function OpenTuiApp(props) {
         syncSidebarFiles();
         bumpSidebar();
     }
+    function syncSidebarGoal() {
+        const line = goalLine();
+        if (sidebarGoalSection)
+            sidebarGoalSection.visible = !!line;
+        if (sidebarGoalText) {
+            sidebarGoalText.content = line || "";
+            sidebarGoalText.requestRender();
+        }
+        sidebarShell?.requestRender();
+        rootBox?.requestRender();
+    }
+    function persistGoal(goal) {
+        const sessionManager = props.options.sessionManager;
+        if (!sessionManager)
+            return;
+        try {
+            const metadata = sessionManager.getMetadata();
+            sessionManager.setMetadata({ ...metadata, goal: goal ?? undefined });
+        }
+        catch {
+            // Persistence is best-effort; never break the run loop over it.
+        }
+    }
     function syncSidebarChrome() {
         const visible = sidebarVisible();
         if (sidebarShell) {
@@ -4912,6 +4973,10 @@ function OpenTuiApp(props) {
             toggleThinkingVisibility();
             return true;
         }
+        if (/^\/goal(?:\s|$)/.test(input.trim())) {
+            await handleGoalCommand(input);
+            return true;
+        }
         if (/^\/(?:trace|verbose|debug)(?:\s|$)/.test(input.trim())) {
             toggleVerboseTrace();
             return true;
@@ -5462,20 +5527,31 @@ function OpenTuiApp(props) {
             addMessage("error", "No model selected. Use /model after /login or provider setup.");
             return;
         }
-        rememberPromptHistory(displayInput);
-        // History keeps the short marker (it expands again on resend); the
-        // transcript shows the full pasted content once the message is sent.
-        const displayContent = expandComposerPastedTexts(displayInput);
-        const reusedQueuedDisplay = promoteQueuedUserDisplay(options.displayId, displayContent);
-        const nextMessages = reusedQueuedDisplay
-            ? displayMessages
-            : [...displayMessages, { role: "user", content: displayContent }];
-        if (!reusedQueuedDisplay)
-            displayMessages = nextMessages;
-        streamingDisplay = undefined;
-        // The user just sent this message — re-engage bottom-follow so the new
-        // turn is visible even if they had scrolled up to read earlier history.
-        redrawTranscript(undefined, nextMessages, { forceFollow: true });
+        // Goal continuation turns are "hidden": their input is an internal context
+        // block (stripped from the model echo) and must not render a user bubble or
+        // pollute prompt history.
+        const isGoalRun = !!options.goalRun;
+        if (!options.hidden) {
+            rememberPromptHistory(displayInput);
+            // History keeps the short marker (it expands again on resend); the
+            // transcript shows the full pasted content once the message is sent.
+            const displayContent = expandComposerPastedTexts(displayInput);
+            const reusedQueuedDisplay = promoteQueuedUserDisplay(options.displayId, displayContent);
+            const nextMessages = reusedQueuedDisplay
+                ? displayMessages
+                : [...displayMessages, { role: "user", content: displayContent }];
+            if (!reusedQueuedDisplay)
+                displayMessages = nextMessages;
+            streamingDisplay = undefined;
+            // The user just sent this message — re-engage bottom-follow so the new
+            // turn is visible even if they had scrolled up to read earlier history.
+            redrawTranscript(undefined, nextMessages, { forceFollow: true });
+        }
+        else {
+            streamingDisplay = undefined;
+            redrawTranscript(undefined, displayMessages, { forceFollow: true });
+        }
+        let goalRunTokens = 0;
         const taskStartedAt = Date.now();
         const run = beginAgentRun();
         traceEvent("tui_agent_run_begin", {
@@ -5743,6 +5819,8 @@ function OpenTuiApp(props) {
                             reasoningTokens: current.reasoningTokens + (event.usage.reasoningTokens ?? 0),
                             turns: current.turns + 1,
                         }));
+                        // Accumulate billed tokens (input + output) toward the goal budget.
+                        goalRunTokens += (event.usage.promptTokens || 0) + (event.usage.completionTokens || 0);
                     }
                     bumpSidebar();
                     const currentParts = snapshotDisplayParts(assistantParts);
@@ -5833,6 +5911,143 @@ function OpenTuiApp(props) {
             setTimeout(() => activePrompt()?.focus(), 0);
             if (queuedInputCount() > 0)
                 scheduleQueuedInputDrain();
+            maybeContinueGoal({ runCancelled, runErrored: !!runError, isGoalRun, runTokens: goalRunTokens });
+        }
+    }
+    /**
+     * Drives the autonomous goal loop. Called after every agent run finishes:
+     * accounts the goal turn, decides whether to auto-continue, and either fires
+     * the next hidden continuation turn or stops with an explanatory notice.
+     */
+    function maybeContinueGoal(input) {
+        if (!goalStore)
+            return;
+        const current = goalStore.snapshot();
+        if (!current)
+            return;
+        // User interrupt or a provider/run error (out of quota, network down, API
+        // failure) stops the autonomous loop. Pause an active goal so it never
+        // silently retries into a broken provider; the user fixes it and resumes.
+        if (input.runCancelled || input.runErrored) {
+            if (current.status === "active") {
+                goalStore.pause();
+                setNotice(stopReasonNotice(input.runErrored ? "error" : "cancelled"));
+            }
+            return;
+        }
+        // Account the goal turn that just finished (token spend + turn count).
+        if (input.isGoalRun) {
+            if (input.runTokens > 0)
+                goalStore.addTokens(input.runTokens);
+            goalStore.incrementTurn();
+        }
+        const goal = goalStore.snapshot();
+        const decision = shouldContinueGoal({ goal, queuedInputs: queuedInputCount() });
+        if (decision.continue) {
+            const text = formatInternalContextBlock("goal", continuationPrompt(goal));
+            // Start the next turn after this run has fully unwound.
+            queueMicrotask(() => { void runAgentInput(text, "", { hidden: true, goalRun: true }); });
+            return;
+        }
+        if (decision.reason === "budget" && goal.status === "active") {
+            goalStore.markBudgetLimited();
+        }
+        // tokensUsed is now accurate (addTokens ran above), so the completion notice
+        // carries the real final spend — which update_goal could not report mid-run.
+        if (decision.reason === "complete") {
+            setNotice(goalCompleteNotice(goal));
+            return;
+        }
+        const note = stopReasonNotice(decision.reason);
+        if (note)
+            setNotice(note);
+    }
+    // Starts a goal turn unless a run is already in flight (which will continue
+    // the goal when it finishes). When `displayInput` is given (the initial /goal
+    // set), the objective renders as a visible message so the user sees what they
+    // asked for; otherwise the turn is hidden (silent auto-continuation/resume).
+    function kickGoalTurn(prompt, displayInput) {
+        if (isRunning())
+            return;
+        queueMicrotask(() => {
+            void runAgentInput(prompt, displayInput ?? "", { hidden: displayInput === undefined, goalRun: true });
+        });
+    }
+    async function handleGoalCommand(input) {
+        if (!goalStore) {
+            setNotice("Goals are not available in this session");
+            return;
+        }
+        const command = parseGoalCommand(input);
+        if (command.error) {
+            addMessage("error", command.error);
+            return;
+        }
+        const existing = goalStore.snapshot();
+        switch (command.kind) {
+            case "show": {
+                if (!existing) {
+                    setNotice("No active goal. Set one with /goal <objective>");
+                }
+                else {
+                    setNotice(goalSummaryText(existing));
+                }
+                return;
+            }
+            case "clear": {
+                if (!existing) {
+                    setNotice("No active goal to clear");
+                    return;
+                }
+                goalStore.clear();
+                setNotice("Goal cleared");
+                return;
+            }
+            case "pause": {
+                if (!existing) {
+                    setNotice("No active goal to pause");
+                    return;
+                }
+                goalStore.pause();
+                setNotice("Goal paused — /goal resume to continue");
+                return;
+            }
+            case "resume": {
+                if (!existing) {
+                    setNotice("No goal to resume. Set one with /goal <objective>");
+                    return;
+                }
+                const resumed = goalStore.resume();
+                if (resumed?.status === "active") {
+                    setNotice("Goal resumed");
+                    kickGoalTurn(formatInternalContextBlock("goal", continuationPrompt(resumed)));
+                }
+                else {
+                    setNotice("Goal cannot be resumed (already complete)");
+                }
+                return;
+            }
+            case "edit": {
+                if (!existing) {
+                    setNotice("No active goal to edit. Set one with /goal <objective>");
+                    return;
+                }
+                goalStore.edit(command.objective);
+                if (command.tokenBudget !== undefined)
+                    goalStore.setBudget(command.tokenBudget);
+                setNotice(`Goal updated: ${truncate(goalStore.snapshot().objective, 60)}`);
+                return;
+            }
+            case "set": {
+                const goal = goalStore.set(command.objective, { tokenBudget: command.tokenBudget });
+                const budgetNote = goal.tokenBudget !== undefined ? ` (budget ${goal.tokenBudget} tok)` : "";
+                setNotice(`Goal set${budgetNote} — working autonomously. /goal pause to stop.`);
+                // Echo the full `/goal …` command the user typed as their visible
+                // message (so the transcript and prompt history reflect the invocation);
+                // the model receives the (hidden) initial goal prompt as the turn input.
+                kickGoalTurn(formatInternalContextBlock("goal", initialPrompt(goal)), input.trim());
+                return;
+            }
         }
     }
     function promptUiKeyDown(event) {
@@ -5922,11 +6137,49 @@ function OpenTuiApp(props) {
         }, [
             h("box", { flexShrink: 0, flexDirection: "column", alignItems: "center" }, ...logoLines.map((line) => renderHomeLogoLine(line))),
             h("box", { flexShrink: 0, flexDirection: "column", alignItems: "center", paddingTop: 1 }, h("text", { fg: theme.textMuted, content: `v${getCurrentVersion()}` })),
-            ...(props.options.updateNotice
-                ? [h("box", { flexShrink: 0, flexDirection: "column", alignItems: "center" }, h("text", { fg: theme.accent, content: props.options.updateNotice }))]
-                : []),
+            // Always mounted so a late registry check can reveal it mid-session.
+            h("box", {
+                ref: (ref) => {
+                    homeUpdateNoticeBox = ref;
+                    ref.visible = !!homeUpdateNotice;
+                },
+                visible: !!homeUpdateNotice,
+                flexShrink: 0,
+                flexDirection: "column",
+                alignItems: "center",
+            }, h("text", {
+                ref: (ref) => { homeUpdateNoticeText = ref; },
+                fg: theme.accent,
+                content: homeUpdateNotice ?? "",
+            })),
         ]);
     }
+    function watchUpdateNoticeRefresh() {
+        const refresh = props.options.updateNoticeRefresh;
+        if (!refresh)
+            return;
+        refresh.then((notice) => {
+            if (!notice || uiDisposed)
+                return;
+            homeUpdateNotice = notice;
+            if (homeUpdateNoticeText)
+                homeUpdateNoticeText.content = notice;
+            if (homeUpdateNoticeBox)
+                homeUpdateNoticeBox.visible = true;
+            // Already chatting (or resumed straight into a transcript): the home
+            // banner is hidden, so surface the nudge as a transcript line instead.
+            // (Not setNotice: the notice() row in renderSessionView is evaluated
+            // once at initial render and never materializes afterwards.)
+            if (!isHomeSurfaceActive(streamingDisplay))
+                addMessage("assistant", notice);
+            rootBox?.requestRender();
+        }).catch(() => {
+            // The check is best-effort; never disturb the session over it.
+        });
+    }
+    // Component body, not onMount: the onMount callback never fires under the
+    // current @opentui/solid runtime, so anything registered there is dead code.
+    watchUpdateNoticeRefresh();
     function renderQuestionPanelHost() {
         return h("box", {
             ref: (ref) => {
@@ -6684,7 +6937,7 @@ function OpenTuiApp(props) {
             visible: sidebarVisible(),
             flexDirection: "column",
         }, [
-            h("scrollbox", { flexGrow: 1, minHeight: 0 }, h("box", { flexDirection: "column", gap: 1, paddingRight: 1 }, renderSidebarTitle(), renderSidebarSection("Context", [
+            h("scrollbox", { flexGrow: 1, minHeight: 0 }, h("box", { flexDirection: "column", gap: 1, paddingRight: 1 }, renderSidebarTitle(), renderSidebarGoal(), renderSidebarSection("Context", [
                 h("text", {
                     fg: theme.textMuted,
                     flexShrink: 0,
@@ -6845,6 +7098,25 @@ function OpenTuiApp(props) {
             }),
         ]);
     }
+    function renderSidebarGoal() {
+        const line = goalLine();
+        return h("box", {
+            flexDirection: "column",
+            flexShrink: 0,
+            visible: !!line,
+            ref: (ref) => {
+                sidebarGoalSection = ref;
+                syncSidebarGoal();
+            },
+        }, h("text", { fg: theme.text }, "Goal"), h("text", {
+            fg: theme.accent,
+            wrapMode: "word",
+            ref: (ref) => {
+                sidebarGoalText = ref;
+                ref.content = goalLine() || "";
+            },
+        }));
+    }
     function renderSidebarTodos(todos) {
         const visible = todos.slice(0, 8);
         return h("box", {
@@ -7864,7 +8136,7 @@ function createTraceGroupRenderable(ctx, group, syntaxStyle, width = 80) {
         }))));
     }
     if (group.omitted > 0) {
-        children.push(createText(ctx, `  ... ${group.omitted} more, Ctrl+O to view`, {
+        children.push(createText(ctx, traceGroupOmittedLabel(group), {
             fg: theme.textMuted,
             wrapMode: "word",
         }));
@@ -7882,6 +8154,15 @@ function shouldRenderTraceGroupAsRawTool(tool) {
 function traceGroupDetailLines(group) {
     return group.previewLines.length > 0 ? group.previewLines : group.items;
 }
+// Overflow hint under a trace group. Line-based details (tool output) read as
+// "N more lines"; item-based details (file lists) stay as "N more".
+function traceGroupOmittedLabel(group) {
+    if (group.previewLines.length > 0) {
+        const noun = group.omitted === 1 ? "line" : "lines";
+        return `  ... ${group.omitted} more ${noun}, Ctrl+O to expand`;
+    }
+    return `  ... ${group.omitted} more, Ctrl+O to expand`;
+}
 const EXECUTE_COMMAND_BLOCK_MAX_LINES = 4;
 function executeInlineBudget(group, width) {
     return Math.max(14, width - group.title.length - 20);
@@ -7958,9 +8239,14 @@ function traceGroupTitleColor(group) {
         case "edit": return theme.toolWrite;
         case "subagent": return theme.accent;
         case "list": return theme.secondary;
-        default: return theme.toolText;
+        default: return isMcpTraceGroup(group) ? theme.toolMcp : theme.toolText;
     }
 }
+// An "other" group whose single tool is an MCP call (`mcp__<server>__<tool>`).
+function isMcpTraceGroup(group) {
+    const name = group.raw[0]?.name;
+    return typeof name === "string" && name.startsWith("mcp__");
+}
 function traceGroupKey(group) {
     return `group:${group.kind}:${group.raw.map((tool) => tool.id).join(":")}`;
 }
@@ -8749,7 +9035,7 @@ function renderTraceGroup(group, syntaxStyle, width = 80) {
             wrapMode: "word",
         }, `${index === 0 ? "↳ " : "  "}${truncate(line, detailWidth)}`)))
         : null, group.omitted > 0
-        ? h("text", { fg: theme.textMuted, wrapMode: "word" }, `  ... ${group.omitted} more, Ctrl+O to view`)
+        ? h("text", { fg: theme.textMuted, wrapMode: "word" }, traceGroupOmittedLabel(group))
         : null);
 }
 function renderTool(tool, syntaxStyle, width = 80) {
@@ -8864,14 +9150,17 @@ function pickerTitle(kind, providerId) {
 function getModelPickerReasoningLevels(providerId, modelId) {
     // Only expand into one picker row per effort for models that genuinely have a
     // reasoning-effort spectrum: OpenAI's reasoning models (codex gpt-5.x:
-    // off/minimal/low/medium/high/xhigh), DeepSeek's v4 models, and StepFun
-    // Step Plan models. Other providers
-    // (e.g. GLM, Moonshot/Kimi) only have a thinking on/off toggle, not an effort
-    // control, so they stay as a single row.
+    // off/minimal/low/medium/high/xhigh), DeepSeek's v4 models, StepFun
+    // Step Plan models, and GLM-5.2 (the only GLM that accepts `reasoning_effort`:
+    // none/minimal/low/medium/high/xhigh/max). Other providers — including older
+    // GLM (5.1/4.7/4.6/5-turbo) and Moonshot/Kimi — only have a thinking on/off
+    // toggle, not an effort control, so they stay as a single row.
     const isOpenAIReasoning = providerId === "openai" || providerId === "openai-codex";
     const isDeepseekReasoning = providerId === "deepseek" && (modelId === "deepseek-v4-flash" || modelId === "deepseek-v4-pro");
     const isStepFunReasoning = providerId === "stepfun";
-    if (!isOpenAIReasoning && !isDeepseekReasoning && !isStepFunReasoning)
+    const isGlm52Reasoning = ["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)
+        && modelId === "glm-5.2";
+    if (!isOpenAIReasoning && !isDeepseekReasoning && !isStepFunReasoning && !isGlm52Reasoning)
         return [];
     const levels = getAvailableThinkingLevels(providerId, modelId);
     // gpt-4o and friends report only ["off"] — keep those as a single row too.
@@ -8884,9 +9173,9 @@ function displayModelWithThinking(model, thinkingLevel) {
     if (!providerId)
         return displayModel(model);
     // Use the same scoping as the picker: only models with a real reasoning-effort
-    // spectrum (OpenAI codex gpt-5.x, deepseek v4, StepFun Step Plan) get the
-    // "(level)" suffix. The on/off thinking toggle on GLM / Moonshot(Kimi) is
-    // not an effort control.
+    // spectrum (OpenAI codex gpt-5.x, deepseek v4, StepFun Step Plan, GLM-5.2) get
+    // the "(level)" suffix. The on/off thinking toggle on older GLM / Moonshot(Kimi)
+    // is not an effort control.
     const levels = getModelPickerReasoningLevels(providerId, modelId);
     if (levels.length > 1 && thinkingLevel !== "off") {
         return `${displayModel(model)} (${thinkingLevel})`;

package/dist/tui/trace-groups.js

@@ -1,6 +1,7 @@
 import os from "node:os";
 import { getEditDiffDetails } from "./edit-diff.js";
 import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { mcpInfoFromString } from "../mcp/name.js";
 const DEFAULT_MAX_ITEMS = 6;
 const DEFAULT_MAX_PREVIEW_LINES = 8;
 export function buildTraceGroups(toolCalls, options = {}) {
@@ -120,13 +121,18 @@ function classifyTool(toolCall) {
             return { kind: "edit", title: "Edit", bucketKey: `edit:${toolCall.id}`, groupable: false };
         case "write":
             return { kind: "write", title: "Write", bucketKey: "write", groupable: true };
-        default:
+        default: {
+            const mcp = mcpInfoFromString(toolCall.name);
+            const title = mcp
+                ? `${mcp.serverName.toUpperCase()}: ${mcp.toolName}`
+                : displayToolName(toolCall.name);
             return {
                 kind: "other",
-                title: displayToolName(toolCall.name),
+                title,
                 bucketKey: `${toolCall.name}:${toolCall.id}`,
                 groupable: false,
             };
+        }
     }
 }
 function buildTraceGroup(classifier, raw, options) {
@@ -345,15 +351,23 @@ function buildSubagentGroup(classifier, tool, options, pending, startedAt) {
 }
 function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const tool = raw[0];
-    const header = toolHeader(tool, options.homeDir);
+    const mcp = mcpInfoFromString(tool.name);
+    // MCP tools carry arbitrary args, so render them as `key: value` pairs inline
+    // (via the `command` slot) instead of the path-based header used for builtins.
+    const header = mcp ? undefined : toolHeader(tool, options.homeDir);
+    const argsLabel = mcp ? mcpArgsLabel(tool.args) : "";
+    // Suppress the "N calls" fallback for MCP tools — the title already names the
+    // tool, and args (when present) ride alongside it.
+    const hasInline = mcp || !!header;
     const preview = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
     const { shown, omitted } = take(preview, options.maxPreviewLines);
     return {
         kind: "other",
         title: classifier.title,
         raw,
-        count: header ? undefined : raw.length,
-        noun: header ? undefined : plural(raw.length, "call", "calls"),
+        command: argsLabel || undefined,
+        count: hasInline ? undefined : raw.length,
+        noun: hasInline ? undefined : plural(raw.length, "call", "calls"),
         items: header ? [header] : [],
         previewLines: shown,
         errorLines: [],
@@ -469,6 +483,28 @@ function displayToolName(name) {
         return "Tool";
     return name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
 }
+/** Compact `key: value, key: value` rendering of an MCP tool's arguments. */
+function mcpArgsLabel(args) {
+    if (!args || typeof args !== "object")
+        return "";
+    return Object.entries(args)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}: ${formatMcpArgValue(value)}`)
+        .join(", ");
+}
+function formatMcpArgValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (value === null || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 function toolHeader(tool, homeDir) {
     const args = tool.args || {};
     for (const key of ["path", "command", "pattern", "query", "url"]) {

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

@@ -25,6 +25,8 @@ export interface RunTuiOptions {
     settingsManager?: SettingsManager;
     lspService?: LspService;
     mcpManager?: McpManager;
+    /** Accepted for compatibility with the shared options bag; the goal feature is OpenTUI-only. */
+    goalStore?: import("../goal/store.js").GoalStore;
     themeMode?: ThemeMode;
     themeOverrides?: Record<string, string>;
     detectedTheme?: ResolvedTheme;

package/dist/update/index.d.ts

@@ -37,10 +37,24 @@ export declare function upgradeCommandFor(manager: PackageManager): {
 export declare function runUpdateCommand(opts?: {
     checkOnly?: boolean;
 }): Promise<number>;
+export interface StartupUpdateCheck {
+    /** Notice derived from the local cache — available immediately, no network. */
+    notice: string | null;
+    /**
+     * Resolves once the background registry check completes: a notice string
+     * when it finds a version newer than both the running one and the cached
+     * `notice`, otherwise null. Never rejects.
+     */
+    refreshed: Promise<string | null>;
+}
 /**
- * Returns a one-line "update available" notice if the cached latest version is
- * newer than the running one. Reads only a local cache file (fast, no network
- * on the hot path); a stale cache triggers a fire-and-forget refresh so the
- * next launch is accurate. Never throws.
+ * Startup "update available" check. The immediate `notice` comes from the
+ * local cache file (fast, no network on the hot path). A registry refresh
+ * always runs in the background (throttled to once per 30 minutes) so a
+ * release published since the last launch surfaces in the *current* session
+ * via `refreshed`, instead of only after the cache TTL plus another restart.
+ * Never throws.
  */
+export declare function startStartupUpdateCheck(): Promise<StartupUpdateCheck>;
+/** Cache-only variant of {@link startStartupUpdateCheck} (still refreshes in the background). */
 export declare function getStartupUpdateNotice(): Promise<string | null>;