gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/dist/onboarding.js

@@ -749,11 +749,10 @@ export async function runToolKeysStep(p, pc, authStorage) {
 }
 // ─── Remote Questions Step ────────────────────────────────────────────────────
 export async function runRemoteQuestionsStep(p, pc, authStorage) {
-    // Check existing config — use authStorage.get() and validate the key
-    const hasValidKey = (provider) => {
-        const c = authStorage.get(provider);
-        return c?.type === 'api_key' && typeof c.key === 'string' && c.key.length > 0;
-    };
+    // Check existing config — use getCredentialsForProvider to skip empty-key entries
+    const hasValidKey = (provider) => authStorage
+        .getCredentialsForProvider(provider)
+        .some((c) => c.type === 'api_key' && typeof c.key === 'string' && c.key.length > 0);
     const hasDiscord = hasValidKey('discord_bot');
     const hasSlack = hasValidKey('slack_bot');
     const hasTelegram = hasValidKey('telegram_bot');
@@ -951,6 +950,7 @@ async function runDiscordChannelStep(p, pc, token) {
         if (p.isCancel(choice))
             return null;
         guildId = choice;
+        guildName = guilds.find(g => g.id === guildId)?.name ?? guildId;
     }
     // Fetch channels
     let channels;

package/dist/provider-migrations.d.ts

@@ -1,10 +1,28 @@
 import type { AuthStorage } from "@gsd/pi-coding-agent";
 type AnthropicMigrationDeps = {
-    authStorage: Pick<AuthStorage, "get">;
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
     isClaudeCodeReady: boolean;
     defaultProvider: string | undefined;
     env?: NodeJS.ProcessEnv;
 };
-export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "get">, env?: NodeJS.ProcessEnv): boolean;
+type MigrationModel = {
+    provider: string;
+    id: string;
+};
+type AnthropicDefaultMigrationDeps = {
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
+    isClaudeCodeReady: boolean;
+    settingsManager: {
+        getDefaultProvider(): string | undefined;
+        getDefaultModel(): string | undefined;
+        setDefaultModelAndProvider(provider: string, modelId: string): void;
+    };
+    modelRegistry: {
+        getAvailable(): MigrationModel[];
+    };
+    env?: NodeJS.ProcessEnv;
+};
+export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "getCredentialsForProvider">, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env, }: AnthropicMigrationDeps): boolean;
+export declare function migrateAnthropicDefaultToClaudeCode({ authStorage, isClaudeCodeReady, settingsManager, modelRegistry, env, }: AnthropicDefaultMigrationDeps): boolean;
 export {};

package/dist/provider-migrations.js

@@ -2,8 +2,7 @@ export function hasDirectAnthropicApiKey(authStorage, env = process.env) {
     if ((env.ANTHROPIC_API_KEY ?? "").trim()) {
         return true;
     }
-    const credential = authStorage.get("anthropic");
-    return credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0;
+    return authStorage.getCredentialsForProvider("anthropic").some((credential) => credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0);
 }
 export function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env = process.env, }) {
     if (!isClaudeCodeReady || defaultProvider !== "anthropic") {
@@ -11,3 +10,17 @@ export function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeRe
     }
     return !hasDirectAnthropicApiKey(authStorage, env);
 }
+export function migrateAnthropicDefaultToClaudeCode({ authStorage, isClaudeCodeReady, settingsManager, modelRegistry, env = process.env, }) {
+    const defaultProvider = settingsManager.getDefaultProvider();
+    if (!shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env })) {
+        return false;
+    }
+    const defaultModel = settingsManager.getDefaultModel();
+    const target = modelRegistry.getAvailable().find((model) => model.provider === "claude-code" && model.id === defaultModel) ||
+        modelRegistry.getAvailable().find((model) => model.provider === "claude-code");
+    if (!target) {
+        return false;
+    }
+    settingsManager.setDefaultModelAndProvider(target.provider, target.id);
+    return true;
+}

package/dist/remote-questions-config.js

@@ -26,7 +26,7 @@ export function saveRemoteQuestionsConfig(channel, channelId) {
     ].join("\n");
     const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    let next;
+    let next = content;
     if (fmMatch) {
         let frontmatter = fmMatch[1];
         const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -5,7 +5,7 @@
  * immediately. The LLM can continue working and check results later
  * with await_job.
  */
-import { getShellConfig, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, sanitizeCommand, } from "@gsd/pi-coding-agent";
+import { getShellConfig, sanitizeCommand, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream } from "node:fs";

package/dist/resources/extensions/aws-auth/index.js

@@ -133,7 +133,6 @@ export default function (pi) {
         const refreshed = await runRefresh(refreshCommand, (m, level) => ctx.ui.notify(m, level));
         if (!refreshed)
             return;
-        // retryLastTurn removed in pi 0.67.2 — notify user to retry manually
-        ctx.ui.notify("AWS credentials refreshed. Please resend your message to retry.", "info");
+        pi.retryLastTurn();
     });
 }

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -3,7 +3,7 @@
  * context injection, process discovery, footer widget, and periodic maintenance.
  */
 import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
-import { processes, pendingAlerts, pushAlert, cleanupAll, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
+import { processes, pendingAlerts, pushAlert, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
 import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 export function registerBgShellLifecycle(pi, state) {
@@ -66,11 +66,14 @@ export function registerBgShellLifecycle(pi, state) {
         buildProcessStateAlert("Session tree was navigated.");
     });
     // Session switch resets the agent's context.
-    pi.on("session_start", async (_event, ctx) => {
+    pi.on("session_switch", async (event, ctx) => {
         state.latestCtx = ctx;
-        syncLatestCtxCwd();
-        if (state.latestCtx)
-            persistManifest(state.latestCtx.cwd);
+        if (event.reason === "new" && event.previousSessionFile) {
+            await cleanupSessionProcesses(event.previousSessionFile);
+            syncLatestCtxCwd();
+            if (state.latestCtx)
+                persistManifest(state.latestCtx.cwd);
+        }
         buildProcessStateAlert("Session was switched.");
     });
     // ── Context Injection: Proactive Alerts ────────────────────────────
@@ -338,7 +341,7 @@ export function registerBgShellLifecycle(pi, state) {
     pi.on("turn_end", refreshHandler);
     pi.on("agent_end", refreshHandler);
     pi.on("session_start", refreshHandler);
-    pi.on("session_before_switch", refreshHandler);
+    pi.on("session_switch", refreshHandler);
     pi.on("tool_execution_end", async (_event, ctx) => {
         state.latestCtx = ctx;
         refreshWidget();

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -6,8 +6,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { getShellConfig } from "@gsd/pi-coding-agent";
-import { sanitizeCommand } from "@gsd/pi-coding-agent";
+import { getShellConfig, sanitizeCommand } from "@gsd/pi-coding-agent";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
 import { MAX_BUFFER_LINES, MAX_EVENTS, DEAD_PROCESS_TTL, } from "./types.js";
 import { restoreWindowsVTInput, formatUptime } from "./utilities.js";

package/dist/resources/extensions/browser-tools/index.js

@@ -1,3 +1,4 @@
+/** browser-tools — pi extension: full browser interaction via Playwright. */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 let registrationPromise = null;
 async function registerBrowserTools(pi) {

package/dist/resources/extensions/claude-code-cli/index.js

@@ -16,9 +16,9 @@ import { streamViaClaudeCode } from "./stream-adapter.js";
 export default function claudeCodeCli(pi) {
     pi.registerProvider("claude-code", {
         authMode: "externalCli",
-        isReady: isClaudeCodeReady,
         api: "anthropic-messages",
         baseUrl: "local://claude-code",
+        isReady: isClaudeCodeReady,
         streamSimple: streamViaClaudeCode,
         models: CLAUDE_CODE_MODELS,
     });

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -4,103 +4,7 @@
  * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
  * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
  */
-// ---------------------------------------------------------------------------
-// XML parameter tag utilities (inline replacements for removed pi-ai symbols)
-// ---------------------------------------------------------------------------
-/**
- * Detects XML parameter tags (inline <parameter name="...">...</parameter> form)
- * or XML wrapper (<parameters>...</parameters>) in streaming tool call JSON.
- * Replaces removed pi-ai utility (removed in pi 0.67.2).
- * T-10-05: regex only detects tag presence; does not evaluate content.
- */
-function hasXmlParameterTags(s) {
-    return /<parameter[s\s>]/i.test(s);
-}
-/**
- * Repairs malformed LLM-generated tool JSON using three strategies:
- *
- * 1. XML parameter extraction: When inline <parameter name="key">value</parameter>
- *    tags appear inside a JSON string value, extract each as a top-level key and
- *    clean the containing string value by truncating at the closing tag boundary.
- *
- * 2. YAML bullet repair: When bare "- item" patterns appear as JSON values (not
- *    quoted), convert each bullet sequence into a JSON array.
- *
- * 3. XML wrapper extraction: Extract content from <parameters>...</parameters> wrapper.
- *
- * Replaces removed pi-ai utility (removed in pi 0.67.2).
- * T-10-05: extracts text content only, no evaluation.
- */
-function repairToolJson(s) {
-    // Strategy 1: XML parameter tags inside JSON string values (#3751)
-    // The raw JSON string may have escaped quotes: <parameter name=\"key\">val</parameter>
-    // or unescaped: <parameter name="key">val</parameter>
-    // We match both forms.
-    if (/<parameter\s+name=/i.test(s)) {
-        try {
-            // Match <parameter name="key"> or <parameter name=\"key\"> in raw JSON text
-            const paramPattern = /<parameter\s+name=(?:\\"|")([^"\\]+)(?:\\"|")>([\s\S]*?)<\/parameter>/gi;
-            const extracted = {};
-            let match;
-            while ((match = paramPattern.exec(s)) !== null) {
-                const key = match[1];
-                // rawVal may contain JSON-escaped characters; unescape for parsing
-                const rawVal = match[2].trim().replace(/\\"/g, '"').replace(/\\n/g, "\n");
-                // Attempt to parse value as JSON; fall back to string
-                try {
-                    extracted[key] = JSON.parse(rawVal);
-                }
-                catch {
-                    extracted[key] = rawVal;
-                }
-            }
-            if (Object.keys(extracted).length > 0) {
-                // Remove the XML parameter block and preceding closing tag from the raw string.
-                // The block looks like: </tagName>\n<parameter ...>...</parameter>...\n (with escaped chars)
-                // We remove from the first </...> closing tag through the last </parameter> tag.
-                const cleaned = s
-                    .replace(/<\/[^>]+>(?:\\n|\n)*(?:<parameter[\s\S]*?<\/parameter>(?:\\n|\n)*)+/gi, "")
-                    .trim();
-                // Parse cleaned base JSON and merge extracted params
-                const base = JSON.parse(cleaned);
-                return JSON.stringify({ ...base, ...extracted });
-            }
-        }
-        catch {
-            // Fall through to next strategy
-        }
-    }
-    // Strategy 2: YAML bullet lists as unquoted JSON values (#2660)
-    // Pattern: "key": - item1, "key2": - item2
-    if (/:\s*-\s+/.test(s)) {
-        try {
-            // Replace bare YAML bullet sequences with JSON arrays.
-            // Match: "key": - val1, - val2, "nextKey" or end
-            // We need to handle: "key": - item, "nextKey" where - item is the unquoted value
-            const repaired = s.replace(
-            // Match a quoted key followed by colon, then one or more "- item" bullets
-            // terminated by either a comma+quote (next key) or closing brace
-            /"([^"]+)":\s*((?:-\s+[^,\n\-"{}[\]]+(?:,\s*(?![-"\s*{]))?)+)/g, (fullMatch, key, bulletBlock) => {
-                // Extract individual bullet items
-                const items = bulletBlock
-                    .split(/,?\s*-\s+/)
-                    .map((item) => item.trim().replace(/,\s*$/, "").trim())
-                    .filter((item) => item.length > 0);
-                if (items.length === 0)
-                    return fullMatch;
-                return `"${key}": ${JSON.stringify(items)}`;
-            });
-            const parsed = JSON.parse(repaired);
-            return JSON.stringify(parsed);
-        }
-        catch {
-            // Fall through to next strategy
-        }
-    }
-    // Strategy 3: XML wrapper extraction (<parameters>...</parameters>)
-    const m = /<parameters[^>]*>([\s\S]*?)<\/parameters>/i.exec(s);
-    return m ? m[1].trim() : s;
-}
+import { hasXmlParameterTags, repairToolJson } from "@gsd/pi-ai";
 // ---------------------------------------------------------------------------
 // MCP tool name parsing
 // ---------------------------------------------------------------------------
@@ -158,16 +62,17 @@ export function mapContentBlock(block) {
         case "tool_use":
             return toolCallFromBlock(block.id, block.name, block.input);
         case "server_tool_use":
-            // ServerToolUseContent removed from pi-ai in pi 0.67.2 — represent as text
             return {
-                type: "text",
-                text: `[server tool use: ${block.name ?? "unknown"}]`,
+                type: "serverToolUse",
+                id: block.id,
+                name: block.name,
+                input: block.input,
             };
         case "web_search_tool_result":
-            // WebSearchResultContent removed from pi-ai in pi 0.67.2 — represent as text
             return {
-                type: "text",
-                text: `[web search result]`,
+                type: "webSearchResult",
+                toolUseId: block.tool_use_id,
+                content: block.content,
             };
         default: {
             const unknown = block;
@@ -280,7 +185,15 @@ export class PartialMessageBuilder {
                     this.partial.content.push(toolCallFromBlock(block.id, block.name, {}));
                     return { type: "toolcall_start", contentIndex, partial: this.partial };
                 }
-                // server_tool_use removed from pi-ai content types in pi 0.67.2 — skip
+                if (block.type === "server_tool_use") {
+                    this.partial.content.push({
+                        type: "serverToolUse",
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                    return { type: "server_tool_use", contentIndex, partial: this.partial };
+                }
                 return null;
             }
             // ---- Block delta ----
@@ -338,8 +251,6 @@ export class PartialMessageBuilder {
                             // malformation explicitly so downstream consumers can
                             // distinguish this from a healthy tool completion (#2574).
                             block.arguments = { _raw: jsonStr };
-                            // malformedArguments removed from the toolcall_end type in pi 0.67.2;
-                            // cast to any to preserve the runtime signal for downstream consumers (#2574)
                             return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial, malformedArguments: true };
                         }
                     }

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -3,8 +3,9 @@
  *
  * The SDK runs the full agentic loop (multi-turn, tool execution, compaction)
  * in one call. This adapter translates the SDK's streaming output into
- * AssistantMessageEvents for TUI rendering, then strips tool-call blocks from
- * the final AssistantMessage so GSD's agent loop doesn't try to dispatch them.
+ * AssistantMessageEvents for TUI rendering, then preserves externally executed
+ * tool-call blocks on the final AssistantMessage so Agent Core can render them
+ * while `externalToolExecution` prevents local redispatch.
  */
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
@@ -365,9 +366,8 @@ async function promptElicitationWithDialogs(request, questions, ui, signal) {
     for (const question of questions) {
         const title = buildElicitationPromptTitle(request, question);
         if (question.allowMultiple) {
-            // allowMultiple removed from ExtensionUIDialogOptions in pi 0.67.2;
-            // fall back to single-select (result is wrapped in array below)
             const selected = await ui.select(title, question.options.map((option) => option.label), {
+                allowMultiple: true,
                 signal,
             });
             if (Array.isArray(selected)) {
@@ -511,7 +511,7 @@ export async function resolveClaudePermissionMode(env = process.env) {
         console.warn("[claude-code-cli] Headless mode detected (GSD_HEADLESS=1): defaulting permissionMode to 'bypassPermissions' so verification Bash commands can run. Set GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits to opt out.");
         return "bypassPermissions";
     }
-    return "acceptEdits";
+    return "bypassPermissions";
 }
 // NOTE: These helpers intentionally mirror @gsd/pi-ai anthropic-shared
 // behavior so this extension remains typecheck-stable even when the published
@@ -563,21 +563,25 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
-    const permissionMode = overrides?.permissionMode ?? "acceptEdits";
-    const disallowedTools = ["AskUserQuestion"];
-    // Pre-authorize the safe built-ins and every registered workflow MCP
-    // server's tools. `acceptEdits` mode (the interactive default) only
-    // auto-approves file edits — Read/Glob/Grep, basic shell inspection, and
-    // every `mcp__gsd-workflow__*` call still surface as "This command
-    // requires approval" and block GSD actions (#4099).
+    const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
+    // Globally unblock all tools. Users reported that the `acceptEdits` default
+    // plus a narrow allowlist silently declined most Bash/Agent/WebFetch calls
+    // when `extensionUIContext` wasn't threaded through. Default to
+    // bypassPermissions and an empty disallow list so every tool — including
+    // `AskUserQuestion` and every `mcp__*` workflow tool — is auto-approved.
+    // Opt back into gated mode with GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits.
+    const disallowedTools = [];
     const allowedTools = [
         "Read",
         "Write",
         "Edit",
         "Glob",
         "Grep",
-        "Bash(ls:*)",
-        "Bash(pwd)",
+        "Bash",
+        "Agent",
+        "WebFetch",
+        "WebSearch",
+        "AskUserQuestion",
         ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
     ];
     const supportsAdaptive = modelSupportsAdaptiveThinking(modelId);
@@ -756,8 +760,7 @@ export function extractToolResultsFromSdkUserMessage(message) {
 /** Attach external tool results from the SDK synthetic user message to their corresponding tool-call blocks by ID. */
 function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
     for (const block of toolBlocks) {
-        // serverToolUse removed from AssistantMessage content in pi 0.67.2
-        if (block.type !== "toolCall")
+        if (block.type !== "toolCall" && block.type !== "serverToolUse")
             continue;
         const externalResult = toolResultsById.get(block.id);
         if (!externalResult)
@@ -765,6 +768,39 @@ function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
         block.externalResult = externalResult;
     }
 }
+/**
+ * Build the final assistant content that Agent Core consumes in
+ * `externalToolExecution` mode. This preserves tool-call blocks, attaches any
+ * SDK-produced external results by tool-call id, and then appends the final
+ * text/thinking blocks for the completed turn.
+ */
+export function buildFinalAssistantContent(params) {
+    const mergedToolBlocks = [...params.intermediateToolBlocks];
+    if (params.pendingContent) {
+        mergePendingToolCalls(mergedToolBlocks, params.pendingContent);
+    }
+    attachExternalResultsToToolBlocks(mergedToolBlocks, params.toolResultsById);
+    const finalContent = [...mergedToolBlocks];
+    if (params.pendingContent && params.pendingContent.length > 0) {
+        for (const block of params.pendingContent) {
+            if (block.type === "text" || block.type === "thinking") {
+                finalContent.push(block);
+            }
+        }
+    }
+    else {
+        if (params.lastThinkingContent) {
+            finalContent.push({ type: "thinking", thinking: params.lastThinkingContent });
+        }
+        if (params.lastTextContent) {
+            finalContent.push({ type: "text", text: params.lastTextContent });
+        }
+    }
+    if (finalContent.length === 0 && params.fallbackResultText) {
+        finalContent.push({ type: "text", text: params.fallbackResultText });
+    }
+    return finalContent;
+}
 /**
  * Merge tool-call blocks from the active partial-message builder into the
  * running list of intermediate tool calls, preserving order and de-duping
@@ -794,8 +830,9 @@ export function mergePendingToolCalls(intermediate, pending) {
  * GSD streamSimple function that delegates to the Claude Agent SDK.
  *
  * Emits AssistantMessageEvent deltas for real-time TUI rendering
- * (thinking, text, tool calls). The final AssistantMessage has tool-call
- * blocks stripped so the agent loop ends the turn without local dispatch.
+ * (thinking, text, tool calls). The final AssistantMessage preserves
+ * SDK-executed tool-call blocks for Agent Core's `externalToolExecution`
+ * path, which renders the results without dispatching the tools locally.
  */
 export function streamViaClaudeCode(model, context, options) {
     const stream = createAssistantStream();
@@ -910,9 +947,8 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
-                            else if (block.type === "toolCall") {
+                            else if (block.type === "toolCall" || block.type === "serverToolUse") {
                                 // Collect tool blocks for externalToolExecution rendering
-                                // (serverToolUse removed from pi-ai content types in pi 0.67.2)
                                 intermediateToolBlocks.push(block);
                             }
                         }
@@ -944,7 +980,13 @@ async function pumpSdkMessages(model, context, options, stream) {
                                     partial: builder.message,
                                 });
                             }
-                            // serverToolUse/server_tool_use removed from pi-ai in pi 0.67.2
+                            else if (block.type === "serverToolUse") {
+                                stream.push({
+                                    type: "server_tool_use",
+                                    contentIndex,
+                                    partial: builder.message,
+                                });
+                            }
                         }
                     }
                     builder = null;
@@ -953,42 +995,14 @@ async function pumpSdkMessages(model, context, options, stream) {
                 // -- Result (terminal) --
                 case "result": {
                     const result = msg;
-                    // Build final message. Include intermediate tool calls so the
-                    // agent loop's externalToolExecution path emits tool_execution
-                    // events for proper TUI rendering, followed by the text response.
-                    const finalContent = [];
-                    // If the final turn ended without a synthetic user message
-                    // (e.g. stop_reason: "tool_use" followed directly by result,
-                    // or a turn with text but no tool execution), the `builder`
-                    // still holds toolCall blocks that were never pushed into
-                    // `intermediateToolBlocks`. Fold them in here so they aren't
-                    // dropped from the final AssistantMessage.
-                    if (builder) {
-                        mergePendingToolCalls(intermediateToolBlocks, builder.message.content);
-                    }
-                    // Add tool calls from intermediate turns first (renders above text)
-                    attachExternalResultsToToolBlocks(intermediateToolBlocks, toolResultsById);
-                    finalContent.push(...intermediateToolBlocks);
-                    // Add text/thinking from the last turn
-                    if (builder && builder.message.content.length > 0) {
-                        for (const block of builder.message.content) {
-                            if (block.type === "text" || block.type === "thinking") {
-                                finalContent.push(block);
-                            }
-                        }
-                    }
-                    else {
-                        if (lastThinkingContent) {
-                            finalContent.push({ type: "thinking", thinking: lastThinkingContent });
-                        }
-                        if (lastTextContent) {
-                            finalContent.push({ type: "text", text: lastTextContent });
-                        }
-                    }
-                    // Fallback: use the SDK's result text if we have no content
-                    if (finalContent.length === 0 && result.subtype === "success" && result.result) {
-                        finalContent.push({ type: "text", text: result.result });
-                    }
+                    const finalContent = buildFinalAssistantContent({
+                        intermediateToolBlocks,
+                        pendingContent: builder?.message.content,
+                        toolResultsById,
+                        lastThinkingContent,
+                        lastTextContent,
+                        fallbackResultText: result.subtype === "success" && result.result ? result.result : undefined,
+                    });
                     const finalMessage = {
                         role: "assistant",
                         content: finalContent,

package/dist/resources/extensions/cmux/index.js

@@ -1,5 +1,6 @@
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { CMUX_CHANNELS } from "../shared/cmux-events.js";
 const DEFAULT_SOCKET_PATH = "/tmp/cmux.sock";
 const STATUS_KEY = "gsd";
 const lastSidebarSnapshots = new Map();
@@ -382,3 +383,22 @@ function extractSurfaceIds(value) {
     visit(value);
     return Array.from(found);
 }
+/**
+ * Wire event subscriptions so cmux reacts to gsd events.
+ * Called by the gsd extension during registration, passing pi.events.
+ */
+export function initCmuxEventListeners(events) {
+    events.on(CMUX_CHANNELS.SIDEBAR, (data) => {
+        const event = data;
+        if (event.action === "sync" && event.state) {
+            syncCmuxSidebar(event.preferences, event.state);
+        }
+        if (event.action === "clear") {
+            clearCmuxSidebar(event.preferences);
+        }
+    });
+    events.on(CMUX_CHANNELS.LOG, (data) => {
+        const event = data;
+        logCmuxEvent(event.preferences, event.message, event.level);
+    });
+}