gsd-pi 2.71.0 → 2.72.0-dev.3118184

package/README.md

@@ -27,36 +27,68 @@ 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
+### Model Selection Hardening
 
-- **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.
+- **Unconfigured models blocked** — models without a configured provider are filtered from selection surfaces, preventing dispatch failures.
+- **Provider readiness required** — saved default model selection now verifies the provider is ready before accepting it.
+- **Session override honored** — `/gsd model` selection persists as a session override across all dispatch phases.
+- **Minimal context guard** — model override logic is skipped in minimal command contexts where it doesn't apply.
 
-### Infrastructure
+### Auto-Mode Resilience
 
-- **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.
+- **Credential cooldown recovery** — auto-mode survives transient 429 rate-limit responses with structured cooldown errors and a bounded retry budget.
+- **Fire-and-forget auto start** — auto start is detached from active turns to prevent blocking.
+- **Scoped forensics** — stuck-loop forensics are now scoped to auto sessions only, preventing false positives in interactive use.
+
+### TUI Improvements
+
+- **Overlay subscription fix** — resolved overlay subscription lifecycle and `Ctrl+Shift+P` shortcut conflict.
+- **Improved overlays and shortcuts** — GSD overlays, keyboard shortcuts, and notification flows redesigned for consistency.
+- **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.
+
+### Provider Fixes
+
+- **Full OAuth login URLs** — OAuth login URLs are now displayed in full instead of being truncated.
+- **MiniMax bearer auth** — MiniMax Anthropic API requests use proper bearer authentication.
+- **Case-insensitive tool rendering** — renderable tool matching is now case-insensitive, fixing missed tool output.
+- **Headless idle timeout** — idle timeout is kept off during interactive tool execution in headless mode.
+
+### Reliability & Internals
+
+- **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.
+- **Anti-fabrication guardrails** — discuss prompts enforce turn-taking to prevent fabricated user responses.
+- **Milestone worktree cleanup** — merged worktree cleanup uses the milestone branch instead of generic lookups.
+- **Tool cache control** — `cache_control` breakpoints added to tool definitions for improved prompt caching.
 
 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
@@ -591,8 +623,10 @@ The best practice for working in teams is to ensure unique milestone names acros
 # ── GSD: Runtime / Ephemeral (per-developer, per-session) ──────────────────
 # Crash detection sentinel — PID lock, written per auto-mode session
 .gsd/auto.lock
-# Auto-mode dispatch tracker — prevents re-running completed units
-.gsd/completed-units.json
+# Auto-mode dispatch tracker — prevents re-running completed units (includes archived per-milestone files)
+.gsd/completed-units*.json
+# State manifest — workflow state for recovery
+.gsd/state-manifest.json
 # Derived state cache — regenerated from plan/roadmap files on disk
 .gsd/STATE.md
 # Per-developer token/cost accumulator
@@ -605,6 +639,14 @@ The best practice for working in teams is to ensure unique milestone names acros
 .gsd/worktrees/
 # Parallel orchestration IPC and worker status
 .gsd/parallel/
+# SQLite database and WAL sidecars — checkpoint state, forensics data
+.gsd/gsd.db*
+# Daily-rotated event journal — structured event log for forensics
+.gsd/journal/
+# Doctor run history — diagnostic check results
+.gsd/doctor-history.jsonl
+# Workflow event log — structured event stream
+.gsd/event-log.jsonl
 # Generated HTML reports (regenerable via /gsd export --html)
 .gsd/reports/
 # Session-specific interrupted-work markers
@@ -725,6 +767,14 @@ Use expensive models where quality matters (planning, complex execution) and che
 
 ---
 
+## Ecosystem
+
+| Project | Description |
+| ------- | ----------- |
+| [GSD2 Config Utility](https://github.com/jeremymcs/gsd2-config) | Standalone configuration tool for managing GSD preferences, providers, and API keys |
+
+---
+
 ## Star History
 
 <a href="https://star-history.com/#gsd-build/gsd-2&Date">

package/dist/cli.js

@@ -5,8 +5,8 @@ import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
 import { initResources, buildResourceLoader, getNewerManagedResourceVersion } from './resource-loader.js';
 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 { migratePiCredentials, getPiDefaultModelAndProvider } from './pi-migration.js';
+import { shouldMigrateAnthropicToClaudeCode } from './provider-migrations.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
@@ -101,6 +101,41 @@ function parseCliArgs(argv) {
     }
     return flags;
 }
+/**
+ * Validate the configured default model against the registry and reset it if
+ * it no longer exists.  Must run AFTER extensions have registered their
+ * providers so that extension models (e.g. pi-claude-cli) are visible.
+ */
+function validateConfiguredModel(modelRegistry, settingsManager) {
+    const configuredProvider = settingsManager.getDefaultProvider();
+    const configuredModel = settingsManager.getDefaultModel();
+    const allModels = modelRegistry.getAll();
+    const availableModels = modelRegistry.getAvailable();
+    const configuredExists = configuredProvider && configuredModel &&
+        allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
+    const configuredAvailable = configuredProvider && configuredModel &&
+        availableModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
+    if (!configuredModel || !configuredExists) {
+        // Model not configured at all, or removed from registry — pick a fallback.
+        // Only fires when the model is genuinely unknown (not just temporarily unavailable).
+        const piDefault = getPiDefaultModelAndProvider();
+        const preferred = (piDefault
+            ? availableModels.find((m) => m.provider === piDefault.provider && m.id === piDefault.model)
+            : undefined) ||
+            availableModels.find((m) => m.provider === 'openai' && m.id === 'gpt-5.4') ||
+            availableModels.find((m) => m.provider === 'openai') ||
+            availableModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
+            availableModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
+            availableModels.find((m) => m.provider === 'anthropic') ||
+            availableModels[0];
+        if (preferred) {
+            settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
+        }
+    }
+    if (settingsManager.getDefaultThinkingLevel() !== 'off' && !configuredExists) {
+        settingsManager.setDefaultThinkingLevel('off');
+    }
+}
 const cliFlags = parseCliArgs(process.argv);
 const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
 // Early resource-skew check — must run before TTY gate so version mismatch
@@ -233,6 +268,14 @@ if (cliFlags.messages[0] === 'sessions') {
         rl.question(chalk.bold('  Enter session number to resume (or q to quit): '), resolve);
     });
     rl.close();
+    // Clean up stdin state left by readline.createInterface().
+    // Without this, downstream TUI initialization gets corrupted listeners and exhibits
+    // duplicate terminal I/O. Match the pattern used after onboarding cleanup.
+    process.stdin.removeAllListeners('data');
+    process.stdin.removeAllListeners('keypress');
+    if (process.stdin.setRawMode)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
     const choice = parseInt(answer, 10);
     if (isNaN(choice) || choice < 1 || choice > toShow.length) {
         process.stderr.write(chalk.dim('Cancelled.\n'));
@@ -285,7 +328,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)
@@ -311,8 +354,22 @@ if (!isPrintMode) {
 if (!isPrintMode && process.stdout.columns && process.stdout.columns < 40) {
     process.stderr.write(chalk.yellow(`[gsd] Terminal width is ${process.stdout.columns} columns (minimum recommended: 40). Output may be unreadable.\n`));
 }
-// --list-models: print available models and exit (no TTY needed)
+// --list-models: load extensions so that extension-registered providers (e.g.
+// pi-claude-cli) appear in the listing, then flush their pending registrations
+// into the model registry before printing.
 if (cliFlags.listModels !== undefined) {
+    exitIfManagedResourcesAreNewer(agentDir);
+    initResources(agentDir);
+    const listModelsLoader = new DefaultResourceLoader({
+        agentDir,
+        additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
+    });
+    await listModelsLoader.reload();
+    const listModelsExtensions = listModelsLoader.getExtensions();
+    for (const { name, config } of listModelsExtensions.runtime.pendingProviderRegistrations) {
+        modelRegistry.registerProvider(name, config);
+    }
+    listModelsExtensions.runtime.pendingProviderRegistrations = [];
     const models = modelRegistry.getAvailable();
     if (models.length === 0) {
         console.log('No models available. Set API keys in environment variables.');
@@ -401,7 +458,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);
@@ -448,6 +509,10 @@ if (isPrintMode) {
             process.stderr.write(`[gsd] ${prefix}: ${err.error}\n`);
         }
     }
+    // Validate configured model now that extension providers are registered.
+    // Must run after createAgentSession() which flushes pendingProviderRegistrations
+    // so extension models (e.g. pi-claude-cli) are visible in the registry.
+    validateConfiguredModel(modelRegistry, settingsManager);
     // Apply --model override if specified
     if (cliFlags.model) {
         const available = modelRegistry.getAvailable();
@@ -466,6 +531,15 @@ if (isPrintMode) {
     if (mode === 'mcp') {
         printStartupTimings();
         const { startMcpServer } = await import('./mcp-server.js');
+        // Activate every registered tool before starting the MCP transport.
+        // `session.agent.state.tools` is the *active* subset, not the full
+        // registry — if we expose only the active set, extension-registered
+        // tools (gsd workflow, browser-tools, mac-tools, search-the-web, …)
+        // are invisible to MCP clients. Flipping the active set to every
+        // known tool name makes `state.tools` mirror the full registry for
+        // this MCP session, which is what an external client expects.
+        const allToolNames = session.getAllTools().map((t) => t.name);
+        session.setActiveToolsByName(allToolNames);
         await startMcpServer({
             tools: session.agent.state.tools ?? [],
             version: process.env.GSD_VERSION || '0.0.0',
@@ -576,7 +650,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);
@@ -622,6 +700,10 @@ if (extensionsResult.errors.length > 0) {
         process.stderr.write(`[gsd] ${prefix}: ${err.error}\n`);
     }
 }
+// Validate configured model now that extension providers are registered.
+// Must run after createAgentSession() which flushes pendingProviderRegistrations
+// so extension models (e.g. pi-claude-cli) are visible in the registry.
+validateConfiguredModel(modelRegistry, settingsManager);
 // Restore scoped models from settings on startup.
 // The upstream InteractiveMode reads enabledModels from settings when /scoped-models is opened,
 // but doesn't apply them to the session at startup — so Ctrl+P cycles all models instead of

package/dist/headless-events.d.ts

@@ -43,6 +43,8 @@ export declare const NEW_MILESTONE_IDLE_TIMEOUT_MS = 120000;
 export declare function isTerminalNotification(event: Record<string, unknown>): boolean;
 export declare function isBlockedNotification(event: Record<string, unknown>): boolean;
 export declare function isMilestoneReadyNotification(event: Record<string, unknown>): boolean;
+export declare function isInteractiveHeadlessTool(toolName: string | undefined): boolean;
+export declare function shouldArmHeadlessIdleTimeout(toolCallCount: number, interactiveToolCount: number): boolean;
 export declare const FIRE_AND_FORGET_METHODS: Set<string>;
 export declare const QUICK_COMMANDS: Set<string>;
 export declare function isQuickCommand(command: string): boolean;

package/dist/headless-events.js

@@ -65,6 +65,7 @@ export const IDLE_TIMEOUT_MS = 15_000;
 // between tool calls (e.g. after mkdir, before writing files). Use a
 // longer idle timeout to avoid killing the session prematurely (#808).
 export const NEW_MILESTONE_IDLE_TIMEOUT_MS = 120_000;
+const INTERACTIVE_HEADLESS_TOOLS = new Set(['ask_user_questions', 'secure_env_collect']);
 export function isTerminalNotification(event) {
     if (event.type !== 'extension_ui_request' || event.method !== 'notify')
         return false;
@@ -83,6 +84,12 @@ export function isMilestoneReadyNotification(event) {
         return false;
     return /milestone\s+m\d+.*ready/i.test(String(event.message ?? ''));
 }
+export function isInteractiveHeadlessTool(toolName) {
+    return INTERACTIVE_HEADLESS_TOOLS.has(String(toolName ?? ''));
+}
+export function shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCount) {
+    return toolCallCount > 0 && interactiveToolCount === 0;
+}
 // ---------------------------------------------------------------------------
 // Quick Command Detection
 // ---------------------------------------------------------------------------

package/dist/headless.js

@@ -17,7 +17,7 @@ import { resolve } from 'node:path';
 import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
-import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
+import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, isInteractiveHeadlessTool, shouldArmHeadlessIdleTimeout, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
 import { handleExtensionUIRequest, formatProgress, formatThinkingLine, formatTextStart, formatTextEnd, formatThinkingStart, formatThinkingEnd, startSupervisedStdinReader, } from './headless-ui.js';
 import { loadContext, bootstrapGsdProject, } from './headless-context.js';
@@ -282,6 +282,7 @@ async function runHeadlessOnce(options, restartCount) {
     let exitCode = 0;
     let milestoneReady = false; // tracks "Milestone X ready." for auto-chaining
     const recentEvents = [];
+    const interactiveToolCallIds = new Set();
     // JSON batch mode: cost aggregation (cumulative-max pattern per K004)
     let cumulativeCostUsd = 0;
     let cumulativeInputTokens = 0;
@@ -365,7 +366,7 @@ async function runHeadlessOnce(options, restartCount) {
     function resetIdleTimer() {
         if (idleTimer)
             clearTimeout(idleTimer);
-        if (toolCallCount > 0) {
+        if (shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCallIds.size)) {
             idleTimer = setTimeout(() => {
                 completed = true;
                 resolveCompletion();
@@ -386,13 +387,25 @@ async function runHeadlessOnce(options, restartCount) {
     client.onEvent((event) => {
         const eventObj = event;
         trackEvent(eventObj);
+        const eventType = String(eventObj.type ?? '');
+        if (eventType === 'tool_execution_start') {
+            const toolCallId = String(eventObj.toolCallId ?? eventObj.id ?? '');
+            if (toolCallId && isInteractiveHeadlessTool(String(eventObj.toolName ?? ''))) {
+                interactiveToolCallIds.add(toolCallId);
+            }
+        }
+        else if (eventType === 'tool_execution_end') {
+            const toolCallId = String(eventObj.toolCallId ?? eventObj.id ?? '');
+            if (toolCallId) {
+                interactiveToolCallIds.delete(toolCallId);
+            }
+        }
         resetIdleTimer();
         // Answer injector: observe events for question metadata
         injector?.observeEvent(eventObj);
         // --json / --output-format stream-json: forward events as JSONL to stdout (filtered if --events)
         // --output-format json (batch mode): suppress streaming, track cost for final result
         if (options.json && options.outputFormat === 'stream-json') {
-            const eventType = String(eventObj.type ?? '');
             if (!options.eventFilter || options.eventFilter.has(eventType)) {
                 process.stdout.write(JSON.stringify(eventObj) + '\n');
             }

package/dist/mcp-server.js

@@ -1,10 +1,15 @@
-// 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);
+// 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
+// a non-existent file. Historically the workaround (#3603) used createRequire so
+// the CJS resolver could auto-append `.js`; that no longer works with current
+// Node + SDK releases (#3914) — `_require.resolve` also fails with
+// "Cannot find module .../dist/cjs/server/stdio".
+//
+// The reliable convention (matching packages/mcp-server/{server,cli}.ts) is to
+// write the `.js` suffix explicitly on every wildcard subpath. Specifiers are
+// built via a template string so TypeScript's NodeNext resolver treats them as
+// `any` and skips static checking.
 const MCP_PKG = '@modelcontextprotocol/sdk';
 /**
  * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
@@ -22,9 +27,9 @@ 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 serverMod = await import(`${MCP_PKG}/server/index.js`);
+    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;
@@ -42,8 +47,14 @@ export async function startMcpServer(options) {
             inputSchema: t.parameters,
         })),
     }));
-    // tools/call — execute the requested tool and return content blocks
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    // tools/call — execute the requested tool and return content blocks.
+    //
+    // The MCP SDK passes an `extra` argument to request handlers that includes
+    // an AbortSignal scoped to the RPC request (cancelled when the client
+    // cancels the tool call or the transport closes). Threading it into
+    // AgentTool.execute ensures long-running tools (Bash, WebFetch, grep on
+    // huge trees) actually stop when the client gives up on the result.
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
         const tool = toolMap.get(name);
         if (!tool) {
@@ -52,20 +63,32 @@ export async function startMcpServer(options) {
                 content: [{ type: 'text', text: `Unknown tool: ${name}` }],
             };
         }
+        const signal = extra?.signal;
         try {
-            const result = await tool.execute(`mcp-${Date.now()}`, args ?? {}, undefined, // no AbortSignal
-            undefined);
-            // Convert AgentToolResult content blocks to MCP content format
+            const result = await tool.execute(`mcp-${Date.now()}`, args ?? {}, signal, undefined);
+            // Convert AgentToolResult content blocks to MCP content format.
+            // text and image pass through; any other shape is serialized as text
+            // so the client sees the payload rather than an empty response.
             const content = result.content.map((block) => {
                 if (block.type === 'text')
                     return { type: 'text', text: block.text ?? '' };
-                if (block.type === 'image')
-                    return { type: 'image', data: block.data ?? '', mimeType: block.mimeType ?? 'image/png' };
+                if (block.type === 'image') {
+                    return {
+                        type: 'image',
+                        data: block.data ?? '',
+                        mimeType: block.mimeType ?? 'image/png',
+                    };
+                }
+                // Preserve unknown block types (resource, resource_link, audio, ...)
+                // by stringifying into a text block so clients see the payload.
                 return { type: 'text', text: JSON.stringify(block) };
             });
             return { content };
         }
         catch (err) {
+            // AbortError from a cancelled tool surfaces as a normal error — MCP
+            // clients interpret `isError: true` as a failed call, which is the
+            // correct behaviour for a cancelled request.
             const message = err instanceof Error ? err.message : String(err);
             return { isError: true, content: [{ type: 'text', text: message }] };
         }

package/dist/onboarding.js

@@ -277,6 +277,16 @@ async function runLlmStep(p, pc, authStorage) {
         p.log.info('Your Claude subscription will be used for inference. No API key needed.');
         // Store sentinel so hasAuth('claude-code') returns true on future boots
         authStorage.set('claude-code', { type: 'api_key', key: 'cli' });
+        // Persist claude-code as the default provider so the startup migration in
+        // cli.ts does not need to fire and the user is not left on "anthropic".
+        const settingsPath = join(agentDir, 'settings.json');
+        try {
+            const raw = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, 'utf-8')) : {};
+            raw.defaultProvider = 'claude-code';
+            mkdirSync(dirname(settingsPath), { recursive: true });
+            writeFileSync(settingsPath, JSON.stringify(raw, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal — startup migration will catch it */ }
         return true;
     }
     // ── Step 2: Which provider? ──────────────────────────────────────────────

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);
+}