pi-code 1.0.24 → 1.0.26

package/extensions/hooks/index.ts

@@ -95,7 +95,7 @@ import { claudeToolInput, claudeToolName, claudeToolResponse, piToolOutput } fro
 import { formatHooksSummary, type HookCommand, type HookMatcher, type HooksConfig, hookFiles, isBackgroundHook, loadHooks, loadPluginHooks, readAllowedHttpHookUrls, readDisableAllHooks } from './config.js'
 import { blockedToolCall, jsonBlockVerdict, postToolFeedback, promptContext, runPreToolUse, runUserPromptSubmit, surfaceSystemMessages, tryParseJson } from './decisions.js'
 import { allCommands, matchingCommands, passesIfFilter } from './matcher.js'
-import { type HookRunner, type HookRunResult, runAgentHook, runHookCommand, runHttpHook, runMcpToolHook, runPromptHook, timeoutMs } from './runners.js'
+import { type HookRunner, type HookRunResult, runAgentHook, runHookCommand, runHttpHook, runMcpToolHook, runPromptHook, sessionEndTimeoutMs, timeoutMs } from './runners.js'
 
 export * from './config.js'
 export * from './decisions.js'
@@ -185,6 +185,16 @@ export default function hooksExtension(pi: ExtensionAPI) {
     if (ctx.thinkingLevel) common.effort = { level: ctx.thinkingLevel }
     return common
   }
+  /** Claude's prompt-hook `model` override, resolved against the models this user
+   * can run (exact id first, then a substring match); the session model otherwise. */
+  const resolveHookModel = (ctx: ExtensionContext, override: string | undefined): ExtensionContext['model'] => {
+    if (!override) return ctx.model
+    const available = (ctx as { modelRegistry?: { getAvailable?: () => ReadonlyArray<{ id: string; name?: string }> } }).modelRegistry?.getAvailable?.() ?? []
+    const needle = override.toLowerCase()
+    const match = available.find((model) => model.id.toLowerCase() === needle) ?? available.find((model) => model.id.toLowerCase().includes(needle) || model.name?.toLowerCase().includes(needle))
+    return (match as ExtensionContext['model']) ?? ctx.model
+  }
+
   /** Kills for background hooks still running; Claude kills async hooks at teardown,
    * so session_shutdown reaps anything left rather than let a hung hook pin the
    * event loop past a one-shot run's end. */
@@ -220,7 +230,7 @@ export default function hooksExtension(pi: ExtensionAPI) {
       const merged = { ...commonPayload(ctx), ...extra, ...(payload as Record<string, unknown>) }
       const dispatch = (onChild?: (kill: () => void) => void): Promise<HookRunResult> => {
         if (hook.type === 'http') return runHttpHook(hook, merged, ms, allowedHttpHookUrls)
-        if (hook.type === 'prompt') return runPromptHook(hook, merged, ctx.model, ms)
+        if (hook.type === 'prompt') return runPromptHook(hook, merged, resolveHookModel(ctx, hook.model), ms)
         if (hook.type === 'agent') return runAgentHook(hook, merged, ms, (ctx.model as { id?: string } | undefined)?.id)
         if (hook.type === 'mcp_tool') return runMcpToolHook(hook, merged, ms)
         return runHookCommand(hook.command, merged, ms, projectDir, hook.args, onChild)
@@ -483,6 +493,14 @@ export default function hooksExtension(pi: ExtensionAPI) {
       stopHookActive = false
       return
     }
+    // Claude: Stop does not run when the stoppage was a user interrupt; pi marks
+    // the aborted turn's final assistant message stopReason "aborted".
+    const turnMessages = (event as { messages?: Array<{ role: string; stopReason?: string }> }).messages ?? []
+    const lastAssistant = [...turnMessages].reverse().find((message) => message.role === 'assistant')
+    if (lastAssistant?.stopReason === 'aborted') {
+      stopHookActive = false
+      return
+    }
     // Claude's Stop payload carries the turn's final assistant text so a hook need
     // not re-read the transcript; included only when there is one.
     const lastText = lastAssistantText((event as { messages?: Array<{ role: string; content: unknown }> }).messages ?? [])
@@ -543,7 +561,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
 
   pi.on('session_shutdown', async (event, ctx) => {
     const reason = claudeSpelling(SESSION_END_REASON, event.reason)
-    const results = await runNotifyHooks(matchingCommands(config.SessionEnd, reason.names), { hook_event_name: 'SessionEnd', reason: reason.value }, boundRunner(ctx))
+    // SessionEnd rides Claude's short shared budget (see sessionEndTimeoutMs) so a
+    // slow hook cannot stall session exit, /new or /resume.
+    const sessionEndCommands = matchingCommands(config.SessionEnd, reason.names).filter((command) => passesIfFilter(command, undefined))
+    const runner = boundRunner(ctx)
+    const results = await Promise.all(sessionEndCommands.map((command) => runner(command, { hook_event_name: 'SessionEnd', reason: reason.value }, sessionEndTimeoutMs(command))))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
     // Claude kills async hooks still running at teardown; the session that spawned
     // these is over, and their delivery would target a disposed context anyway.

package/extensions/hooks/runners.ts

@@ -20,6 +20,12 @@ import { type HookCommand, httpUrlAllowed, isBackgroundHook } from './config.js'
 // raise their own per-hook `timeout`.
 const DEFAULT_TIMEOUT_S = 60
 
+/** Claude's per-type defaults where they are safe to mirror: 30s for `prompt`
+ * hooks and 60s for `agent` hooks. Command/http/mcp_tool keep the flat 60s
+ * documented divergence from Claude's 600 (a gated hook fails closed here, so ten
+ * minutes of default budget would wedge the turn). */
+const TYPE_DEFAULT_TIMEOUT_S: Record<string, number> = { prompt: 30, agent: 60 }
+
 export interface HookRunResult {
   code: number
   stdout: string
@@ -49,10 +55,20 @@ export function timeoutMs(command: HookCommand): number {
   // Non-positive values fall back to the default: a 0ms timer would fire before the
   // hook runs, and a timed-out PreToolUse hook fails closed, bricking the tool.
   const declared = command.timeout
-  const seconds = typeof declared === 'number' && declared > 0 ? Math.min(declared, MAX_TIMEOUT_S) : DEFAULT_TIMEOUT_S
+  const fallback = TYPE_DEFAULT_TIMEOUT_S[command.type ?? 'command'] ?? DEFAULT_TIMEOUT_S
+  const seconds = typeof declared === 'number' && declared > 0 ? Math.min(declared, MAX_TIMEOUT_S) : fallback
   return seconds * 1000
 }
 
+/** Claude's SessionEnd budget: hooks share 1.5 seconds so session exit (and /new,
+ * /resume) cannot stall on a slow hook; a declared per-hook `timeout` raises the
+ * budget to match, up to 60 seconds. */
+export function sessionEndTimeoutMs(command: HookCommand): number {
+  const declared = command.timeout
+  if (typeof declared === 'number' && declared > 0) return Math.min(declared, 60) * 1000
+  return 1500
+}
+
 /** Memory backstop for a runaway hook. A decision payload is orders of magnitude smaller. */
 const MAX_HOOK_OUTPUT = 1_000_000
 
@@ -217,7 +233,11 @@ export async function runPromptHook(hook: HookCommand, payload: unknown, model:
   if (!model) return { code: 1, stdout: '', stderr: 'no model available for prompt hook', timedOut: false }
   // A replacer function, so `$$`/`$&`/`` $` ``/`$'` inside the payload JSON are inserted
   // verbatim rather than read as replacement patterns (a Bash `echo $$` is a common trigger).
-  const prompt = substituteArguments(hook.prompt, payload)
+  // Claude: when $ARGUMENTS is not present, the input JSON is appended to the
+  // prompt, so the model never evaluates blind.
+  const template = hook.prompt ?? ''
+  const withInput = template.includes('$ARGUMENTS') ? template : `${template}\n\n$ARGUMENTS`
+  const prompt = substituteArguments(withInput, payload)
   const signal = AbortSignal.timeout(timeoutMs)
   try {
     const { text: answer } = await completeText(model, prompt, { system: PROMPT_HOOK_SYSTEM, maxTokens: 512, signal })

package/extensions/internal/plugins.ts

@@ -180,7 +180,9 @@ function resolvePlugin(home: string, cacheDir: string, marketplace: string, plug
   const root = path.join(cacheDir, marketplace, pluginDir, version)
   const manifest = readJson(path.join(root, '.claude-plugin', 'plugin.json'))
   const name = typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : pluginDir
-  const id = qualified.replace(/[^A-Za-z0-9]+/g, '-')
+  // Claude: "{id} is the plugin identifier with characters outside a-z, A-Z, 0-9,
+  // _, and - replaced by -", one dash per character, underscores kept.
+  const id = qualified.replace(/[^A-Za-z0-9_-]/g, '-')
   const userConfig = configs[qualified] ?? configs[pluginDir] ?? configs[name]
   return { name, root, dataDir: path.join(claudeConfigDir(home), 'plugins', 'data', id), manifest, ...(userConfig ? { userConfig } : {}) }
 }

package/extensions/mcp/config.ts

@@ -99,13 +99,34 @@ export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
  */
 export function loadUserScope(home: string, cwd: string): Record<string, ServerConfig> {
   const servers = loadConfigFrom(userConfigPaths(home))
+  Object.assign(servers, projectRecord(home, cwd).mcpServers ?? {})
+  return servers
+}
+
+/** The per-project record for `cwd` in ~/.claude.json, or an empty one when the file
+ * is missing, invalid, or has no entry for this project. */
+function projectRecord(home: string, cwd: string): { mcpServers?: Record<string, ServerConfig>; disabledMcpServers?: unknown } {
   try {
     const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath(home), 'utf-8'))
-    Object.assign(servers, claudeJson.projects?.[cwd]?.mcpServers ?? {})
+    return claudeJson.projects?.[cwd] ?? {}
   } catch {
-    // missing or invalid ~/.claude.json: the top-level user servers already loaded
+    return {}
   }
-  return servers
+}
+
+/** Names the local scope defines for this project. Claude's precedence is local over
+ * project over user, so a local name must also outrank a project .mcp.json entry. */
+export function localScopeServerNames(home: string, cwd: string): Set<string> {
+  return new Set(Object.keys(projectRecord(home, cwd).mcpServers ?? {}))
+}
+
+/** The per-project `disabledMcpServers` toggle list from ~/.claude.json: Claude's /mcp
+ * panel records a server toggled off here (an opt-out list for user-configured and
+ * plugin servers) and does not connect to it. The `enabledMcpServers` opt-in list
+ * covers only default-off built-in servers, which pi-code has none of. */
+export function disabledServerNames(home: string, cwd: string): Set<string> {
+  const listed = projectRecord(home, cwd).disabledMcpServers
+  return new Set(Array.isArray(listed) ? listed.filter((entry): entry is string => typeof entry === 'string') : [])
 }
 
 /** The mcpServers one plugin declares, parsed WITHOUT substitution: an inline map on
@@ -115,18 +136,22 @@ export function loadUserScope(home: string, cwd: string): Record<string, ServerC
  * the parse and headersHelper can be shielded. */
 function rawPluginServerEntries(plugin: InstalledPlugin): Record<string, unknown> {
   const declared = plugin.manifest.mcpServers
-  // An inline map of name -> config; an array is not a valid mcpServers map (it
-  // would register a server named '0'), so it falls through to the path branch.
+  // An inline map of name -> config. The manifest field is string|array|object per
+  // Claude's plugin reference; an array lists config file paths, merged in order.
   if (declared !== null && typeof declared === 'object' && !Array.isArray(declared)) {
     return { ...(declared as Record<string, unknown>) }
   }
-  const file = path.resolve(plugin.root, typeof declared === 'string' ? declared : '.mcp.json')
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
-    return parsed.mcpServers ?? {}
-  } catch {
-    return {}
+  const paths = Array.isArray(declared) ? declared.filter((entry): entry is string => typeof entry === 'string') : [typeof declared === 'string' ? declared : '.mcp.json']
+  const servers: Record<string, unknown> = {}
+  for (const entry of paths) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(path.resolve(plugin.root, entry), 'utf-8'))
+      Object.assign(servers, parsed.mcpServers ?? {})
+    } catch {
+      // Malformed or missing JSON contributes no entries.
+    }
   }
+  return servers
 }
 
 /** Every string in the value mapped through `substitute`, arrays and objects walked. */
@@ -169,7 +194,8 @@ function substitutePathPluginVars(text: string, plugin: InstalledPlugin): string
  * tools alias as mcp__plugin_<plugin>_<server>__<tool> for hook matchers, as
  * Claude scopes them. */
 export function loadPluginServers(plugins: InstalledPlugin[], projectDir?: string): Record<string, ServerConfig> {
-  const fold = (name: string): string => name.replaceAll('-', '_')
+  // Claude keeps hyphens in the alias; only characters outside A-Za-z0-9_- fold to _.
+  const fold = (name: string): string => name.replace(/[^A-Za-z0-9_-]/g, '_')
   const servers: Record<string, ServerConfig> = {}
   for (const plugin of plugins) {
     for (const [name, config] of Object.entries(rawPluginServerEntries(plugin))) {

package/extensions/mcp/index.ts

@@ -43,11 +43,11 @@ import { installedPlugins } from '../internal/plugins.js'
 import { isProjectApproved, isProjectApprovedSilently } from '../internal/project-approval.js'
 import { repoRoot } from '../internal/project-root.js'
 import { claudeSettingsChain } from '../internal/settings-chain.js'
-import { loadConfigFrom, loadPluginServers, loadUserScope, projectConfigPaths, type ServerConfig, warnOnTypelessUrl } from './config.js'
+import { disabledServerNames, loadConfigFrom, loadPluginServers, loadUserScope, localScopeServerNames, projectConfigPaths, type ServerConfig, warnOnTypelessUrl } from './config.js'
 import { collectServerResourceEntries, listAllPrompts, listAllTools, type McpToolInfo, resourceServerFilter } from './listing.js'
 import { formatPromptCommandName, formatToolName, type McpContentBlock, type McpPromptInfo, mapContent, mapPromptArguments, normalizeSchema, promptMessageContent } from './mapping.js'
 import { applyServerPolicy, loadManagedMcpServers, type McpPolicy, mcpAllowDeny, projectServerPolicy, splitByPolicy } from './policy.js'
-import { type AuthUi, callRequestOptions, callTimeoutMs, connect, connectTimeoutMs, withTimeout } from './transport.js'
+import { type AuthUi, callRequestOptions, callTimeoutMs, connect, connectTimeoutMs, type ServerCallTuning, serverCallTuning, withTimeout } from './transport.js'
 
 export { managedSettingsPath, setManagedSettingsPath } from '../internal/managed-settings.js'
 // Re-exports for consumers: the module split keeps the extension's public surface
@@ -84,11 +84,19 @@ function authUiFor(ctx: ExtensionContext): AuthUi | undefined {
 export default async function mcpExtension(pi: ExtensionAPI) {
   const clients = new Map<string, Client>()
   const status = new Map<string, { state: string; tools: number }>()
+  // Config per server name, kept for call-time timeout tuning: the idle tier follows
+  // the transport kind, and a declared per-server timeout governs the wall budget.
+  const serverConfigs = new Map<string, ServerConfig>()
+  const callTuning = (name: string): ServerCallTuning => {
+    const config = serverConfigs.get(name)
+    return config ? serverCallTuning(config) : {}
+  }
   // Let other extensions (hooks' mcp_tool type) call a connected server's tool.
   setMcpToolCaller(async (server, tool, input) => {
     const client = clients.get(server)
     if (!client) throw new Error(`MCP server "${server}" is not connected`)
-    const result = await client.callTool({ name: tool, arguments: input }, undefined, callRequestOptions(callTimeoutMs()))
+    const tuning = callTuning(server)
+    const result = await client.callTool({ name: tool, arguments: input }, undefined, callRequestOptions(tuning.serverTimeoutMs ?? callTimeoutMs(), tuning))
     const text = mapContent(result.content as McpContentBlock[], result.structuredContent)
       .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
       .map((part) => part.text)
@@ -138,9 +146,9 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           // own default request timeout is 60s and would otherwise reject first. The outer
           // race uses the wall budget, never the idle window, so a progressing call is not
           // cut off at the idle timeout.
-          const declared = typeof config.timeout === 'number' && config.timeout >= 1000 ? config.timeout : undefined
-          const wall = declared ?? callTimeoutMs()
-          const result = await withTimeout(current.callTool({ name: tool.name, arguments: params as Record<string, unknown> }, undefined, callRequestOptions(wall)), wall, toolName)
+          const tuning = serverCallTuning(config)
+          const wall = tuning.serverTimeoutMs ?? callTimeoutMs()
+          const result = await withTimeout(current.callTool({ name: tool.name, arguments: params as Record<string, unknown> }, undefined, callRequestOptions(wall, tuning)), wall, toolName)
           const content = mapContent(result.content as McpContentBlock[], result.structuredContent)
           const details: { error?: string } = {}
           if (result.isError) {
@@ -193,7 +201,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
             const params: { name: string; arguments?: Record<string, string> } = { name: prompt.name }
             if (Object.keys(promptArgs).length > 0) params.arguments = promptArgs
             const wall = callTimeoutMs()
-            const result = await withTimeout(current.getPrompt(params, callRequestOptions(wall)), wall, commandName)
+            const result = await withTimeout(current.getPrompt(params, callRequestOptions(wall, callTuning(name))), wall, commandName)
             // The prompt drives a turn exactly the way a custom slash command does
             // (see commands.ts), carrying its image blocks through. A prompt that
             // yields no content is reported rather than sent as an empty turn.
@@ -280,7 +288,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
         const client = clients.get(server)
         if (!client) throw new Error(`MCP server "${server}" is not connected`)
         const wall = callTimeoutMs()
-        const result = await withTimeout(client.readResource({ uri }, callRequestOptions(wall)), wall, `read ${uri}`)
+        const result = await withTimeout(client.readResource({ uri }, callRequestOptions(wall, callTuning(server))), wall, `read ${uri}`)
         const blocks = (result.contents as Array<{ uri: string; text?: string; blob?: string; mimeType?: string }>).map((entry): McpContentBlock => {
           if (typeof entry.text === 'string') return { type: 'resource', resource: { uri: entry.uri, text: entry.text } }
           if (entry.blob && entry.mimeType?.startsWith('image/')) return { type: 'image', data: entry.blob, mimeType: entry.mimeType }
@@ -341,6 +349,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
       // Seed in config order before connecting: parallel connects settle in completion
       // order, and /mcp plus the session summary iterate the map's insertion order.
       status.set(name, { state: 'connecting', tools: 0 })
+      serverConfigs.set(name, config)
       pending.push([name, config])
     }
     await Promise.all(
@@ -424,9 +433,12 @@ export default async function mcpExtension(pi: ExtensionAPI) {
    * or whose transport dropped, without duplicate-name warnings. */
   async function connectNormalScopes(ctx: ExtensionContext, policy: McpPolicy, authUi?: AuthUi): Promise<void> {
     // Plugin servers merge under the user scope (plugins are user-installed);
-    // the user's own entry wins a name clash with a plugin's.
+    // the user's own entry wins a name clash with a plugin's. A server toggled off
+    // in ~/.claude.json's per-project disabledMcpServers list never connects.
     const pluginServers = loadPluginServers(installedPlugins(os.homedir()), repoRoot(ctx.cwd) ?? ctx.cwd)
-    const scoped = applyServerPolicy({ ...pluginServers, ...loadUserScope(os.homedir(), ctx.cwd) }, policy)
+    const disabled = disabledServerNames(os.homedir(), ctx.cwd)
+    const merged = Object.fromEntries(Object.entries({ ...pluginServers, ...loadUserScope(os.homedir(), ctx.cwd) }).filter(([name]) => !disabled.has(name)))
+    const scoped = applyServerPolicy(merged, policy)
     // Claude's precedence is project over user for a duplicate name. A project .mcp.json
     // server only outranks the user's own when it will actually connect (the user already
     // consented to it, or an approved project's), so a merely-present untrusted project
@@ -436,7 +448,12 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // The stored project decision, read without prompting: consent recorded inside
     // the project only counts once the project itself has been approved.
     const projectPolicy = projectServerPolicy(ctx.cwd, os.homedir(), isProjectApprovedSilently(ctx))
-    const { consented, gated } = splitByPolicy(applyServerPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), policy), projectPolicy)
+    const { consented: consentedRaw, gated } = splitByPolicy(applyServerPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), policy), projectPolicy)
+    // Claude's scope precedence is local over project: a name the local scope defines
+    // stays with the local (user-side) definition, so the project's entry is dropped
+    // here rather than allowed to shadow it.
+    const localNames = localScopeServerNames(os.homedir(), ctx.cwd)
+    const consented = Object.fromEntries(Object.entries(consentedRaw).filter(([name]) => !localNames.has(name)))
     const projectWinners = new Set(Object.keys(consented))
     const userServers = Object.fromEntries(Object.entries(scoped).filter(([name]) => !clients.has(name) && !projectWinners.has(name)))
     // The consented project servers carry no ordering dependency on the user scope:

package/extensions/mcp/mapping.ts

@@ -5,19 +5,19 @@
  */
 
 import { DEFAULT_MAX_BYTES } from '@earendil-works/pi-coding-agent'
-import { splitArgs } from '../internal/command-file.js'
 import { capForContext } from '../internal/output-guard.js'
 
 export function formatToolName(server: string, tool: string): string {
   return `${server}_${tool}`.replaceAll('-', '_')
 }
 
-/** Claude exposes server prompts as /mcp__<server>__<prompt> slash commands. Both
- * names normalize like formatToolName, extended to spaces: dashes and spaces each
- * become an underscore. */
+/** Claude exposes server prompts as /mcp__<server>__<prompt> slash commands: any
+ * character in the server name outside A-Za-z0-9_- becomes an underscore (hyphens
+ * stay), and the prompt name is used as the server declares it. Divergence: pi
+ * dispatches commands on the first whitespace-delimited token, so whitespace in the
+ * prompt name also folds to an underscore or the command would be unreachable. */
 export function formatPromptCommandName(server: string, prompt: string): string {
-  const normalize = (name: string): string => name.replace(/[\s-]/g, '_')
-  return `mcp__${normalize(server)}__${normalize(prompt)}`
+  return `mcp__${server.replace(/[^A-Za-z0-9_-]/g, '_')}__${prompt.replace(/\s/g, '_')}`
 }
 
 export interface McpPromptArgumentInfo {
@@ -32,17 +32,16 @@ export interface McpPromptInfo {
   arguments?: McpPromptArgumentInfo[]
 }
 
-/** Claude passes prompt arguments space-separated after the command. Tokens map
- * positionally onto the declared arguments, split the way slash-command args are
- * (quoted runs stay together); the last declared argument absorbs any trailing
- * tokens so free text at the end is not silently dropped. Declared arguments with
- * no token are omitted, and the server enforces its own `required`. */
+/** Claude passes prompt arguments space-separated after the command and "splits the
+ * arguments on whitespace, so each argument is a single token": no quote handling,
+ * one token per declared argument, extra trailing tokens dropped. Declared arguments
+ * with no token are omitted, and the server enforces its own `required`. */
 export function mapPromptArguments(declared: ReadonlyArray<{ name: string }> | undefined, args: string): Record<string, string> {
-  const tokens = splitArgs(args)
+  const tokens = args.split(/\s+/).filter((token) => token !== '')
   const names = (declared ?? []).map((argument) => argument.name)
   const mapped: Record<string, string> = {}
   for (let index = 0; index < names.length && index < tokens.length; index++) {
-    mapped[names[index]] = index === names.length - 1 ? tokens.slice(index).join(' ') : tokens[index]
+    mapped[names[index]] = tokens[index]
   }
   return mapped
 }

package/extensions/mcp/transport.ts

@@ -17,38 +17,61 @@ import { FileOAuthProvider } from '../internal/mcp-oauth.js'
 import { expandCwd, interpolateEnv, type ServerConfig, type StdioServerConfig } from './config.js'
 import { runInteractiveOAuth, serializeInteractiveOAuth } from './oauth-flow.js'
 
-const DEFAULT_CONNECT_TIMEOUT_MS = 10_000
+// Claude's MCP_TIMEOUT default: 30 seconds per connect attempt.
+const DEFAULT_CONNECT_TIMEOUT_MS = 30_000
 // Claude's MCP_TOOL_TIMEOUT default is effectively hours: the per-call wall-clock budget
 // is only a ceiling, and the idle timeout below is the real guard. 4h matches that model,
 // so a legitimately slow-but-progressing tool is not killed at the old 2 minutes.
 const DEFAULT_CALL_TIMEOUT_MS = 14_400_000
 // The idle timeout: the longest a call may go with no response or progress before it is
-// abandoned. Claude uses a separate idle guard (minutes) rather than the hours-long
-// wall-clock budget; the SDK resets this window on every progress notification.
+// abandoned. Claude uses a separate idle guard rather than the hours-long wall-clock
+// budget, defaulting to five minutes for remote transports and 30 minutes for stdio
+// servers; the SDK resets this window on every progress notification.
 const DEFAULT_CALL_IDLE_TIMEOUT_MS = 300_000
+const DEFAULT_STDIO_CALL_IDLE_TIMEOUT_MS = 1_800_000
+
+/** Claude's numeric env vars accept scientific notation and digit-separator spellings
+ * (2e3 as 2000, 64_000 as 64000). A non-numeric value is undefined, not zero. */
+function parseNumericEnv(raw: string): number | undefined {
+  const cleaned = raw.replaceAll('_', '')
+  if (cleaned.trim() === '') return undefined
+  const value = Number(cleaned)
+  return Number.isFinite(value) ? Math.floor(value) : undefined
+}
 
 /** A positive-integer env override, or the default when unset or unparseable. */
 function envTimeout(name: string, fallback: number): number {
   const raw = process.env[name]
   if (raw === undefined) return fallback
-  const value = Number.parseInt(raw, 10)
-  return Number.isInteger(value) && value > 0 ? value : fallback
+  const value = parseNumericEnv(raw)
+  return value !== undefined && value > 0 ? value : fallback
 }
 
 // Claude honors MCP_TIMEOUT (connect) and MCP_TOOL_TIMEOUT (per-call), both in ms.
 export const connectTimeoutMs = (): number => envTimeout('MCP_TIMEOUT', DEFAULT_CONNECT_TIMEOUT_MS)
 export const callTimeoutMs = (): number => envTimeout('MCP_TOOL_TIMEOUT', DEFAULT_CALL_TIMEOUT_MS)
 
+/** Per-server inputs to the idle-window choice: the transport kind picks the default
+ * tier, and a per-server `timeout` of at least 1000 also floors the idle window. */
+export interface ServerCallTuning {
+  stdio?: boolean
+  serverTimeoutMs?: number
+}
+
 /** The idle timeout in ms: the longest a call may go with no response or progress before
- * it is abandoned, overridable by CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT, with 0 disabling it
- * (leaving only the wall-clock budget). Unlike envTimeout, an explicit 0 is honored as
- * "disabled" rather than falling back to the default. */
-function idleTimeoutMs(): number {
+ * it is abandoned. Defaults to Claude's tiers (five minutes remote, 30 minutes stdio),
+ * overridable by CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT, with 0 disabling it (leaving only
+ * the wall-clock budget). Unlike envTimeout, an explicit 0 is honored as "disabled"
+ * rather than falling back to the default. A per-server timeout of at least 1000 floors
+ * the enabled window, so a server granted a long wall budget is not idled out earlier. */
+function idleTimeoutMs(tuning: ServerCallTuning): number {
   const raw = process.env.CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT
-  if (raw === undefined) return DEFAULT_CALL_IDLE_TIMEOUT_MS
-  const value = Number.parseInt(raw, 10)
-  if (value === 0) return 0
-  return Number.isInteger(value) && value > 0 ? value : DEFAULT_CALL_IDLE_TIMEOUT_MS
+  const override = raw === undefined ? undefined : parseNumericEnv(raw)
+  if (override === 0) return 0
+  const tierDefault = tuning.stdio ? DEFAULT_STDIO_CALL_IDLE_TIMEOUT_MS : DEFAULT_CALL_IDLE_TIMEOUT_MS
+  const base = override !== undefined && override > 0 ? override : tierDefault
+  const floor = tuning.serverTimeoutMs !== undefined && tuning.serverTimeoutMs >= 1000 ? tuning.serverTimeoutMs : 0
+  return Math.max(base, floor)
 }
 
 /** The SDK RequestOptions for a call under pi's two-tier timeout: a wall-clock ceiling and,
@@ -60,12 +83,20 @@ function idleTimeoutMs(): number {
  * wall budget, only the wall budget applies. The outer withTimeout race is a wall-clock
  * backstop and must be raced against `wall`, never the idle window, so a legitimately
  * progressing call is not cut off. */
-export function callRequestOptions(wall: number): { timeout: number; resetTimeoutOnProgress?: boolean; maxTotalTimeout?: number; onprogress?: () => void } {
-  const idle = idleTimeoutMs()
+export function callRequestOptions(wall: number, tuning: ServerCallTuning = {}): { timeout: number; resetTimeoutOnProgress?: boolean; maxTotalTimeout?: number; onprogress?: () => void } {
+  const idle = idleTimeoutMs(tuning)
   if (idle === 0 || idle >= wall) return { timeout: wall }
   return { timeout: idle, resetTimeoutOnProgress: true, maxTotalTimeout: wall, onprogress: () => {} }
 }
 
+/** The tuning one server's config yields: its transport kind, and its declared
+ * per-server timeout. Per Claude, timeout values below 1000 are ignored and fall
+ * through to MCP_TOOL_TIMEOUT. */
+export function serverCallTuning(config: ServerConfig): ServerCallTuning {
+  const declared = typeof config.timeout === 'number' && config.timeout >= 1000 ? config.timeout : undefined
+  return { stdio: isStdio(config), ...(declared !== undefined ? { serverTimeoutMs: declared } : {}) }
+}
+
 /** Claude reports a config entry that has a url but no type as an error; pi-code
  * still connects (streamable HTTP with SSE fallback) but says the entry is wrong. */
 /** An inline bearerToken (interpolated) wins over bearerTokenEnv, which names an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",