@bubblebrain-ai/bubble 0.0.22 → 0.0.23

package/README.md

@@ -1,38 +1,37 @@
 # Bubble
 
-Bubble is a terminal coding agent for working inside local project folders. It can read and edit files, run commands with approval controls, use project skills, connect MCP tools, and keep persistent memory across sessions.
+Bubble is a terminal coding agent. It works inside a local project folder: it reads and edits files, runs commands behind configurable approval controls, searches and navigates code with language-server intelligence, browses the web, loads reusable skills, connects MCP tools, fans work out to subagents, and keeps persistent memory across sessions.
+
+It is provider-agnostic. Bring an API key for OpenAI, Anthropic, Google, DeepSeek, Moonshot/Kimi, Zhipu, Z.AI, MiniMax, Groq, Together, Fireworks, a local OpenAI-compatible endpoint, and more — or sign in to ChatGPT with OAuth and drive the Codex models directly.
+
+---
 
 ## Requirements
 
-- Node.js 20+ and npm for installation
-- Bun for running Bubble
+- Node.js 20 or newer (used to install the launcher)
+- [Bun](https://bun.sh) (used to run the agent)
 
-Install Bun if it is not already available:
+Install Bun if you do not already have it:
 
 ```bash
 curl -fsSL https://bun.sh/install | bash
 ```
 
-## Install
+The `npm install` step puts a small Node.js launcher named `bubble` on your PATH. When you run `bubble`, the launcher locates Bun and starts the real runtime under it. If Bun is missing, it prints the install command above instead of failing with a low-level error.
 
-From npm:
+## Install
 
 ```bash
 npm install -g @bubblebrain-ai/bubble
 ```
 
-From a local package tarball:
+To install from a local tarball:
 
 ```bash
-npm install -g ./bubblebrain-ai-bubble-0.0.3.tgz
+npm install -g ./bubblebrain-ai-bubble-<version>.tgz
 ```
 
-The npm command installs a small Node.js launcher named `bubble`. When you run
-`bubble`, the launcher checks for Bun and starts the real Bubble runtime with
-`bun`. If Bun is missing, it prints the install command above instead of failing
-with a low-level runtime error.
-
-## Usage
+## Quick start
 
 Start Bubble in the current directory:
 
@@ -40,31 +39,192 @@ Start Bubble in the current directory:
 bubble
 ```
 
-Start Bubble for a specific project:
+On first launch, connect a model:
+
+- Run `/login` to sign in to ChatGPT (OAuth) and use the Codex models, or
+- Run `/provider` to add any other provider with an API key.
+
+Then just type what you want done. Bubble plans, edits files, and runs commands, asking for approval where the current permission mode requires it.
+
+Point Bubble at a different project:
 
 ```bash
 bubble --cwd /path/to/project
 ```
 
-Show CLI options:
+Resume your last conversation:
 
 ```bash
-bubble --help
+bubble --resume
+```
+
+## Model providers
+
+Bubble ships with a catalog of built-in providers. Configure them inside the app — no environment variables required.
+
+| How | What it does |
+| --- | --- |
+| `/login` | OAuth sign-in for ChatGPT; unlocks the OpenAI Codex models without an API key. |
+| `/provider` | Open a picker to connect, switch, add, or remove a provider. |
+| `/key <provider> <key>` | Set the API key for a provider. |
+| `/model` | Pick the active model and reasoning effort. |
+
+Built-in providers include OpenAI, Anthropic, Google, DeepSeek, Moonshot (CN and international), Kimi for Coding, Zhipu AI, Z.AI, Alibaba DashScope, MiniMax, StepFun, Groq, Together AI, Fireworks, and a `local` profile for any OpenAI-compatible endpoint (Ollama, vLLM, LM Studio, etc.).
+
+### Custom providers and models
+
+For full control — custom base URLs, self-hosted gateways, extra models, or pinning a protocol — define providers in `~/.bubble/models.json`:
+
+```json
+{
+  "providers": {
+    "my-gateway": {
+      "baseURL": "https://gateway.internal/v1",
+      "apiKey": "sk-...",
+      "protocol": "openai-chat",
+      "models": [
+        { "id": "my-model", "name": "My Model" }
+      ]
+    }
+  }
+}
+```
+
+`protocol` accepts `openai-chat` (default) or `anthropic-messages`. Entries in `models.json` take precedence over the built-in catalog.
+
+### Reasoning effort
+
+Models that support it expose a reasoning-effort control: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Set it with `/model <id> --reasoning-effort <level>` in the app, or at launch with `--reasoning` (medium) or `--reasoning-effort <level>`.
+
+## Permission modes
+
+Bubble gates risky actions behind a permission mode. Press `Tab` to cycle modes during a session, or set a default with `--plan` / `--dangerously-skip-permissions` / project settings.
+
+| Mode | Behavior |
+| --- | --- |
+| Default (Build) | File edits and writes auto-approve; bash and other tools prompt unless covered by an allow rule. |
+| Plan | Read-only investigation. The agent proposes a plan and waits for your approval before making changes. |
+| Bypass | Auto-approves every tool and disables all safety prompts. Enable deliberately with `--dangerously-skip-permissions`. |
+
+Allow/deny rules are configured per scope and persisted across sessions. Manage them in-app with `/permissions`, or edit the settings files directly:
+
+- `~/.bubble/settings.json` — user scope (applies everywhere)
+- `<project>/.bubble/settings.json` — project scope (commit to share with your team)
+- `<project>/.bubble/settings.local.json` — local overrides (gitignore)
+
+Rules use a simple pattern syntax, for example:
+
+```json
+{
+  "permissions": {
+    "defaultMode": "default",
+    "allow": [
+      "Bash(git status)",
+      "Bash(npm run:*)",
+      "Read(./src/**)",
+      "WebFetch(domain:github.com)"
+    ],
+    "deny": ["Read(~/.ssh/**)"]
+  }
+}
 ```
 
-## Configuration
+## What Bubble can do
 
-Bubble stores user configuration, sessions, permissions, skills, and memory under:
+**Files and code.** Read, write, and make targeted edits; find files by glob; search contents with ripgrep; and navigate with language-server operations (go-to-definition, find references, hover, document/workspace symbols, call hierarchy).
+
+**Shell and dev servers.** Run bounded bash commands with streaming output, and start/stop/inspect long-running dev servers (`npm run dev`, Vite, Next, etc.) with readiness checks and captured logs.
+
+**Web.** Search the web and fetch/extract page contents on demand.
+
+**Skills.** Drop reusable instructions and assets into a `SKILL.md`-based directory and invoke them with `/<skill-name>`. Bubble discovers skills from `~/.bubble/skills`, `~/.agents/skills`, `~/.claude/skills`, and the project's `.bubble/skills`. Browse them with `/skills`.
+
+**MCP tools.** Connect Model Context Protocol servers (stdio, HTTP, or SSE) under the `mcpServers` key of any settings file. Their tools and prompts become available to the agent; manage connections with `/mcp`.
+
+**Subagents.** Bubble can spawn background subagents with independent context, send them follow-ups, wait on their results, and fan a task out across a team — with concurrency limits and token budgets. Define custom agent profiles in `~/.bubble/agents` or a project's `.bubble/agents`.
+
+**Persistent memory.** A background pipeline distills durable facts, preferences, and decisions from past sessions and recalls them later. Inspect and maintain it with `/memory status`, `/memory search <query>`, and `/memory refresh`.
+
+**Sessions.** Every conversation is saved. Resume the latest with `bubble --resume`, or browse and switch sessions in-app with `/session`. Use `/rewind` to roll the conversation — and optionally your file edits — back to an earlier point.
+
+## Useful slash commands
+
+| Command | Description |
+| --- | --- |
+| `/help` | List available commands. |
+| `/model` | Switch model and reasoning effort. |
+| `/provider`, `/login`, `/logout`, `/key` | Connect and manage providers. |
+| `/session`, `/rewind`, `/clear` | Manage conversation history. |
+| `/skills` | Open the searchable skills picker. |
+| `/mcp` | List or reconnect MCP servers. |
+| `/memory` | Inspect and maintain persistent memory. |
+| `/permissions` | View or edit allow/deny rules. |
+| `/context`, `/stats`, `/compact` | Inspect context usage, model stats, and compact the session. |
+| `/lsp`, `/hooks` | Manage language servers and lifecycle hooks. |
+| `/theme`, `/sidebar` | Adjust the interface. |
+| `/feedback` | Send feedback or report a bug. |
+
+## Non-interactive mode
+
+Run a single prompt and print the result — useful for scripts and pipelines:
+
+```bash
+bubble --print "summarize what this repo does"
+echo "fix the failing test" | bubble --print
+```
+
+Combine with `--model`, `--cwd`, and `--plan` as needed.
+
+## CLI reference
 
 ```text
-~/.bubble
+Usage:
+  bubble [options] [prompt]              Start interactive TUI
+  bubble update [--check]                Update to the latest version (alias: upgrade)
+  bubble serve --feishu [options]        Run as a Feishu bot host
+
+Options (default):
+  -m, --model <model>      Model to use
+  --cwd <dir>              Working directory (default: current)
+  -k, --api-key <key>      API key for the active provider
+  -r, --resume             Resume a previous session (latest by default)
+  --session <name>         Session name to create or resume
+  --reasoning              Enable reasoning mode at medium effort
+  --reasoning-effort <l>   Set reasoning effort: off|minimal|low|medium|high|xhigh|max
+  --plan                   Start in plan mode (read-only investigation; propose before executing)
+  --dangerously-skip-permissions
+                           Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)
+  -p, --print              Non-interactive mode (single prompt)
+  -v, --version            Print the installed version and exit
+  -h, --help               Show this help
 ```
 
-In the app, use `/login` or provider commands to configure model access.
+Run `bubble update` at any time to upgrade to the latest published version.
+
+## Configuration and storage
 
-### ChatGPT Network Configuration
+Bubble keeps everything under `~/.bubble`:
+
+```text
+~/.bubble/
+  config.json          User preferences (theme, default model, recent models)
+  models.json          Custom providers and models
+  auth.json            OAuth credentials (file mode 0600)
+  settings.json        User-scope permissions, MCP servers, hooks
+  sessions/            Saved conversations, grouped by project directory
+  memories/            Persistent memory store
+  skills/              User skills
+  agents/              Custom subagent profiles
+```
 
-ChatGPT OAuth and GPT/Codex requests respect standard proxy variables:
+Environment variables:
+
+- `BUBBLE_HOME` — override the data directory (defaults to `~/.bubble`).
+- `BUBBLE_DEV=1` — use `~/.bubble-dev` instead, for development.
+
+### Network configuration
+
+ChatGPT OAuth and GPT/Codex requests respect the standard proxy variables:
 
 ```bash
 export HTTPS_PROXY=http://proxy.example.com:8080
@@ -72,28 +232,31 @@ export HTTP_PROXY=http://proxy.example.com:8080
 export NO_PROXY=localhost,127.0.0.1
 ```
 
-If your network uses a corporate or custom HTTPS CA, start Bubble with:
+If your network uses a corporate or custom HTTPS CA:
 
 ```bash
 NODE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
 ```
 
-You can also use `BUBBLE_EXTRA_CA_CERTS` for Bubble's ChatGPT requests:
+`BUBBLE_EXTRA_CA_CERTS` applies the same trust to Bubble's ChatGPT requests specifically. Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+
+## Development
 
 ```bash
-BUBBLE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+bun install        # install dependencies
+npm run build      # compile TypeScript to dist/
+npm test           # run the test suite (vitest)
+npm start          # run the built agent
 ```
 
-Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+`npm run dev` compiles and launches in one step. The TUI is built on [OpenTUI](https://github.com/anomalyco/opentui) and Solid.
 
-## Memory
+## Feishu host (optional)
 
-Bubble maintains persistent memory automatically from prior sessions. Useful commands:
+Bubble can also run as a Feishu (Lark) bot host:
 
-```text
-/memory status
-/memory search <query>
-/memory refresh
+```bash
+bubble serve --feishu --setup
 ```
 
-Memory is maintained by a background pipeline and can be refreshed manually when you want new session information to be indexed immediately.
+`--setup` runs the binding wizard, `--kill-old` replaces a conflicting instance for the same App ID, and `--dry-run` connects once and exits as a smoke test.

package/dist/agent/internal-reminder-sanitizer.js

@@ -54,17 +54,37 @@ export function sanitizeAssistantProviderMetadata(metadata) {
     if (!metadata || !anthropic || !blocks?.length)
         return metadata;
     let changed = false;
-    const sanitizedBlocks = blocks.map((block) => {
-        if (block.type !== "text" || typeof block.text !== "string") {
-            return block;
+    const sanitizedBlocks = [];
+    for (const block of blocks) {
+        // Plaintext text blocks are unsigned, so rewriting them in place is safe.
+        if (block.type === "text" && typeof block.text === "string") {
+            const sanitizedText = sanitizeInternalReminderBlocks(block.text);
+            if (sanitizedText !== block.text) {
+                changed = true;
+                sanitizedBlocks.push({ ...block, text: sanitizedText });
+            }
+            else {
+                sanitizedBlocks.push(block);
+            }
+            continue;
         }
-        const sanitizedText = sanitizeInternalReminderBlocks(block.text);
-        if (sanitizedText === block.text) {
-            return block;
+        // Extended-thinking blocks carry an Anthropic signature over their exact
+        // text; rewriting the text would invalidate the signature and the API
+        // would reject the replayed block. So when a thinking block's text carries
+        // internal markup (e.g. an echoed system reminder), DROP the whole block
+        // rather than mutate it. Thinking text is never user-visible — the display
+        // path renders message.reasoning, not contentBlocks — so dropping loses
+        // nothing on screen; it only keeps the verbatim reminder out of the
+        // persisted metadata and the Anthropic replay payload. redacted_thinking
+        // holds encrypted `data` (no plaintext field) and cannot carry a reminder.
+        if (block.type === "thinking" && typeof block.thinking === "string") {
+            if (sanitizeInternalReminderBlocks(block.thinking) !== block.thinking) {
+                changed = true;
+                continue;
+            }
         }
-        changed = true;
-        return { ...block, text: sanitizedText };
-    });
+        sanitizedBlocks.push(block);
+    }
     if (!changed)
         return metadata;
     return {

package/dist/main.js

@@ -563,8 +563,9 @@ async function main() {
             runMemorySummary,
             runMemoryRefresh,
         };
-        const { getStartupUpdateNotice } = await import("./update/index.js");
-        const updateNotice = await getStartupUpdateNotice();
+        const { startStartupUpdateCheck } = await import("./update/index.js");
+        const updateCheck = await startStartupUpdateCheck();
+        const updateNotice = updateCheck.notice;
         // Two explicit branches (not a dynamic ternary import) so TypeScript
         // checks each renderer's RunTuiOptions shape independently.
         let exitWallMs;
@@ -577,6 +578,7 @@ async function main() {
                 detectedTheme,
                 onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
                 updateNotice: updateNotice ?? undefined,
+                updateNoticeRefresh: updateCheck.refreshed,
             });
         }
         else {

package/dist/model-catalog.js

@@ -28,6 +28,9 @@ const GPT51_CODEX_MAX_LEVELS = ["off", "low", "medium", "high", "xhigh"];
 const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 const OPENAI_CHAT_LEVELS = ["off"];
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
+// kimi-k2.7-code only supports thinking mode (disabling it errors), so "off" is
+// not offered — the model is always in its thinking variant.
+const KIMI_THINKING_ONLY_LEVELS = ["medium"];
 const DEEPSEEK_V4_LEVELS = ["high", "max"];
 const STEPFUN_REASONING_LEVELS = ["off", "low", "medium", "high"];
 const MINIMAX_M3_REASONING_LEVELS = ["off", "medium"];
@@ -105,18 +108,21 @@ export const BUILTIN_MODELS = [
     { id: "step-3.5-flash-2603", name: "Step 3.5 Flash 2603", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-3.5-flash", name: "Step 3.5 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-router-v1", name: "Step Router V1", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
+    { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-cn", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "moonshot-cn", reasoningLevels: ["off"], contextWindow: 256000 },
     { id: "kimi-k2-0905-preview", name: "Kimi K2 0905", providerId: "moonshot-cn", reasoningLevels: ["off"], contextWindow: 256000 },
     { id: "kimi-k2-thinking", name: "Kimi K2 Thinking", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
+    { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-intl", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "moonshot-intl", reasoningLevels: ["off"], contextWindow: 256000 },
     { id: "kimi-k2-0905-preview", name: "Kimi K2 0905", providerId: "moonshot-intl", reasoningLevels: ["off"], contextWindow: 256000 },
     { id: "kimi-k2-thinking", name: "Kimi K2 Thinking", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
+    { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "kimi-for-coding", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "kimi-for-coding", reasoningLevels: ["off"], contextWindow: 256000 },

package/dist/provider-transform.js

@@ -1,6 +1,7 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
+const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code"]);
 const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
 const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
@@ -78,6 +79,19 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     // temperature/top_p/n/penalties and exposes thinking via extra_body.thinking;
     // kimi-k2-thinking family locks temperature=1.
     if (MOONSHOT_PROVIDER_IDS.has(providerId)) {
+        // kimi-k2.7-code is thinking-only: temperature is locked to 1.0 server-side
+        // (any explicit value errors), thinking can never be disabled, and
+        // reasoning_content must be echoed back on tool-call turns.
+        if (KIMI_K27_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                extraBody: {
+                    thinking: { type: "enabled" },
+                },
+            };
+        }
         if (KIMI_K25_FAMILY.has(modelId)) {
             return {
                 effectiveThinkingLevel,

package/dist/tui/run.d.ts

@@ -45,6 +45,12 @@ export interface RunTuiOptions {
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
     /** One-line "update available" notice shown on the home screen, if any. */
     updateNotice?: string;
+    /**
+     * Background registry check started before the TUI. Resolves with a late
+     * "update available" notice (or null); the TUI surfaces it live — on the
+     * home screen when still there, otherwise as a composer notice.
+     */
+    updateNoticeRefresh?: Promise<string | null>;
     /**
      * Swap the active session in place (driven by the /session picker).
      * Rebinds persistence to the picked session file and replaces the agent's

package/dist/tui/run.js

@@ -101,6 +101,7 @@ const DEFAULT_THEME = {
     toolRead: "#9d7cd8",
     toolWrite: "#f5a742",
     toolSearch: "#5c9cf5",
+    toolMcp: "#d479c9",
     diffAdded: "#7fd88f",
     diffRemoved: "#e06c75",
     diffContext: "#a6acb8",
@@ -145,6 +146,7 @@ const LIGHT_THEME = {
     toolRead: "#6F55AE",
     toolWrite: "#8B4A00",
     toolSearch: "#356FD2",
+    toolMcp: "#A03595",
     diffAdded: "#1E725C",
     diffRemoved: "#B62633",
     diffContext: "#6F7377",
@@ -564,6 +566,9 @@ function OpenTuiApp(props) {
     let rootBox;
     let sidebarShell;
     let homeSurfaceShell;
+    let homeUpdateNotice = props.options.updateNotice;
+    let homeUpdateNoticeBox;
+    let homeUpdateNoticeText;
     let transcriptHost;
     const transcriptState = {
         entries: [],
@@ -5922,11 +5927,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) => {
@@ -7864,7 +7907,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 +7925,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 +8010,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 +8806,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) {

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

package/dist/update/index.js

@@ -16,7 +16,9 @@ import { getBubbleHome } from "../bubble-home.js";
 const require = createRequire(import.meta.url);
 export const PACKAGE_NAME = "@bubblebrain-ai/bubble";
 const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // once a day
+// Throttle for the startup registry check. Short on purpose: with frequent
+// releases, a long TTL means users only learn about a new version a day late.
+const REFRESH_THROTTLE_MS = 30 * 60 * 1000;
 export function getCurrentVersion() {
     try {
         const pkg = require("../../package.json");
@@ -209,32 +211,52 @@ async function writeCache(cache) {
         // best-effort; never fail startup over a cache write
     }
 }
-async function refreshCacheInBackground(now) {
-    const latest = await fetchLatestVersion(4000);
-    if (latest) {
-        await writeCache({ lastCheck: now, latest });
-    }
+function formatUpdateNotice(current, latest) {
+    return `Update available: v${current} → v${latest} · run \`bubble update\``;
 }
 /**
- * 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 async function getStartupUpdateNotice() {
+export async function startStartupUpdateCheck() {
     try {
         const current = getCurrentVersion();
         const now = Date.now();
         const cache = await readCache();
-        if (!cache || now - cache.lastCheck > CHECK_INTERVAL_MS) {
-            void refreshCacheInBackground(now);
-        }
-        if (cache && compareVersions(cache.latest, current) > 0) {
-            return `Update available: v${current} → v${cache.latest} · run \`bubble update\``;
-        }
-        return null;
+        const notice = cache && compareVersions(cache.latest, current) > 0
+            ? formatUpdateNotice(current, cache.latest)
+            : null;
+        const refreshed = (async () => {
+            try {
+                if (cache && now - cache.lastCheck < REFRESH_THROTTLE_MS)
+                    return null;
+                const latest = await fetchLatestVersion(4000);
+                if (!latest)
+                    return null;
+                await writeCache({ lastCheck: now, latest });
+                if (compareVersions(latest, current) <= 0)
+                    return null;
+                // The cache already surfaced this version in `notice` — stay quiet.
+                if (notice && cache && compareVersions(latest, cache.latest) <= 0)
+                    return null;
+                return formatUpdateNotice(current, latest);
+            }
+            catch {
+                return null;
+            }
+        })();
+        return { notice, refreshed };
     }
     catch {
-        return null;
+        return { notice: null, refreshed: Promise.resolve(null) };
     }
 }
+/** Cache-only variant of {@link startStartupUpdateCheck} (still refreshes in the background). */
+export async function getStartupUpdateNotice() {
+    const check = await startStartupUpdateCheck();
+    return check.notice;
+}

package/package.json

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