gsd-pi 2.70.1 → 2.71.0-dev.06b86c6

package/README.md

@@ -27,36 +27,43 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.68
+## What's New in v2.71
 
-### MCP Workflow Tools
+### MCP Secure Env Collect
 
-- **Full workflow over MCP** — slice replanning, milestone management, slice completion, task completion, and core planning tools are now exposed over MCP for external integrations.
-- **Transport-gated MCP** — workflow tool availability adapts to provider transport capabilities automatically.
-- **Write gate enforcement** — workflow MCP respects write gates, preventing unauthorized state mutations from external clients.
+- **Secure credential collection over MCP** — the new `secure_env_collect` tool uses MCP form elicitation to collect secrets (API keys, tokens) from external clients without exposing values in tool output. Masks input in interactive mode.
+- **Hardened elicitation schema** — MCP elicitation schema handling is stricter, with proper validation and fallback for providers that don't support forms.
 
-### Reliability & Recovery
+### MCP Reliability
 
-- **False degraded-mode fix** — eliminates spurious degraded-mode warnings when the DB hasn't been initialized yet.
-- **Stale session resume suppression** — prevents stale interrupted-session resume prompts from hijacking fresh sessions.
-- **Merge conflict recovery** — `autoCommitDirtyState` guarded with cwd restore on `MergeConflictError`.
-- **Auto-resume hardening** — `autoStartTime` restored on resume, managed resources resynced on auto resume.
+- **Stream ordering preserved** — MCP tool output now renders in the correct order, fixing interleaved output in Claude Code and other MCP clients.
+- **isError flag propagation** — workflow tool execution failures now correctly return `isError: true`, so MCP clients can distinguish success from failure.
+- **Multi-round discuss questions** — new-project discuss phase supports multi-round questioning with structured question gates.
 
-### TUI & Developer Experience
+### TUI Fixes
 
-- **Contextual tips system** — TUI and web terminal now surface contextual tips based on workflow state.
-- **Claude Code MCP streaming** — real-time streaming and tool output rendering for Claude Code MCP connections.
+- **Pinned output restored** — pinned output bar displays above the editor during tool execution again.
+- **Turn completion cleanup** — pinned latest output is cleared on turn completion, preventing stale output from persisting.
+- **Secure input masking** — extension input values are masked in interactive mode when collecting secrets.
 
-### Infrastructure
+### Reliability & Internals
 
-- **Weekly model registry refresh** — CI workflow auto-regenerates the model registry on a weekly schedule.
-- **Codebase cache auto-refresh** — stale codebase cache is refreshed automatically without manual intervention.
+- **TOCTOU file locking** — race conditions in event log and custom workflow graph file locking are fixed with proper atomic lock acquisition.
+- **State derive refactor** — `deriveStateFromDb` god function extracted into composable, testable helpers.
+- **Windows portability** — hardened cross-platform portability across runtime, tooling, and CI.
+- **Model routing transparency** — dynamic routing is skipped for interactive dispatches; model changes are always shown in the banner.
+- **Capability-aware routing (ADR-004)** — full implementation of capability scoring, `before_model_select` hook, and task metadata extraction.
+- **Multi-model provider strategy (ADR-005)** — infrastructure for multi-provider model selection wired into live paths.
 
 See the full [Changelog](./CHANGELOG.md) for details on every release.
 
 <details>
-<summary>Previous highlights (v2.67 and earlier)</summary>
+<summary>Previous highlights (v2.70 and earlier)</summary>
 
+- **Full workflow over MCP (v2.68)** — slice replanning, milestone management, slice completion, task completion, and core planning tools exposed over MCP
+- **Transport-gated MCP (v2.68)** — workflow tool availability adapts to provider transport capabilities automatically
+- **Contextual tips system (v2.68)** — TUI and web terminal surface contextual tips based on workflow state
+- **Ask user questions over MCP (v2.70)** — interactive questions exposed via elicitation for external integrations
 - **Tiered Context Injection (M005)** — relevance-scoped context with 65%+ token reduction
 - **Resilient transient error recovery** — defers to Core RetryHandler and fixes cmdCtx race conditions
 - **Anthropic subscription routing** — auto-routed through Claude Code CLI provider with proper display names

package/dist/cli.js

@@ -7,6 +7,7 @@ import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys } from './wizard.js';
 import { migratePiCredentials } from './pi-migration.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
+import { shouldMigrateAnthropicToClaudeCode } from './provider-migrations.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
@@ -285,7 +286,7 @@ const { resolveModelsJsonPath } = await import('./models-resolver.js');
 const modelsJsonPath = resolveModelsJsonPath();
 const modelRegistry = new ModelRegistry(authStorage, modelsJsonPath);
 markStartup('ModelRegistry');
-const settingsManager = SettingsManager.create(agentDir);
+const settingsManager = SettingsManager.create(process.cwd(), agentDir);
 applySecurityOverrides(settingsManager);
 markStartup('SettingsManager.create');
 // Run onboarding wizard on first launch (no LLM provider configured)
@@ -401,7 +402,11 @@ if (isPrintMode) {
     // Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
     // Anthropic blocks third-party apps from using subscription quotas — routing through
     // the local claude CLI binary is TOS-compliant.
-    if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+    if (shouldMigrateAnthropicToClaudeCode({
+        authStorage,
+        isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
+        defaultProvider: settingsManager.getDefaultProvider(),
+    })) {
         const currentModelId = settingsManager.getDefaultModel();
         if (currentModelId) {
             const ccModel = modelRegistry.find('claude-code', currentModelId);
@@ -576,7 +581,11 @@ markStartup('createAgentSession');
 // Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
 // Anthropic blocks third-party apps from using subscription quotas — routing through
 // the local claude CLI binary is TOS-compliant.
-if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+if (shouldMigrateAnthropicToClaudeCode({
+    authStorage,
+    isClaudeCodeReady: modelRegistry.isProviderRequestReady('claude-code'),
+    defaultProvider: settingsManager.getDefaultProvider(),
+})) {
     const currentModelId = settingsManager.getDefaultModel();
     if (currentModelId) {
         const ccModel = modelRegistry.find('claude-code', currentModelId);

package/dist/mcp-server.js

@@ -1,10 +1,10 @@
 // MCP SDK subpath imports use wildcard exports (./*) that NodeNext resolves
 // at runtime but TypeScript cannot statically type-check. We construct the
 // specifiers dynamically so tsc treats them as `any`.
-// Use createRequire to resolve wildcard subpaths — CJS resolver auto-appends
-// .js, which the ESM wildcard export map does not (#3603).
-import { createRequire } from 'node:module';
-const _require = createRequire(import.meta.url);
+//
+// Use explicit .js subpaths for modules that are loaded dynamically at runtime.
+// Recent Node / SDK combinations do not reliably resolve the extensionless
+// wildcard targets for `server/stdio` and `types` (#3914).
 const MCP_PKG = '@modelcontextprotocol/sdk';
 /**
  * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
@@ -23,8 +23,8 @@ const MCP_PKG = '@modelcontextprotocol/sdk';
 export async function startMcpServer(options) {
     const { tools, version = '0.0.0' } = options;
     const serverMod = await import(`${MCP_PKG}/server`);
-    const stdioMod = await import(_require.resolve(`${MCP_PKG}/server/stdio`));
-    const typesMod = await import(_require.resolve(`${MCP_PKG}/types`));
+    const stdioMod = await import(`${MCP_PKG}/server/stdio.js`);
+    const typesMod = await import(`${MCP_PKG}/types.js`);
     const Server = serverMod.Server;
     const StdioServerTransport = stdioMod.StdioServerTransport;
     const { ListToolsRequestSchema, CallToolRequestSchema } = typesMod;

package/dist/provider-migrations.d.ts

@@ -0,0 +1,10 @@
+import type { AuthStorage } from "@gsd/pi-coding-agent";
+type AnthropicMigrationDeps = {
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
+    isClaudeCodeReady: boolean;
+    defaultProvider: string | undefined;
+    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 {};

package/dist/provider-migrations.js

@@ -0,0 +1,12 @@
+export function hasDirectAnthropicApiKey(authStorage, env = process.env) {
+    if ((env.ANTHROPIC_API_KEY ?? "").trim()) {
+        return true;
+    }
+    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") {
+        return false;
+    }
+    return !hasDirectAnthropicApiKey(authStorage, env);
+}

package/dist/resource-loader.js

@@ -2,7 +2,7 @@ import { DefaultResourceLoader, sortExtensionPaths } from '@gsd/pi-coding-agent'
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
@@ -254,34 +254,157 @@ function copyDirRecursive(src, dest) {
  * ~/.gsd/agent/extensions/ have no ancestor node_modules, so imports of
  * @gsd/* packages fail. The symlink makes Node's standard resolution find
  * them without requiring every call site to use jiti.
+ *
+ * Layout differences by install method:
+ * - Source/monorepo: packageRoot/node_modules has everything → simple symlink
+ * - npm/bun global: deps hoisted to dirname(packageRoot), including @gsd/* → simple symlink
+ * - pnpm global: external deps hoisted, but @gsd/* stays in packageRoot/node_modules
+ *   → merged directory with symlinks from both roots (#3529, #3564)
  */
 function ensureNodeModulesSymlink(agentDir) {
     const agentNodeModules = join(agentDir, 'node_modules');
-    const gsdNodeModules = join(packageRoot, 'node_modules');
+    const internalNodeModules = join(packageRoot, 'node_modules');
+    const hoistedNodeModules = dirname(packageRoot);
+    const isGlobalInstall = basename(hoistedNodeModules) === 'node_modules';
+    if (!isGlobalInstall) {
+        // Source/monorepo: internal node_modules has everything
+        reconcileSymlink(agentNodeModules, internalNodeModules);
+        return;
+    }
+    // Global install: check if workspace scopes (@gsd/*) are hoisted.
+    // npm/bun hoist everything; pnpm keeps workspace packages internal.
+    if (!hasMissingWorkspaceScopes(hoistedNodeModules, internalNodeModules)) {
+        // Everything is hoisted — simple symlink to parent node_modules
+        reconcileSymlink(agentNodeModules, hoistedNodeModules);
+        return;
+    }
+    // pnpm-style layout: create a real directory merging both roots
+    reconcileMergedNodeModules(agentNodeModules, hoistedNodeModules, internalNodeModules);
+}
+/** Check if any @gsd* scopes exist in internal but not in hoisted node_modules */
+function hasMissingWorkspaceScopes(hoisted, internal) {
+    if (!existsSync(internal))
+        return false;
     try {
-        const stat = lstatSync(agentNodeModules);
+        for (const entry of readdirSync(internal, { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name.startsWith('@gsd') &&
+                !existsSync(join(hoisted, entry.name))) {
+                return true;
+            }
+        }
+    }
+    catch { /* non-fatal */ }
+    return false;
+}
+/** Ensure a symlink at `link` points to `target`, fixing stale/wrong entries */
+function reconcileSymlink(link, target) {
+    try {
+        const stat = lstatSync(link);
         if (stat.isSymbolicLink()) {
-            const existing = readlinkSync(agentNodeModules);
-            // Symlink exists — verify it points to the correct, existing target
-            if (existing === gsdNodeModules && existsSync(agentNodeModules))
+            const existing = readlinkSync(link);
+            if (existing === target && existsSync(link))
                 return; // correct and target exists
-            // Stale or wrong target — remove and recreate
+            unlinkSync(link);
+        }
+        else {
+            // Real directory (or merged dir from previous pnpm fix) — remove it
+            rmSync(link, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // lstatSync throws if path doesn't exist — fine, we'll create below
+    }
+    try {
+        symlinkSync(target, link, 'junction');
+    }
+    catch (err) {
+        console.error(`[gsd] WARN: Failed to symlink ${link} → ${target}: ${err instanceof Error ? err.message : err}`);
+    }
+}
+/**
+ * Create a real node_modules directory containing symlinks from both the
+ * hoisted root (external deps) and internal root (@gsd/* workspace packages).
+ * Used for pnpm global installs where @gsd/* isn't hoisted.
+ */
+function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
+    // Fast path: if already merged for this packageRoot + same directory contents, skip.
+    // The fingerprint includes entry names from both roots so `pnpm add/remove` triggers rebuild.
+    const marker = join(agentNodeModules, '.gsd-merged');
+    const fingerprint = mergedFingerprint(hoisted, internal);
+    try {
+        if (existsSync(marker) && readFileSync(marker, 'utf-8').trim() === fingerprint)
+            return;
+    }
+    catch { /* rebuild */ }
+    // Remove any existing symlink or stale merged directory
+    try {
+        const stat = lstatSync(agentNodeModules);
+        if (stat.isSymbolicLink()) {
             unlinkSync(agentNodeModules);
         }
         else {
-            // Real directory (not a symlink) is blocking — remove it
             rmSync(agentNodeModules, { recursive: true, force: true });
         }
     }
-    catch {
-        // lstatSync throws if path doesn't exist — that's fine, we'll create below
+    catch { /* doesn't exist */ }
+    mkdirSync(agentNodeModules, { recursive: true });
+    let linkedCount = 0;
+    // Symlink entries from the hoisted node_modules (external deps)
+    try {
+        for (const entry of readdirSync(hoisted, { withFileTypes: true })) {
+            // Skip the gsd-pi package itself and dotfiles
+            if (entry.name === basename(packageRoot))
+                continue;
+            if (entry.name.startsWith('.'))
+                continue;
+            try {
+                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name));
+                linkedCount++;
+            }
+            catch { /* skip individual */ }
+        }
     }
+    catch (err) {
+        console.error(`[gsd] WARN: Failed to read hoisted node_modules at ${hoisted}: ${err instanceof Error ? err.message : err}`);
+    }
+    // Overlay @gsd* workspace scopes from internal node_modules
     try {
-        symlinkSync(gsdNodeModules, agentNodeModules, 'junction');
+        for (const entry of readdirSync(internal, { withFileTypes: true })) {
+            if (!entry.name.startsWith('@gsd'))
+                continue;
+            const link = join(agentNodeModules, entry.name);
+            try {
+                lstatSync(link);
+                unlinkSync(link);
+            }
+            catch { /* didn't exist */ }
+            try {
+                symlinkSync(join(internal, entry.name), link);
+                linkedCount++;
+            }
+            catch { /* skip individual */ }
+        }
     }
     catch (err) {
-        // This failure makes GSD non-functional — extensions can't resolve @gsd/* packages
-        console.error(`[gsd] WARN: Failed to symlink ${agentNodeModules} → ${gsdNodeModules}: ${err instanceof Error ? err.message : err}`);
+        console.error(`[gsd] WARN: Failed to read internal node_modules at ${internal}: ${err instanceof Error ? err.message : err}`);
+    }
+    // Only stamp marker if we actually linked something — avoids caching a broken state
+    if (linkedCount > 0) {
+        try {
+            writeFileSync(marker, fingerprint);
+        }
+        catch { /* non-fatal */ }
+    }
+}
+/** Build a cache fingerprint from packageRoot + sorted entry names of both directories */
+function mergedFingerprint(hoisted, internal) {
+    try {
+        const h = readdirSync(hoisted).sort().join(',');
+        const i = readdirSync(internal).sort().join(',');
+        return `${packageRoot}\n${h}\n${i}`;
+    }
+    catch {
+        return packageRoot; // fallback: at least invalidate on version change
     }
 }
 /**

package/dist/resources/GSD-WORKFLOW.md

@@ -275,7 +275,7 @@ Work flows through these phases. Each phase produces a file.
 **How to do it manually:**
 1. Read the roadmap to understand the scope.
 2. Identify 3-5 gray areas — implementation decisions the user cares about.
-3. Use `ask_user_questions` to discuss each area.
+3. Use `ask_user_questions` to discuss each area, one round at a time. Never fabricate user input; wait for the user's actual response before the next round.
 4. Write decisions to the appropriate context file (`M###-CONTEXT.md` or `S##-CONTEXT.md`).
 5. Do NOT discuss how to implement — only what the user wants.
 

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

@@ -12,6 +12,7 @@ import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.j
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 import { showInterviewRound } from "../shared/tui.js";
 const OTHER_OPTION_LABEL = "None of the above";
+const SENSITIVE_FIELD_PATTERN = /(password|passphrase|secret|token|api[_\s-]*key|private[_\s-]*key|credential)/i;
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -182,6 +183,56 @@ export function parseAskUserQuestionsElicitation(request) {
     }
     return questions.length > 0 ? questions : null;
 }
+function isSecureElicitationField(requestMessage, fieldId, field) {
+    if (field.format === "password")
+        return true;
+    if (field.writeOnly === true)
+        return true;
+    const rawField = field;
+    if (rawField.sensitive === true || rawField["x-sensitive"] === true)
+        return true;
+    const haystack = [
+        requestMessage,
+        fieldId.replace(/[_-]+/g, " "),
+        typeof field.title === "string" ? field.title : "",
+        typeof field.description === "string" ? field.description : "",
+    ]
+        .join(" ")
+        .toLowerCase();
+    return SENSITIVE_FIELD_PATTERN.test(haystack);
+}
+export function parseTextInputElicitation(request) {
+    if (request.mode && request.mode !== "form")
+        return null;
+    const schema = request.requestedSchema;
+    const fieldsSource = schema?.properties && typeof schema.properties === "object"
+        ? schema.properties
+        : schema?.keys && typeof schema.keys === "object"
+            ? schema.keys
+            : undefined;
+    if (!fieldsSource)
+        return null;
+    const requiredSet = new Set(Array.isArray(request.requestedSchema?.required)
+        ? request.requestedSchema.required.filter((value) => typeof value === "string")
+        : []);
+    const fields = [];
+    for (const [fieldId, field] of Object.entries(fieldsSource)) {
+        if (!field || typeof field !== "object")
+            continue;
+        if (field.type !== "string")
+            continue;
+        if (Array.isArray(field.oneOf) && field.oneOf.length > 0)
+            continue;
+        fields.push({
+            id: fieldId,
+            title: typeof field.title === "string" && field.title.length > 0 ? field.title : fieldId,
+            description: typeof field.description === "string" ? field.description : "",
+            required: requiredSet.has(fieldId),
+            secure: isSecureElicitationField(request.message, fieldId, field),
+        });
+    }
+    return fields.length > 0 ? fields : null;
+}
 export function roundResultToElicitationContent(questions, result) {
     const content = {};
     for (const question of questions) {
@@ -246,6 +297,38 @@ async function promptElicitationWithDialogs(request, questions, ui, signal) {
     }
     return { action: "accept", content };
 }
+function buildTextInputPromptTitle(request, field) {
+    const parts = [
+        request.serverName ? `[${request.serverName}]` : "",
+        field.title,
+        field.description,
+    ].filter((part) => typeof part === "string" && part.trim().length > 0);
+    return parts.join("\n\n");
+}
+function buildTextInputPlaceholder(field) {
+    const desc = field.description.trim();
+    if (!desc)
+        return field.required ? "Required" : "Leave empty to skip";
+    const formatLine = desc
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => /^format:/i.test(line));
+    if (!formatLine)
+        return field.required ? "Required" : "Leave empty to skip";
+    const hint = formatLine.replace(/^format:\s*/i, "").trim();
+    return hint.length > 0 ? hint : field.required ? "Required" : "Leave empty to skip";
+}
+async function promptTextInputElicitation(request, fields, ui, signal) {
+    const content = {};
+    for (const field of fields) {
+        const value = await ui.input(buildTextInputPromptTitle(request, field), buildTextInputPlaceholder(field), { signal, ...(field.secure ? { secure: true } : {}) });
+        if (value === undefined) {
+            return { action: "cancel" };
+        }
+        content[field.id] = value;
+    }
+    return { action: "accept", content };
+}
 export function createClaudeCodeElicitationHandler(ui) {
     if (!ui)
         return undefined;
@@ -254,17 +337,21 @@ export function createClaudeCodeElicitationHandler(ui) {
             return { action: "decline" };
         }
         const questions = parseAskUserQuestionsElicitation(request);
-        if (!questions) {
-            return { action: "decline" };
+        if (questions) {
+            const interviewResult = await showInterviewRound(questions, { signal }, { ui }).catch(() => undefined);
+            if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
+                return {
+                    action: "accept",
+                    content: roundResultToElicitationContent(questions, interviewResult),
+                };
+            }
+            return promptElicitationWithDialogs(request, questions, ui, signal);
         }
-        const interviewResult = await showInterviewRound(questions, { signal }, { ui }).catch(() => undefined);
-        if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
-            return {
-                action: "accept",
-                content: roundResultToElicitationContent(questions, interviewResult),
-            };
+        const textFields = parseTextInputElicitation(request);
+        if (textFields) {
+            return promptTextInputElicitation(request, textFields, ui, signal);
         }
-        return promptElicitationWithDialogs(request, questions, ui, signal);
+        return { action: "decline" };
     };
 }
 // ---------------------------------------------------------------------------
@@ -278,6 +365,7 @@ export function createClaudeCodeElicitationHandler(ui) {
  */
 export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
+    const disallowedTools = ["AskUserQuestion"];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -288,6 +376,7 @@ export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
         allowDangerouslySkipPermissions: true,
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
+        disallowedTools,
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
         ...extraOptions,
@@ -371,9 +460,9 @@ export function extractToolResultsFromSdkUserMessage(message) {
     }
     return extracted;
 }
-function attachExternalResultsToToolCalls(toolCalls, toolResultsById) {
-    for (const block of toolCalls) {
-        if (block.type !== "toolCall")
+function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
+    for (const block of toolBlocks) {
+        if (block.type !== "toolCall" && block.type !== "serverToolUse")
             continue;
         const externalResult = toolResultsById.get(block.id);
         if (!externalResult)
@@ -402,8 +491,8 @@ async function pumpSdkMessages(model, context, options, stream) {
     /** Track the last text content seen across all assistant turns for the final message. */
     let lastTextContent = "";
     let lastThinkingContent = "";
-    /** Collect tool calls from intermediate SDK turns for tool_execution events. */
-    const intermediateToolCalls = [];
+    /** Collect tool blocks from intermediate SDK turns for tool execution rendering. */
+    const intermediateToolBlocks = [];
     /** Preserve real external tool results from Claude Code's synthetic user messages. */
     const toolResultsById = new Map();
     try {
@@ -491,9 +580,9 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
-                            else if (block.type === "toolCall") {
-                                // Collect tool calls for externalToolExecution rendering
-                                intermediateToolCalls.push(block);
+                            else if (block.type === "toolCall" || block.type === "serverToolUse") {
+                                // Collect tool blocks for externalToolExecution rendering
+                                intermediateToolBlocks.push(block);
                             }
                         }
                     }
@@ -502,25 +591,35 @@ async function pumpSdkMessages(model, context, options, stream) {
                     for (const { toolUseId, result } of extractToolResultsFromSdkUserMessage(msg)) {
                         toolResultsById.set(toolUseId, result);
                     }
-                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+                    attachExternalResultsToToolBlocks(intermediateToolBlocks, toolResultsById);
                     // Push a synthetic toolcall_end for each tool call from this turn
                     // so the TUI can render tool results in real-time during the SDK
                     // session instead of waiting until the entire session completes.
                     if (builder) {
                         for (const block of builder.message.content) {
-                            if (block.type !== "toolCall")
-                                continue;
                             const extResult = block.externalResult;
                             if (!extResult)
                                 continue;
-                            // Push a toolcall_end with result attached so the chat-controller
-                            // can call updateResult on the pending ToolExecutionComponent.
-                            stream.push({
-                                type: "toolcall_end",
-                                contentIndex: builder.message.content.indexOf(block),
-                                toolCall: block,
-                                partial: builder.message,
-                            });
+                            const contentIndex = builder.message.content.indexOf(block);
+                            if (contentIndex < 0)
+                                continue;
+                            // Push synthetic completion events with result attached so the
+                            // chat-controller can update pending ToolExecutionComponents.
+                            if (block.type === "toolCall") {
+                                stream.push({
+                                    type: "toolcall_end",
+                                    contentIndex,
+                                    toolCall: block,
+                                    partial: builder.message,
+                                });
+                            }
+                            else if (block.type === "serverToolUse") {
+                                stream.push({
+                                    type: "server_tool_use",
+                                    contentIndex,
+                                    partial: builder.message,
+                                });
+                            }
                         }
                     }
                     builder = null;
@@ -534,8 +633,8 @@ async function pumpSdkMessages(model, context, options, stream) {
                     // events for proper TUI rendering, followed by the text response.
                     const finalContent = [];
                     // Add tool calls from intermediate turns first (renders above text)
-                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
-                    finalContent.push(...intermediateToolCalls);
+                    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) {

package/dist/resources/extensions/get-secrets-from-user.js

@@ -93,7 +93,7 @@ export function detectDestination(basePath) {
 async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guidance) {
     if (!ctx.hasUI)
         return null;
-    return ctx.ui.custom((tui, theme, _kb, done) => {
+    const customResult = await ctx.ui.custom((tui, theme, _kb, done) => {
         let value = "";
         let cachedLines;
         const editorTheme = {
@@ -178,6 +178,22 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
             handleInput,
         };
     });
+    // RPC/web surfaces may not implement ctx.ui.custom(). Fall back to a
+    // standard input prompt so users can still provide the secret.
+    if (customResult !== undefined) {
+        return customResult;
+    }
+    if (typeof ctx.ui?.input !== "function") {
+        return null;
+    }
+    const inputTitle = `Secure value for ${keyName} (${pageIndex + 1}/${totalPages})`;
+    const inputPlaceholder = hint || "Enter secret value";
+    const inputResult = await ctx.ui.input(inputTitle, inputPlaceholder, { secure: true });
+    if (typeof inputResult !== "string") {
+        return null;
+    }
+    const trimmed = inputResult.trim();
+    return trimmed.length > 0 ? trimmed : null;
 }
 /**
  * Exported wrapper around collectOneSecret for testing.