gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

package/dist/loader.js

@@ -3,7 +3,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join, relative, delimiter } from 'path';
-import { existsSync, readFileSync, mkdirSync, symlinkSync, cpSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, symlinkSync, cpSync } from 'fs';
 // Fast-path: handle --version/-v and --help/-h before importing any heavy
 // dependencies. This avoids loading the entire pi-coding-agent barrel import
 // (~1s) just to print a version string.
@@ -155,15 +155,42 @@ if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy
 // On Windows without Developer Mode or admin rights, symlinkSync will throw even for
 // 'junction' type — so we fall back to cpSync (a full directory copy) which works
 // everywhere without elevated permissions.
-const gsdScopeDir = join(gsdNodeModules, '@gsd');
+// Discover linkable workspace packages by scanning packages/*/package.json for
+// `gsd.linkable === true`. This is the single source of truth — the same list
+// read by scripts/link-workspace-packages.cjs and scripts/validate-pack.js.
+// Adding a new linkable package requires only setting `gsd.linkable` in its
+// package.json; there is no enumeration to keep in sync here.
 const packagesDir = join(gsdRoot, 'packages');
-const wsPackages = ['native', 'pi-agent-core', 'pi-ai', 'pi-coding-agent', 'pi-tui'];
+const wsPackages = [];
+try {
+    if (existsSync(packagesDir)) {
+        for (const dir of readdirSync(packagesDir)) {
+            const pkgPath = join(packagesDir, dir);
+            if (!statSync(pkgPath).isDirectory())
+                continue;
+            const pkgJsonPath = join(pkgPath, 'package.json');
+            if (!existsSync(pkgJsonPath))
+                continue;
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                const gsd = pkg.gsd;
+                if (!gsd || gsd.linkable !== true)
+                    continue;
+                if (gsd.scope && gsd.name)
+                    wsPackages.push({ dir, scope: gsd.scope, name: gsd.name });
+            }
+            catch { /* ignore malformed package.json */ }
+        }
+    }
+}
+catch { /* non-fatal — validation below catches missing critical packages */ }
 try {
-    if (!existsSync(gsdScopeDir))
-        mkdirSync(gsdScopeDir, { recursive: true });
     for (const pkg of wsPackages) {
-        const target = join(gsdScopeDir, pkg);
-        const source = join(packagesDir, pkg);
+        const scopeDir = join(gsdNodeModules, pkg.scope);
+        if (!existsSync(scopeDir))
+            mkdirSync(scopeDir, { recursive: true });
+        const target = join(scopeDir, pkg.name);
+        const source = join(packagesDir, pkg.dir);
         if (!existsSync(source) || existsSync(target))
             continue;
         try {
@@ -180,6 +207,7 @@ try {
     }
 }
 catch { /* non-fatal */ }
+const gsdScopeDir = join(gsdNodeModules, '@gsd');
 // Validate critical workspace packages are resolvable. If still missing after the
 // symlink+copy attempts, emit a clear diagnostic instead of a cryptic
 // ERR_MODULE_NOT_FOUND from deep inside cli.js.

package/dist/mcp-server.d.ts

@@ -1,6 +1,11 @@
 /**
  * Minimal tool interface matching GSD's AgentTool shape.
  * Avoids a direct dependency on @gsd/pi-agent-core from this compiled module.
+ *
+ * `details` and `isError` are optional fields that runtime tool implementations
+ * may populate. The MCP transport drops non-standard fields, so the wrapper at
+ * the call site mirrors `details` into `structuredContent` and forwards
+ * `isError` directly. See #4472.
  */
 export interface McpToolDef {
     name: string;
@@ -13,6 +18,8 @@ export interface McpToolDef {
             data?: string;
             mimeType?: string;
         }>;
+        details?: Record<string, unknown>;
+        isError?: boolean;
     }>;
 }
 /**

package/dist/mcp-server.js

@@ -1,3 +1,21 @@
+/**
+ * Strict plain-object guard. True only for object literals and
+ * `Object.create(null)` — not for `Date`, `URL`, `Map`, `Set`, class instances,
+ * or arrays. Used to gate `structuredContent` forwarding so the MCP transport
+ * receives only true JSON objects (the protocol contract). See #4477 review.
+ *
+ * Mirrored in `packages/mcp-server/src/workflow-tools.ts` for the
+ * `adaptExecutorResult` adapter on the workflow path. Keep both copies in
+ * sync if the contract definition needs to evolve.
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
 // MCP SDK subpath imports use wildcard exports (./*) in @modelcontextprotocol/sdk's
 // package.json export map. The wildcard maps "./foo" → "./dist/cjs/foo" (no .js
 // suffix), so bare subpath specifiers like `${MCP_PKG}/server/stdio` resolve to
@@ -83,7 +101,23 @@ export async function startMcpServer(options) {
                 // by stringifying into a text block so clients see the payload.
                 return { type: 'text', text: JSON.stringify(block) };
             });
-            return { content };
+            // Forward a tool's runtime `details` field to MCP's `structuredContent`
+            // channel. The protocol drops non-standard fields on the wire, so tools
+            // that populate `details` for client-side renderers (e.g. save_gate_result)
+            // would otherwise arrive empty on the other side. See #4472.
+            //
+            // Use a strict plain-object guard (prototype-chain check) rather than just
+            // `typeof === 'object' && !Array.isArray()` — Date, URL, Map, Set, and
+            // class instances would otherwise pass through and end up as
+            // `structuredContent`, violating the protocol's JSON-object contract.
+            // The mirror discipline applies in `workflow-tools.ts adaptExecutorResult`.
+            const base = { content };
+            if (isPlainObject(result.details)) {
+                base.structuredContent = result.details;
+            }
+            if (result.isError === true)
+                base.isError = true;
+            return base;
         }
         catch (err) {
             // AbortError from a cancelled tool surfaces as a normal error — MCP

package/dist/onboarding.js

@@ -60,6 +60,8 @@ const OTHER_PROVIDERS = [
     { value: 'xai', label: 'xAI (Grok)', hint: 'console.x.ai' },
     { value: 'openrouter', label: 'OpenRouter', hint: '200+ models — openrouter.ai/keys' },
     { value: 'mistral', label: 'Mistral', hint: 'console.mistral.ai/api-keys' },
+    { value: 'minimax', label: 'MiniMax', hint: 'platform.minimax.io (Anthropic-compatible recommended)' },
+    { value: 'minimax-cn', label: 'MiniMax CN', hint: 'api.minimaxi.com (Anthropic-compatible)' },
     { value: 'ollama-cloud', label: 'Ollama Cloud' },
     { value: 'custom-openai', label: 'Custom (OpenAI-compatible)', hint: 'Ollama, LM Studio, vLLM, proxies — see docs/providers.md' },
 ];
@@ -131,6 +133,36 @@ function persistDefaultProvider(providerId) {
         // Non-fatal: startup fallback logic will still run.
     }
 }
+/**
+ * Persist the selected default model to settings.json.
+ */
+function persistDefaultModel(modelId) {
+    const settingsPath = join(agentDir, 'settings.json');
+    try {
+        const raw = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, 'utf-8')) : {};
+        raw.defaultModel = modelId;
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify(raw, null, 2), 'utf-8');
+    }
+    catch {
+        // Non-fatal: startup fallback logic will still run.
+    }
+}
+function detectNativeProviderFromBaseUrl(baseUrl) {
+    try {
+        const hostname = new URL(baseUrl).hostname.toLowerCase();
+        if (hostname === 'api.minimax.io' || hostname.endsWith('.minimax.io')) {
+            return 'minimax';
+        }
+        if (hostname === 'api.minimaxi.com' || hostname.endsWith('.minimaxi.com')) {
+            return 'minimax-cn';
+        }
+    }
+    catch {
+        // ignore parse failures; handled by prior validation
+    }
+    return null;
+}
 /** Sentinel returned by runStep when the user cancels — tells the caller
  *  to abort the entire wizard. */
 const STEP_CANCELLED = Symbol('step-cancelled');
@@ -558,9 +590,22 @@ async function runCustomOpenAIFlow(p, pc, authStorage) {
     if (p.isCancel(modelId) || !modelId)
         return false;
     const trimmedModelId = modelId.trim();
+    const nativeProvider = detectNativeProviderFromBaseUrl(trimmedUrl);
+    if (nativeProvider) {
+        const envVar = nativeProvider === 'minimax' ? 'MINIMAX_API_KEY' : 'MINIMAX_CN_API_KEY';
+        authStorage.set(nativeProvider, { type: 'api_key', key: trimmedKey });
+        persistDefaultProvider(nativeProvider);
+        persistDefaultModel(trimmedModelId);
+        process.env[envVar] = trimmedKey;
+        p.log.success(`${pc.green('MiniMax')} detected — configured as native provider (${pc.cyan(nativeProvider)})`);
+        p.log.info(`Model: ${pc.cyan(trimmedModelId)}`);
+        p.log.info(pc.dim('Using Anthropic-compatible MiniMax integration for full model metadata and clean thinking output.'));
+        return true;
+    }
     // Save API key to auth storage
     authStorage.set('custom-openai', { type: 'api_key', key: trimmedKey });
     persistDefaultProvider('custom-openai');
+    persistDefaultModel(trimmedModelId);
     // Write or merge into models.json
     const modelsJsonPath = join(agentDir, 'models.json');
     let config = { providers: {} };

package/dist/provider-migrations.d.ts

@@ -5,6 +5,24 @@ type AnthropicMigrationDeps = {
     defaultProvider: string | undefined;
     env?: NodeJS.ProcessEnv;
 };
+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

@@ -10,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/resource-loader.d.ts

@@ -21,6 +21,6 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export declare function initResources(agentDir: string): void;
+export declare function initResources(agentDir: string, skillsDir?: string): void;
 export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -506,7 +506,7 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
-export function initResources(agentDir) {
+export function initResources(agentDir, skillsDir = join(homedir(), '.agents', 'skills')) {
     mkdirSync(agentDir, { recursive: true });
     const currentVersion = getBundledGsdVersion();
     const manifest = readManagedResourceManifest(agentDir);
@@ -538,13 +538,7 @@ export function initResources(agentDir) {
     // Sync bundled resources — overwrite so updates land on next launch.
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
-    // Skills are no longer force-synced here. Users install skills via the
-    // skills.sh CLI (`npx skills add <repo>`) into ~/.agents/skills/ which
-    // is the industry-standard Agent Skills ecosystem directory.
-    //
-    // Migration from the legacy ~/.gsd/agent/skills/ directory is handled
-    // above the manifest check so it runs on every launch (including retries
-    // after partial copy failures).
+    syncResourceDir(join(resourcesDir, 'skills'), skillsDir);
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
     // env var is not set (e.g. fork/dev builds, alternative entry points).
     const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');

package/dist/resources/agents/researcher.md

@@ -1,7 +1,7 @@
 ---
 name: researcher
 description: Web researcher that finds and synthesizes current information using Brave Search
-tools: search-the-web, bash
+tools: search-the-web, bash, capture_thought, memory_query, gsd_graph
 ---
 
 You are a web researcher. You find current, accurate information using web search and synthesize it into a clear, well-structured report.

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

@@ -10,15 +10,38 @@
  */
 import { execFileSync } from "node:child_process";
 /**
- * Platform-correct binary name for the Claude Code CLI.
+ * Candidate executable names for the Claude Code CLI.
  *
- * On Windows, npm-global binaries are installed as `.cmd` shims and
- * `execFileSync` does not auto-resolve the extension — calling bare
- * `claude` would fail with ENOENT even when the CLI is installed and
- * authenticated. Mirrors the `NPM_COMMAND` pattern in
- * `src/resources/extensions/gsd/pre-execution-checks.ts`.
+ * Keep the explicit win32 ternary selector for regression coverage (Issue #4424):
+ * Node's execFileSync must target `claude.cmd` directly on Windows.
  */
 const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
+/**
+ * Windows installs vary: some environments expose `claude.cmd` (npm shim),
+ * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
+ * (for example Git Bash wrappers). Try all three to avoid false "not
+ * installed" results in readiness checks.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
+function execClaude(args) {
+    let lastError;
+    for (const command of CLAUDE_COMMAND_CANDIDATES) {
+        try {
+            return execFileSync(command, args, { timeout: 5_000, stdio: "pipe" });
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            // Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
+            // of ENOENT. Treat both as "try next candidate".
+            if (code === "ENOENT" || code === "EINVAL") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
+}
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
@@ -32,7 +55,7 @@ function refreshCache() {
     lastCheckMs = now;
     // Check binary presence
     try {
-        execFileSync(CLAUDE_COMMAND, ["--version"], { timeout: 5_000, stdio: "pipe" });
+        execClaude(["--version"]);
         cachedBinaryPresent = true;
     }
     catch {
@@ -42,7 +65,7 @@ function refreshCache() {
     }
     // Check auth status — exit code 0 with non-error output means authenticated
     try {
-        const output = execFileSync(CLAUDE_COMMAND, ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+        const output = execClaude(["auth", "status"])
             .toString()
             .toLowerCase();
         // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated

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";
@@ -484,24 +485,32 @@ export function makeAbortedMessage(model, lastTextContent) {
 /**
  * Resolve the Claude Code permission mode for the current run.
  *
- * GSD subagents run underneath a host Claude Code session the user has
- * already consented to, and their work (edits, shell inspection, MCP calls)
- * spans the full workflow toolset. Defaulting the inner SDK to
- * `bypassPermissions` avoids per-tool approval prompts that offer no
- * meaningful safety beyond what the host session and the subagent prompts
- * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
- * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ * Defaults to `acceptEdits`, which auto-approves file reads/edits but
+ * surfaces a permission dialog for dangerous operations (e.g. general Bash,
+ * Agent, WebFetch). This prevents tools outside the allowlist from being
+ * silently denied — the SDK emits an `extension_ui_request` event so the
+ * user sees a prompt instead of a silent refusal that Claude Code mistakes
+ * for user rejection (#4383).
  *
- * Tradeoff: bypass means a prompt-injection payload read from an untrusted
- * file could trigger tool calls without a second gate. Accepted for GSD
- * because the workflow is explicit user intent and the alternative
- * (#4099) is continuous approval fatigue that blocks real work.
+ * Set `GSD_CLAUDE_CODE_PERMISSION_MODE` to `bypassPermissions` to restore
+ * the old always-approve behaviour, or to `default` / `plan` for stricter
+ * modes.
+ *
+ * When `GSD_HEADLESS=1` is set (auto-mode / non-interactive runs), the
+ * default flips to `bypassPermissions` because there is no UI to approve
+ * permission dialogs — `acceptEdits` would hang verification commands like
+ * `npx tsc --noEmit` or `npx vitest run` indefinitely (#4657). Explicit
+ * overrides still win, so users can opt back into `acceptEdits` in headless.
  */
 export async function resolveClaudePermissionMode(env = process.env) {
     const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
     if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
         return override;
     }
+    if (env.GSD_HEADLESS === "1") {
+        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 "bypassPermissions";
 }
 // NOTE: These helpers intentionally mirror @gsd/pi-ai anthropic-shared
@@ -555,20 +564,24 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
-    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).
+    // 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);
@@ -637,6 +650,68 @@ function normalizeToolResultContent(content) {
     }
     return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
 }
+/**
+ * Extract a `details` payload from an MCP tool-result block.
+ *
+ * MCP's `CallToolResult` carries structured data in `structuredContent` — the
+ * protocol's supported channel for non-text payloads. Claude Code's synthetic
+ * user message may surface that field in one of two shapes depending on SDK
+ * version: as a sibling on the `mcp_tool_result` block itself, or as a
+ * dedicated content sub-block with `type: "structuredContent"`. Snake-case
+ * (`structured_content`) is accepted defensively in case a transport hop
+ * rewrites casing. All other shapes fall back to an empty object so callers
+ * can rely on `details` being present.
+ */
+function extractStructuredDetailsFromBlock(block) {
+    const sibling = block.structuredContent ?? block.structured_content;
+    if (sibling && typeof sibling === "object" && !Array.isArray(sibling)) {
+        return sibling;
+    }
+    if (Array.isArray(block.content)) {
+        for (const item of block.content) {
+            if (!item || typeof item !== "object")
+                continue;
+            const sub = item;
+            if (sub.type !== "structuredContent" && sub.type !== "structured_content")
+                continue;
+            const payload = sub.structuredContent ?? sub.structured_content ?? sub.data ?? sub.value;
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                return payload;
+            }
+        }
+    }
+    // Return undefined (not {}) when no structured payload is present, matching
+    // the pre-#4477 contract where `details` was nullable. An empty-object
+    // sentinel is truthy and breaks downstream consumers that gate on
+    // `if (details)`. `undefined` matches the type of the field these results
+    // flow into (`Record<string, unknown> | undefined`).
+    return undefined;
+}
+/**
+ * True for items that are MCP `structuredContent` pseudo-blocks living inside
+ * a tool-result `content[]` array. These blocks carry the structured payload
+ * (extracted separately by `extractStructuredDetailsFromBlock`) and must NOT
+ * leak into the visible content rendered to the user — otherwise the renderer
+ * stringifies the JSON pseudo-block and shows it next to the actual tool
+ * output. See PR #4477 review (CodeRabbit, post-fix-round).
+ */
+function isStructuredContentPseudoBlock(item) {
+    if (!item || typeof item !== "object")
+        return false;
+    const type = item.type;
+    return type === "structuredContent" || type === "structured_content";
+}
+/**
+ * Strip `structuredContent` pseudo-blocks from a tool-result content array
+ * before normalization. The structured payload is extracted via the sibling
+ * `structuredContent` field (or a dedicated extractor pass on the raw block);
+ * the visible content path must not include the pseudo-block itself.
+ */
+function stripStructuredContentPseudoBlocks(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content.filter((item) => !isStructuredContentPseudoBlock(item));
+}
 /** Extract tool result payloads from an SDK synthetic user message, keyed by tool-use ID. */
 export function extractToolResultsFromSdkUserMessage(message) {
     const extracted = [];
@@ -657,8 +732,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
         extracted.push({
             toolUseId,
             result: {
-                content: normalizeToolResultContent(block.content),
-                details: {},
+                content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(block.content)),
+                details: extractStructuredDetailsFromBlock(block),
                 isError: block.is_error === true,
             },
         });
@@ -672,8 +747,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
                 extracted.push({
                     toolUseId,
                     result: {
-                        content: normalizeToolResultContent(toolResult.content),
-                        details: {},
+                        content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(toolResult.content)),
+                        details: extractStructuredDetailsFromBlock(toolResult),
                         isError: toolResult.is_error === true,
                     },
                 });
@@ -693,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
@@ -722,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();
@@ -886,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,