shortcutxl 0.3.89 → 0.3.91

package/dist/app/local/tools/take-screenshot/com-screenshot.js

@@ -13,6 +13,7 @@ async function captureComScreenshot(host, range, signal) {
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
             control: 'screenshot',
+            workbook: range.workbook,
             sheet: range.sheet,
             range: range.cell_range
         }),
@@ -43,6 +44,7 @@ export async function captureComScreenshots(ranges, signal, resolveTarget) {
         const msg = error instanceof Error ? error.message : String(error);
         console.error(`[take_screenshot] COM capture unavailable: ${msg}`);
         return ranges.map((range) => ({
+            workbook: range.workbook,
             sheet: range.sheet,
             cell_range: range.cell_range,
             data: null
@@ -58,7 +60,12 @@ export async function captureComScreenshots(ranges, signal, resolveTarget) {
             const msg = error instanceof Error ? error.message : String(error);
             console.error(`[take_screenshot] COM capture failed for ${range.sheet}!${range.cell_range}: ${msg}`);
         }
-        screenshots.push({ sheet: range.sheet, cell_range: range.cell_range, data });
+        screenshots.push({
+            workbook: range.workbook,
+            sheet: range.sheet,
+            cell_range: range.cell_range,
+            data
+        });
     }
     return screenshots;
 }

package/dist/app/local/tools/take-screenshot/mog-screenshot.d.ts

@@ -1,6 +1,5 @@
 import type { Screenshot, ScreenshotRange } from '../../../tools/take-screenshot.js';
 interface MogSheetPoolWithScreenshots {
-    activeWorkbookName: string | null | undefined;
     getWorkbook(name: string): unknown;
 }
 export declare function captureMogScreenshots(pool: MogSheetPoolWithScreenshots, ranges: ScreenshotRange[], _signal?: AbortSignal): Promise<Screenshot[]>;

package/dist/app/local/tools/take-screenshot/mog-screenshot.js

@@ -4,26 +4,14 @@ function isMogWorkbookWithScreenshots(value) {
         typeof value.captureScreenshot === 'function');
 }
 export async function captureMogScreenshots(pool, ranges, _signal) {
-    if (!pool.activeWorkbookName) {
-        return ranges.map((range) => ({
-            sheet: range.sheet,
-            cell_range: range.cell_range,
-            data: null
-        }));
-    }
-    const workbook = pool.getWorkbook(pool.activeWorkbookName);
-    if (!isMogWorkbookWithScreenshots(workbook)) {
-        console.error('[take_screenshot] Active Mog workbook does not support screenshot capture');
-        return ranges.map((range) => ({
-            sheet: range.sheet,
-            cell_range: range.cell_range,
-            data: null
-        }));
-    }
     const screenshots = [];
     for (const range of ranges) {
         let data = null;
         try {
+            const workbook = pool.getWorkbook(range.workbook);
+            if (!isMogWorkbookWithScreenshots(workbook)) {
+                throw new Error(`Workbook does not support screenshot capture: ${range.workbook}`);
+            }
             const pngBuffer = await workbook.captureScreenshot(range.sheet, range.cell_range);
             data = Buffer.from(pngBuffer).toString('base64');
         }
@@ -31,7 +19,12 @@ export async function captureMogScreenshots(pool, ranges, _signal) {
             const msg = error instanceof Error ? error.message : String(error);
             console.error(`[take_screenshot] Mog capture failed for ${range.sheet}!${range.cell_range}: ${msg}`);
         }
-        screenshots.push({ sheet: range.sheet, cell_range: range.cell_range, data });
+        screenshots.push({
+            workbook: range.workbook,
+            sheet: range.sheet,
+            cell_range: range.cell_range,
+            data
+        });
     }
     return screenshots;
 }

package/dist/app/mcp/auth-status.d.ts

@@ -6,6 +6,8 @@ export interface ResolveMcpAuthStatusOptions {
     authStorage?: AuthStorage;
     mcpOAuthStore?: McpOAuthStore;
     discovery?: McpAuthDiscoveryMode;
+    /** Pre-fetched connection secrets by name; when absent the keychain is read directly. */
+    connectionSecrets?: ReadonlyMap<string, Record<string, string> | undefined>;
 }
 export declare function resolveMcpAuthStatus(serverName: string, config: McpServerConfig, options?: ResolveMcpAuthStatusOptions): Promise<McpAuthStatus>;
 export declare function getMcpAuthStatus(serverName: string, config: McpServerConfig, authStorage?: AuthStorage, mcpOAuthStore?: McpOAuthStore): Promise<McpAuthStatus>;

package/dist/app/mcp/auth-status.js

@@ -10,7 +10,11 @@ export async function resolveMcpAuthStatus(serverName, config, options = {}) {
         return 'unsupported';
     }
     const staticHeaders = { ...(config.headers ?? {}) };
-    const secretHeaders = config.connection ? getSecret(config.connection) : undefined;
+    const secretHeaders = !config.connection
+        ? undefined
+        : options.connectionSecrets
+            ? options.connectionSecrets.get(config.connection)
+            : getSecret(config.connection);
     if (hasConfiguredHeaders(staticHeaders) || hasConfiguredHeaders(secretHeaders)) {
         return 'configured';
     }

package/dist/app/mcp/connection.d.ts

@@ -4,17 +4,47 @@
 import type { AuthStorage } from '../auth/auth-storage.js';
 import type { McpOAuthStore } from './oauth-state-store.js';
 import { type McpConnection, type McpFailureKind, type McpRequestPolicy, type McpServerConfig } from './types.js';
+/** Abort signal plus absolute deadline that bounds one server's whole startup. */
+export interface McpStartupBudget {
+    signal: AbortSignal;
+    deadlineAt: number;
+}
+export interface McpConnectOptions {
+    /**
+     * Connection secrets already read from the keychain, keyed by connection
+     * name. When absent, the server reads its own secret synchronously.
+     */
+    connectionSecrets?: ReadonlyMap<string, Record<string, string> | undefined>;
+    /** Budget shared across the whole startup. Direct callers get one from the config's startup timeout. */
+    budget?: McpStartupBudget;
+}
 export declare class McpConnectionError extends Error {
     readonly failureKind: McpFailureKind;
     constructor(failureKind: McpFailureKind, message: string);
 }
 export declare function resolveStartupTimeoutMs(config: McpServerConfig): number;
 export declare function buildRequestPolicy(config: McpServerConfig): McpRequestPolicy;
+/**
+ * Run one server's startup under a single deadline. The budget's signal is
+ * threaded into every SDK request so a stalled initialize or tools/list is
+ * cancelled, and the race guarantees the deadline even for steps that cannot
+ * observe the signal (process spawn, keychain reads).
+ */
+export declare function withStartupBudget<T>(name: string, timeoutMs: number, operation: (budget: McpStartupBudget) => Promise<T>): Promise<T>;
+/** SDK request options for initialize and tools/list under a startup budget. */
+export declare function requestOptions(budget: McpStartupBudget): {
+    signal: AbortSignal;
+    timeout: number;
+};
+/** Whether a failed hosted startup is safe to repeat with a fresh MCP session. */
+export declare function isTransientHostedStartupError(error: unknown): boolean;
 export declare function createHostedMcpLoggingFetch(serverName: string, fetchImpl?: typeof fetch): typeof fetch;
 /**
- * Connect a server, list tools, and return a live MCP connection.
+ * Connect a server, list tools, and return a live MCP connection. The whole
+ * sequence runs under `options.budget`, or under a fresh budget from the
+ * config's startup timeout when the caller did not supply one.
  */
-export declare function connectServer(name: string, config: McpServerConfig, defaultCwd: string, authStorage?: AuthStorage, mcpOAuthStore?: McpOAuthStore): Promise<McpConnection>;
+export declare function connectServer(name: string, config: McpServerConfig, defaultCwd: string, authStorage?: AuthStorage, mcpOAuthStore?: McpOAuthStore, options?: McpConnectOptions): Promise<McpConnection>;
 /**
  * Call a tool on a connected server. Returns the result text or throws.
  */

package/dist/app/mcp/connection.js

@@ -10,16 +10,40 @@ import { mkdir, writeFile } from 'fs/promises';
 import { basename, extname, join } from 'path';
 import { getAgentTempDir } from '../../config.js';
 import { log } from '../../shared/logging/agent-log.js';
+import { sleep } from '../../utils/sleep.js';
 import { getSecret } from '../connectors/secret-store.js';
 import { getHostedMcpOAuthProviderId } from './hosted-oauth-id.js';
 import { createHostedMcpRuntimeAuthProvider } from './hosted-oauth-provider.js';
 import { resolveHostedMcpOAuthTimeoutMs, supportsHostedMcpOAuth } from './oauth-discovery.js';
 import { withHostedMcpProxyFetchOptions } from './proxy-fetch.js';
 import { isHostedServerConfig } from './types.js';
-const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
+/**
+ * Default budget for one server's whole startup: credential lookup, connect and
+ * initialize, OAuth refresh, and tool discovery. Managed Windows fleets behind
+ * proxies and EDR routinely take 60-90s here, so the budget is generous while
+ * still sitting under the 180s RPC readiness budget in `rpc-client.ts`.
+ */
+const DEFAULT_STARTUP_TIMEOUT_MS = 120_000;
 const DEFAULT_TOOL_CALL_TIMEOUT_MS = 600_000;
 const DEFAULT_RESET_TIMEOUT_ON_PROGRESS = true;
 const MCP_OUTPUT_DIR_NAME = 'mcp';
+const HOSTED_STARTUP_RETRY_DELAY_MS = 250;
+const TRANSIENT_NETWORK_ERROR_CODES = new Set([
+    'EAI_AGAIN',
+    'ECONNABORTED',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'ENOTFOUND',
+    'EPIPE',
+    'ETIMEDOUT',
+    'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_SOCKET'
+]);
+const TRANSIENT_HTTP_STATUS_CODES = new Set([408, 425, 429, 500, 502, 503, 504]);
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -231,14 +255,68 @@ export function buildRequestPolicy(config) {
             : {})
     };
 }
-async function buildHostedHeaders(name, config) {
+/**
+ * Run one server's startup under a single deadline. The budget's signal is
+ * threaded into every SDK request so a stalled initialize or tools/list is
+ * cancelled, and the race guarantees the deadline even for steps that cannot
+ * observe the signal (process spawn, keychain reads).
+ */
+export async function withStartupBudget(name, timeoutMs, operation) {
+    const controller = new AbortController();
+    const timeoutError = new McpConnectionError('startup_timeout', `MCP server '${name}' did not finish connection and tool discovery within ${timeoutMs / 1000}s.`);
+    const expired = new Promise((_, reject) => {
+        controller.signal.addEventListener('abort', () => reject(timeoutError), { once: true });
+    });
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    if (typeof timer === 'object' && 'unref' in timer)
+        timer.unref();
+    try {
+        return await Promise.race([
+            operation({ signal: controller.signal, deadlineAt: Date.now() + timeoutMs }),
+            expired
+        ]);
+    }
+    catch (error) {
+        // The SDK surfaces our abort as its own error; report the budget instead.
+        throw controller.signal.aborted ? timeoutError : error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * The SDK arms its own per-request timer (60s when none is given), so it cannot
+ * be the budget's timekeeper: two timers set to the same instant race, and the
+ * SDK's raw "Request timed out" would sometimes win. The budget's abort signal
+ * is the single source of truth; the SDK timeout only sits above it so the
+ * default 60s never cuts a longer budget short.
+ */
+const SDK_TIMEOUT_SLACK_MS = 1_000;
+/** SDK request options for initialize and tools/list under a startup budget. */
+export function requestOptions(budget) {
+    return {
+        signal: budget.signal,
+        timeout: Math.max(1, budget.deadlineAt - Date.now()) + SDK_TIMEOUT_SLACK_MS
+    };
+}
+/** Secret for `config.connection`, from the pre-fetched map when the manager supplied one. */
+function resolveConnectionSecret(name, connection, options) {
+    const secret = options.connectionSecrets
+        ? options.connectionSecrets.get(connection)
+        : getSecret(connection);
+    if (!secret) {
+        throw new Error(`MCP server '${name}' references connection '${connection}' but no credentials found in keychain. Run /connect to set it up.`);
+    }
+    return secret;
+}
+/** Best-effort teardown after a failed startup; a stdio close waits on the child, so never block on it. */
+function discardClient(client) {
+    void client.close().catch(() => { });
+}
+function buildHostedHeaders(name, config, options) {
     const headers = { ...(config.headers ?? {}) };
     if (config.connection) {
-        const secrets = getSecret(config.connection);
-        if (!secrets) {
-            throw new Error(`MCP server '${name}' references connection '${config.connection}' but no credentials found in keychain. Run /connect to set it up.`);
-        }
-        Object.assign(headers, secrets);
+        Object.assign(headers, resolveConnectionSecret(name, config.connection, options));
     }
     return headers;
 }
@@ -354,6 +432,32 @@ function summarizeErrorForLog(error, depth = 0) {
     }
     return details;
 }
+/** Whether a failed hosted startup is safe to repeat with a fresh MCP session. */
+export function isTransientHostedStartupError(error) {
+    if (error instanceof UnauthorizedError || error instanceof McpConnectionError) {
+        return false;
+    }
+    if (error instanceof StreamableHTTPError &&
+        typeof error.code === 'number' &&
+        TRANSIENT_HTTP_STATUS_CODES.has(error.code)) {
+        return true;
+    }
+    let current = error;
+    for (let depth = 0; depth < 4; depth += 1) {
+        if (current === null || (typeof current !== 'object' && typeof current !== 'function')) {
+            return false;
+        }
+        const record = current;
+        if (record.name === 'AbortError')
+            return false;
+        if (typeof record.code === 'string' &&
+            TRANSIENT_NETWORK_ERROR_CODES.has(record.code.toUpperCase())) {
+            return true;
+        }
+        current = record.cause;
+    }
+    return false;
+}
 async function readResponseSnippet(response) {
     try {
         const text = await response.clone().text();
@@ -383,10 +487,33 @@ export function createHostedMcpLoggingFetch(serverName, fetchImpl = fetch) {
         return response;
     };
 }
-async function connectHostedServer(name, config, authStorage, mcpOAuthStore, retriedAfterOAuthRefresh = false) {
-    const startupTimeoutMs = resolveStartupTimeoutMs(config);
+/** Discover the server's tools inside the budget, releasing the client if discovery fails. */
+async function discoverTools(name, client, budget) {
+    let toolsResult;
+    try {
+        budget.signal.throwIfAborted();
+        toolsResult = await client.listTools(undefined, requestOptions(budget));
+    }
+    catch (error) {
+        discardClient(client);
+        throw error;
+    }
+    const tools = (toolsResult.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameterNames: t.inputSchema?.properties
+            ? Object.keys(t.inputSchema.properties)
+            : [],
+        inputSchema: (t.inputSchema ?? {})
+    }));
+    if (tools.length === 0) {
+        log.info('mcp', `MCP server '${name}' connected but exposed 0 tools.`);
+    }
+    return tools;
+}
+async function connectHostedServerAttempt(name, config, authStorage, mcpOAuthStore, options, budget, retriedAfterOAuthRefresh = false) {
     const requestPolicy = buildRequestPolicy(config);
-    const headers = await buildHostedHeaders(name, config);
+    const headers = buildHostedHeaders(name, config, options);
     const authProvider = authStorage &&
         mcpOAuthStore &&
         !hasAuthorizationHeader(headers) &&
@@ -399,25 +526,12 @@ async function connectHostedServer(name, config, authStorage, mcpOAuthStore, ret
         authProvider
     });
     const client = new Client({ name: 'shortcut-agent', version: '1.0.0' }, { capabilities: {} });
-    let timer;
-    const connectPromise = client.connect(transport);
-    const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`did not respond within ${startupTimeoutMs / 1000}s`)), startupTimeoutMs);
-        if (typeof timer === 'object' && 'unref' in timer)
-            timer.unref();
-    });
     try {
-        await Promise.race([connectPromise, timeoutPromise]);
-        if (timer)
-            clearTimeout(timer);
+        await client.connect(transport, requestOptions(budget));
     }
     catch (err) {
-        try {
-            await client.close();
-        }
-        catch {
-            // Ignore close errors during cleanup.
-        }
+        discardClient(client);
+        budget.signal.throwIfAborted();
         if (err instanceof UnauthorizedError ||
             (err instanceof StreamableHTTPError && err.code === 401)) {
             const providerId = getHostedMcpOAuthProviderId(name, config);
@@ -426,12 +540,13 @@ async function connectHostedServer(name, config, authStorage, mcpOAuthStore, ret
                 !retriedAfterOAuthRefresh &&
                 authStorage.get(providerId)?.type === 'oauth') {
                 const refreshedToken = await authStorage.getApiKey(providerId, { forceRefresh: true });
+                budget.signal.throwIfAborted();
                 if (refreshedToken) {
-                    return connectHostedServer(name, config, authStorage, mcpOAuthStore, true);
+                    return connectHostedServerAttempt(name, config, authStorage, mcpOAuthStore, options, budget, true);
                 }
             }
             const supportsOAuth = await supportsHostedMcpOAuth(name, config, mcpOAuthStore, {
-                timeoutMs: resolveHostedMcpOAuthTimeoutMs(config)
+                timeoutMs: Math.min(resolveHostedMcpOAuthTimeoutMs(config), requestOptions(budget).timeout)
             }).catch(() => !!config.oauth);
             const providerName = config.oauth?.providerName ?? `MCP: ${name}`;
             throw new McpConnectionError('auth_required', supportsOAuth
@@ -440,31 +555,32 @@ async function connectHostedServer(name, config, authStorage, mcpOAuthStore, ret
         }
         throw err;
     }
-    const toolsResult = await client.listTools();
-    const tools = (toolsResult.tools ?? []).map((t) => ({
-        name: t.name,
-        description: t.description,
-        parameterNames: t.inputSchema?.properties
-            ? Object.keys(t.inputSchema.properties)
-            : [],
-        inputSchema: (t.inputSchema ?? {})
-    }));
-    if (tools.length === 0) {
-        log.info('mcp', `Hosted MCP server '${name}' connected but exposed 0 tools.`);
-    }
+    const tools = await discoverTools(name, client, budget);
     return { name, client, transport, tools, requestPolicy };
 }
-async function connectStdioServer(name, config, defaultCwd) {
-    const startupTimeoutMs = resolveStartupTimeoutMs(config);
-    const requestPolicy = buildRequestPolicy(config);
-    let serverEnv = { ...process.env, ...(config.env ?? {}) };
-    if (config.connection) {
-        const secrets = getSecret(config.connection);
-        if (!secrets) {
-            throw new Error(`MCP server '${name}' references connection '${config.connection}' but no credentials found in keychain. Run /connect to set it up.`);
+/** Retry transient hosted startup failures with a fresh client and transport each time. */
+async function connectHostedServer(name, config, authStorage, mcpOAuthStore, options, budget) {
+    try {
+        return await connectHostedServerAttempt(name, config, authStorage, mcpOAuthStore, options, budget);
+    }
+    catch (error) {
+        budget.signal.throwIfAborted();
+        if (!isTransientHostedStartupError(error) ||
+            Date.now() + HOSTED_STARTUP_RETRY_DELAY_MS >= budget.deadlineAt) {
+            throw error;
         }
-        serverEnv = { ...serverEnv, ...secrets };
+        log.warn('mcp', `MCP server '${name}' had a transient startup failure; retrying once with a fresh session. error=${JSON.stringify(summarizeErrorForLog(error))}`);
+        await sleep(HOSTED_STARTUP_RETRY_DELAY_MS, budget.signal);
+        return connectHostedServerAttempt(name, config, authStorage, mcpOAuthStore, options, budget);
     }
+}
+async function connectStdioServer(name, config, defaultCwd, options, budget) {
+    const requestPolicy = buildRequestPolicy(config);
+    const serverEnv = {
+        ...process.env,
+        ...(config.env ?? {}),
+        ...(config.connection ? resolveConnectionSecret(name, config.connection, options) : {})
+    };
     const transport = new StdioClientTransport({
         command: config.command,
         args: config.args,
@@ -480,52 +596,32 @@ async function connectStdioServer(name, config, defaultCwd) {
         }
     });
     const client = new Client({ name: 'shortcut-agent', version: '1.0.0' }, { capabilities: {} });
-    const connectPromise = client.connect(transport);
-    let timer;
-    const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`did not respond within ${startupTimeoutMs / 1000}s`)), startupTimeoutMs);
-        if (typeof timer === 'object' && 'unref' in timer)
-            timer.unref();
-    });
     try {
-        await Promise.race([connectPromise, timeoutPromise]);
-        if (timer)
-            clearTimeout(timer);
+        await client.connect(transport, requestOptions(budget));
     }
     catch (err) {
-        try {
-            await client.close();
-        }
-        catch {
-            // Ignore close errors during cleanup.
-        }
+        discardClient(client);
+        budget.signal.throwIfAborted();
         const stderr = stderrBuf.trim();
         const base = err instanceof Error ? err.message : String(err);
         const detail = stderr ? `${base}\nServer stderr: ${stderr}` : base;
         throw new McpConnectionError('connect_failed', detail);
     }
-    const toolsResult = await client.listTools();
-    const tools = (toolsResult.tools ?? []).map((t) => ({
-        name: t.name,
-        description: t.description,
-        parameterNames: t.inputSchema?.properties
-            ? Object.keys(t.inputSchema.properties)
-            : [],
-        inputSchema: (t.inputSchema ?? {})
-    }));
-    if (tools.length === 0) {
-        log.info('mcp', `MCP server '${name}' connected but exposed 0 tools.`);
-    }
+    const tools = await discoverTools(name, client, budget);
     return { name, client, transport, tools, requestPolicy };
 }
 /**
- * Connect a server, list tools, and return a live MCP connection.
+ * Connect a server, list tools, and return a live MCP connection. The whole
+ * sequence runs under `options.budget`, or under a fresh budget from the
+ * config's startup timeout when the caller did not supply one.
  */
-export async function connectServer(name, config, defaultCwd, authStorage, mcpOAuthStore) {
-    if (isHostedServerConfig(config)) {
-        return connectHostedServer(name, config, authStorage, mcpOAuthStore);
-    }
-    return connectStdioServer(name, config, defaultCwd);
+export async function connectServer(name, config, defaultCwd, authStorage, mcpOAuthStore, options = {}) {
+    const connect = (budget) => isHostedServerConfig(config)
+        ? connectHostedServer(name, config, authStorage, mcpOAuthStore, options, budget)
+        : connectStdioServer(name, config, defaultCwd, options, budget);
+    return options.budget
+        ? connect(options.budget)
+        : withStartupBudget(name, resolveStartupTimeoutMs(config), connect);
 }
 /**
  * Call a tool on a connected server. Returns the result text or throws.

package/dist/app/mcp/index.js

@@ -2,10 +2,11 @@
  * MCP client manager — composition root for the MCP subsystem.
  */
 import { log } from '../../shared/logging/agent-log.js';
+import { getSecrets } from '../connectors/secret-store.js';
 import { resolveMcpAuthStatus } from './auth-status.js';
 import { buildCatalog, buildStatusLine } from './catalog.js';
 import { loadMcpConfig } from './config.js';
-import { closeConnection, connectServer, McpConnectionError } from './connection.js';
+import { closeConnection, connectServer, McpConnectionError, resolveStartupTimeoutMs, withStartupBudget } from './connection.js';
 import { getHostedMcpOAuthProviderId } from './hosted-oauth-id.js';
 import { registerHostedMcpOAuthProviders, unregisterHostedMcpOAuthProviders } from './hosted-oauth-provider.js';
 import { createMcpDescribeTool } from './mcp-describe-tool.js';
@@ -20,6 +21,25 @@ function resolveDisplayedAuthStatus(connection, rawAuthStatus, failureKind) {
     }
     return rawAuthStatus;
 }
+/**
+ * Read every referenced connection secret in one asynchronous batch so that a
+ * slow keychain (PowerShell on managed Windows) neither blocks the event loop
+ * nor runs once per server. A failed batch is reported per server as a
+ * connection failure instead of masquerading as "no credentials".
+ */
+async function loadConnectionSecrets(servers, timeoutMs) {
+    const names = [
+        ...new Set(Object.values(servers)
+            .map((config) => config.connection)
+            .filter((name) => typeof name === 'string'))
+    ];
+    try {
+        return await getSecrets(names, timeoutMs);
+    }
+    catch (error) {
+        throw new McpConnectionError('connect_failed', `Could not read connection credentials from the keychain: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 export async function createMcpManager(options) {
     const servers = loadMcpConfig({
         cwd: options.cwd,
@@ -35,14 +55,28 @@ export async function createMcpManager(options) {
     const failureKinds = new Map();
     const authStatuses = new Map();
     let shutDown = false;
-    const results = await Promise.allSettled(serverNames.map(async (name) => {
-        authStatuses.set(name, await resolveMcpAuthStatus(name, servers[name], {
-            authStorage: options.authStorage,
-            mcpOAuthStore: options.mcpOAuthStore,
-            discovery: 'cached'
-        }));
-        const conn = await connectServer(name, servers[name], options.cwd, options.authStorage, options.mcpOAuthStore);
-        return { name, conn };
+    const startupTimeouts = serverNames.map((name) => resolveStartupTimeoutMs(servers[name]));
+    const connectionSecrets = loadConnectionSecrets(servers, Math.max(...startupTimeouts));
+    const startupMs = new Map();
+    const results = await Promise.allSettled(serverNames.map(async (name, index) => {
+        const config = servers[name];
+        const startedAt = Date.now();
+        try {
+            return await withStartupBudget(name, startupTimeouts[index], async (budget) => {
+                const secrets = config.connection ? await connectionSecrets : undefined;
+                authStatuses.set(name, await resolveMcpAuthStatus(name, config, {
+                    authStorage: options.authStorage,
+                    mcpOAuthStore: options.mcpOAuthStore,
+                    discovery: 'cached',
+                    connectionSecrets: secrets
+                }));
+                const conn = await connectServer(name, config, options.cwd, options.authStorage, options.mcpOAuthStore, { connectionSecrets: secrets, budget });
+                return { name, conn };
+            });
+        }
+        finally {
+            startupMs.set(name, Date.now() - startedAt);
+        }
     }));
     for (const [idx, result] of results.entries()) {
         if (result.status === 'fulfilled') {
@@ -113,6 +147,7 @@ export async function createMcpManager(options) {
                 : {}),
             toolCount: connection?.tools.length ?? 0,
             toolNames: connection?.tools.map((t) => t.name) ?? [],
+            startupMs: startupMs.get(name) ?? 0,
             ...(failure ? { error: failure } : {})
         };
     });

package/dist/app/mcp/types.d.ts

@@ -67,7 +67,7 @@ export interface McpHostedServerConfig {
 }
 export type McpServerConfig = McpStdioServerConfig | McpHostedServerConfig;
 export type McpAuthStatus = 'unsupported' | 'not_logged_in' | 'configured' | 'oauth';
-export type McpFailureKind = 'auth_required' | 'connect_failed';
+export type McpFailureKind = 'auth_required' | 'connect_failed' | 'startup_timeout';
 export declare function isHostedServerConfig(config: McpServerConfig): config is McpHostedServerConfig;
 export declare function isStdioServerConfig(config: McpServerConfig): config is McpStdioServerConfig;
 export type McpTransport = StdioClientTransport | StreamableHTTPClientTransport;
@@ -100,6 +100,8 @@ export interface McpServerStatus {
     oauthProviderName?: string;
     toolCount: number;
     toolNames: string[];
+    /** Wall-clock time the server's startup took, whether it connected or failed. */
+    startupMs: number;
     error?: string;
 }
 export interface McpManager {

package/dist/app/modes/ask/prompt.js

@@ -65,7 +65,7 @@ Generally speaking, unless it is for very simple requests, you should spawn para
 
 ## Tone and Style
 - Be clear and direct. Give enough context that the user understands what's happening and why
-- Reference cells/ranges frequently using Sheet!Range or Sheet!Cell format (e.g., "Summary!A1:B10", "Data!C5")
+- Reference cells/ranges frequently using Sheet!Range or Sheet!Cell format as plain text (e.g., Summary!A1:B10, Data!C5). Do not wrap them in markdown links.
 - No emojis unless requested. Avoid filler phrases
 `;
 // ---------------------------------------------------------------------------

package/dist/app/modes/manage/prompt.js

@@ -65,7 +65,7 @@ Launch verification subagent(s) in the background to check results against requi
 
 - **NEVER** write "based on your findings, implement X" — this pushes synthesis onto the subagent. YOU must synthesize research results and write precise instructions.
 - **NEVER** delegate understanding. Read subagent outputs, extract what matters, then write specific implementation instructions.
-- **NEVER** launch a single subagent for a task that could be parallelized. If 5 sheets need independent work, launch 5 subagents.
+- **NEVER** spawn a replacement until the original subagent has stopped, and never resume the original afterward.
 - **NEVER** give vague instructions like "fix the formatting" — specify which cells, which format, which style.
 
 ## Delegation Format

package/dist/app/providers/model-registry.d.ts

@@ -106,6 +106,7 @@ export interface ProviderConfigInput {
             cacheWrite: number;
         };
         contextWindow: number;
+        compactionThresholdTokens?: number;
         maxTokens: number;
         capabilities?: Model<Api>['capabilities'];
         headers?: Record<string, string>;

package/dist/app/providers/model-registry.js

@@ -575,6 +575,7 @@ export class ModelRegistry {
                     input: modelDef.input,
                     cost: modelDef.cost,
                     contextWindow: modelDef.contextWindow,
+                    compactionThresholdTokens: modelDef.compactionThresholdTokens,
                     maxTokens: modelDef.maxTokens,
                     capabilities: modelDef.capabilities,
                     headers,

package/dist/app/providers/model-resolver.js

@@ -59,6 +59,7 @@ function getDefaultModelCandidatesForProvider(provider) {
     if (provider === SHORTCUT_PROVIDER_ID) {
         return [
             SHORTCUT_OPENAI_MODEL_ID,
+            SHORTCUT_MODEL_ID.ClaudeFable51,
             SHORTCUT_MODEL_ID.ClaudeFable5,
             SHORTCUT_MODEL_ID.ClaudeOpus5
         ];