pi-code 1.0.62 → 1.0.63

package/extensions/context-imports.ts

@@ -943,22 +943,25 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
     type: 'string',
   })
 
-  pi.on('session_start', async (_event, ctx) => {
-    // pi's ctx.reload() rebuilds extension instances, so this set never survives
-    // a reload anyway; a reload simply re-fires InstructionsLoaded once per file,
-    // which is fine, since a reload re-loads the instruction files.
-    announced.clear()
-    envCache = undefined
-    importMemo = undefined
-    localContexts = []
-    userContext = undefined
-    projectDotClaude = undefined
+  /** The session-scope memory session_start loads: the user's own CLAUDE.md, plus
+   * CLAUDE.local.md and ./.claude/CLAUDE.md from an approved project. Claude:
+   * CLAUDE_CODE_DISABLE_CLAUDE_MDS "prevent[s] loading any CLAUDE.md memory files
+   * into context, including user, project, and auto memory files", so a disabled run
+   * returns empty state and skips isProjectApproved's trust prompt entirely: there is
+   * nothing left for it to gate. Extracted so session_start itself stays a thin
+   * dispatcher; before_agent_start's own excluded() check covers pi's native files,
+   * which this cannot reach since pi loads those itself. */
+  async function loadSessionMemory(ctx: ExtensionContext): Promise<{ userContext?: { path: string; content: string }; localContexts: Array<{ path: string; content: string }>; projectDotClaude?: { path: string; content: string } }> {
+    if (process.env.CLAUDE_CODE_DISABLE_CLAUDE_MDS === '1') return { localContexts: [] }
 
     // ~/.claude/CLAUDE.md, Claude's user-scope memory. The user's own file, so no
     // project approval is required; a missing file simply leaves it unset.
     const userClaudeMd = path.join(claudeConfigDir(os.homedir()), 'CLAUDE.md')
     const userContent = readContextFile(userClaudeMd)
-    if (userContent !== undefined) userContext = { path: userClaudeMd, content: userContent }
+    const memory: { userContext?: { path: string; content: string }; localContexts: Array<{ path: string; content: string }>; projectDotClaude?: { path: string; content: string } } = {
+      userContext: userContent !== undefined ? { path: userClaudeMd, content: userContent } : undefined,
+      localContexts: [],
+    }
 
     // CLAUDE.local.md is Claude Code's personal sidecar of CLAUDE.md; pi's own loader
     // skips it. A cloned repo can ship one, so it is gated like other project config.
@@ -969,16 +972,30 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
     // ride the one approval decision.
     const candidates = ancestorFiles(ctx.cwd, 'CLAUDE.local.md')
     const dotClaudeMd = findNearestFile(ctx.cwd, path.join('.claude', 'CLAUDE.md'))
-    if ((candidates.length > 0 || dotClaudeMd !== null) && (await isProjectApproved(ctx))) {
-      for (const candidate of candidates) {
-        const content = readContextFile(candidate)
-        if (content !== undefined) localContexts.push({ path: candidate, content })
-      }
-      if (dotClaudeMd !== null) {
-        const content = readContextFile(dotClaudeMd)
-        if (content !== undefined) projectDotClaude = { path: dotClaudeMd, content }
-      }
+    if ((candidates.length === 0 && dotClaudeMd === null) || !(await isProjectApproved(ctx))) return memory
+
+    for (const candidate of candidates) {
+      const content = readContextFile(candidate)
+      if (content !== undefined) memory.localContexts.push({ path: candidate, content })
     }
+    if (dotClaudeMd !== null) {
+      const content = readContextFile(dotClaudeMd)
+      if (content !== undefined) memory.projectDotClaude = { path: dotClaudeMd, content }
+    }
+    return memory
+  }
+
+  pi.on('session_start', async (_event, ctx) => {
+    // pi's ctx.reload() rebuilds extension instances, so this set never survives
+    // a reload anyway; a reload simply re-fires InstructionsLoaded once per file,
+    // which is fine, since a reload re-loads the instruction files.
+    announced.clear()
+    envCache = undefined
+    importMemo = undefined
+    const memory = await loadSessionMemory(ctx)
+    localContexts = memory.localContexts
+    userContext = memory.userContext
+    projectDotClaude = memory.projectDotClaude
     // Read after the local-context flow so an approval it just recorded is honored.
     projectApproved = isProjectApprovedSilently(ctx)
     gatedFilesApproved = isGatedFileApproved(ctx)
@@ -1014,7 +1031,12 @@ export default function contextImportsExtension(pi: ExtensionAPI) {
       envCache = { cwd, managed: managedNow, excludeGlobs: readClaudeMdExcludes(claudeMdExcludeFiles(cwd, home, projectApproved), managedNow), projectRoot: repoRoot(cwd) ?? cwd }
     }
     const { managed, excludeGlobs, projectRoot } = envCache
-    const excluded = (absPath: string): boolean => isExcludedPath(absPath, excludeGlobs, home)
+    // CLAUDE_CODE_DISABLE_CLAUDE_MDS also covers pi's own auto-discovered native context
+    // files ("including... auto memory files"), which session_start's gate cannot reach
+    // since pi loads them itself. Routing through the exclusion path already used for
+    // claudeMdExcludes drops the block, strips the InstructionsLoaded event, and skips
+    // import expansion for it, exactly as an excluded file already does.
+    const excluded = (absPath: string): boolean => process.env.CLAUDE_CODE_DISABLE_CLAUDE_MDS === '1' || isExcludedPath(absPath, excludeGlobs, home)
 
     // claudeMdExcludes drops an excluded file's block from the assembled prompt and
     // from import expansion; surviving blocks get block-level comments stripped.

package/extensions/git-checkpoint.ts

@@ -331,6 +331,10 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   pi.on('turn_start', async () => {
     if (!runNeedsSnapshot) return
     runNeedsSnapshot = false
+    // Claude: "Set to 1 to disable file checkpointing. The /rewind command will not be
+    // able to restore code changes." No snapshot means turn_end's `if (!snap) return`
+    // always fires, so no checkpoint is ever recorded.
+    if (process.env.CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING === '1') return
     pending = await snapshot()
   })
 

package/extensions/hooks/index.ts

@@ -283,7 +283,7 @@ export default function hooksExtension(pi: ExtensionAPI) {
         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, args: hook.args, onChild, shell: hook.shell, plugin: hook.pluginRoot !== undefined && hook.pluginDataDir !== undefined ? { root: hook.pluginRoot, dataDir: hook.pluginDataDir } : undefined })
+        return runHookCommand(hook.command, merged, ms, { projectDir, args: hook.args, onChild, shell: hook.shell, plugin: hook.pluginRoot !== undefined && hook.pluginDataDir !== undefined ? { root: hook.pluginRoot, dataDir: hook.pluginDataDir } : undefined, sessionId: merged.session_id as string | undefined })
       }
       // Claude's `once` (skill-frontmatter hooks only): removed after the first
       // successful run; a failure, block, or timeout leaves it in place.

package/extensions/hooks/runners.ts

@@ -56,6 +56,10 @@ export interface HookSpawnOptions {
   shell?: string
   /** The declaring plugin's paths, exported to the child. */
   plugin?: { root: string; dataDir: string }
+  /** Claude: "set automatically to the current session ID in ... hook command
+   * subprocesses ... this matches the session_id field in the hook JSON input and
+   * is updated on /clear." Absent in a stub context with no session manager. */
+  sessionId?: string
 }
 
 export type HookCommandRunner = (command: string, payload: unknown, timeoutMs: number, options?: HookSpawnOptions) => Promise<HookRunResult>
@@ -136,7 +140,7 @@ function shellInvocation(command: string, shell: string | undefined): { file: st
   return resolved ? { file: resolved.file, spawnArgs: resolved.argsFor(command) } : undefined
 }
 
-export const runHookCommand: HookCommandRunner = (command, payload, timeoutMs, { projectDir, args, onChild, shell, plugin } = {}) =>
+export const runHookCommand: HookCommandRunner = (command, payload, timeoutMs, { projectDir, args, onChild, shell, plugin, sessionId } = {}) =>
   new Promise((resolve) => {
     // /bin/sh by absolute path off Windows, so the shell can't be resolved through an
     // attacker-controlled PATH; on Windows the resolver follows Claude's documented Git
@@ -150,6 +154,11 @@ export const runHookCommand: HookCommandRunner = (command, payload, timeoutMs, {
     // detection cannot see the captured terminal.
     const env: NodeJS.ProcessEnv = { ...process.env, CLAUDECODE: '1', CLAUDE_CODE_CHILD_SESSION: '1' }
     if (projectDir) env.CLAUDE_PROJECT_DIR = projectDir
+    // Claude: "Claude Code sets this to its own process ID in the subprocesses it
+    // spawns: Bash and PowerShell tool commands and hook commands." Set unconditionally,
+    // since every hook child qualifies.
+    env.CLAUDE_PID = String(process.pid)
+    if (sessionId) env.CLAUDE_CODE_SESSION_ID = sessionId
     // Claude: "All three are exported as environment variables to hook processes and to
     // MCP and LSP server subprocesses", so a plugin script can read them rather than
     // depend on inline substitution. The data directory is "created on first reference",

package/extensions/internal/mcp-oauth.ts

@@ -72,6 +72,14 @@ function storeFileFor(serverName: string, endpoint?: string): string {
   return path.join(getAgentDir(), 'mcp-oauth', `${safe}-${digest}.json`)
 }
 
+/** MCP_OAUTH_CALLBACK_PORT parsed, or undefined when unset or not a plain integer. */
+function envCallbackPort(): number | undefined {
+  const raw = process.env.MCP_OAUTH_CALLBACK_PORT
+  if (raw === undefined || raw.trim() === '') return undefined
+  const parsed = Number(raw)
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+}
+
 export class FileOAuthProvider implements OAuthClientProvider {
   private readonly storePath: string
   private readonly data: StoredAuth
@@ -107,15 +115,19 @@ export class FileOAuthProvider implements OAuthClientProvider {
   }
 
   /** The configured callbackPort alone, absent when only a remembered port exists.
-   * The caller needs the two apart: a configured port is a hard requirement. */
+   * The caller needs the two apart: a configured port is a hard requirement. Falls
+   * back to MCP_OAUTH_CALLBACK_PORT, Claude's "alternative to --callback-port when
+   * adding an MCP server with pre-configured credentials"; pi-code has no `mcp add`
+   * command, so the env var applies as a default for any server naming no port of
+   * its own rather than only ones added that way. */
   configuredRedirectPort(): number | undefined {
-    return this.oauth?.callbackPort
+    return this.oauth?.callbackPort ?? envCallbackPort()
   }
 
   /** The configured callbackPort (Claude: for pre-registered redirect URIs), else
    * the port a prior login registered, so a re-login can bind the same one. */
   savedRedirectPort(): number | undefined {
-    return this.oauth?.callbackPort ?? this.data.redirectPort
+    return this.oauth?.callbackPort ?? envCallbackPort() ?? this.data.redirectPort
   }
 
   /** Record the loopback port the callback server actually bound; the redirect

package/extensions/internal/path-rules.ts

@@ -96,10 +96,29 @@ function bracketEnd(pattern: string, start: number): number {
 
 /** A bracket expression body as a regex character class, escaping regex-relevant
  * characters while keeping `-` ranges; a leading `!` (or `^`) negates. */
-function bracketClass(body: string): string {
+function bracketClass(body: string): string | null {
   const negated = body.startsWith('!') || body.startsWith('^')
   const members = (negated ? body.slice(1) : body).replace(/[\\\]^]/g, (ch) => `\\${ch}`)
-  return `[${negated ? '^' : ''}${members}]`
+  const source = `[${negated ? '^' : ''}${members}]`
+  // A range whose endpoints descend, `["- ]` for instance, is not a character class
+  // JavaScript will build: RegExp throws "Range out of order in character class". The
+  // `-` cannot simply be escaped, since `[a-z]` is the whole point of the syntax, so the
+  // class is validated by construction and an unbuildable one is treated exactly as an
+  // unterminated `[` already is: the pattern is invalid and matches nothing. Without
+  // this the throw escaped compileGlobs, which does not catch, and took the permission
+  // check that called it with it.
+  return isBuildableClass(source) ? source : null
+}
+
+/** Whether JavaScript will build this character class. Asking RegExp is the only
+ * faithful test: the invalid forms are its rules, not ones worth re-deriving here. */
+function isBuildableClass(source: string): boolean {
+  try {
+    new RegExp(source)
+    return true
+  } catch {
+    return false
+  }
 }
 
 /** A `*` run starting at `i`: a double star followed by a slash spans whole
@@ -114,39 +133,33 @@ function translateStar(pattern: string, i: number): { source: string; next: numb
   return { source: '[^/]*', next: i + 1 }
 }
 
+/** The regex source for the construct at `i` and the index after it, or null when the
+ * pattern is invalid there and so matches nothing. */
+function translateAt(pattern: string, i: number): { source: string; next: number } | null {
+  const ch = pattern[i]
+  // Claude: to match a literal bracket, escape it; the escape consumes both chars.
+  if (ch === '\\' && (pattern[i + 1] === '[' || pattern[i + 1] === ']')) return { source: escapeRegExp(pattern[i + 1]), next: i + 2 }
+  // Claude: `[` starts a bracket expression such as `[abc]`; a `[` that cannot be read
+  // as one, or a body that is not a buildable class, makes the pattern invalid.
+  if (ch === '[') {
+    const end = bracketEnd(pattern, i)
+    if (end === -1) return null
+    const cls = bracketClass(pattern.slice(i + 1, end))
+    return cls === null ? null : { source: cls, next: end + 1 }
+  }
+  if (ch === '*') return translateStar(pattern, i)
+  if (ch === '?') return { source: '[^/]', next: i + 1 }
+  return { source: escapeRegExp(ch), next: i + 1 }
+}
+
 function translateGlob(pattern: string): string | null {
   let out = ''
   let i = 0
   while (i < pattern.length) {
-    const ch = pattern[i]
-    // Claude: to match a literal bracket, escape it; the escape consumes both chars.
-    if (ch === '\\' && (pattern[i + 1] === '[' || pattern[i + 1] === ']')) {
-      out += escapeRegExp(pattern[i + 1])
-      i += 2
-      continue
-    }
-    // Claude: `[` starts a bracket expression such as `[abc]`; a `[` that cannot be
-    // read as one makes the pattern invalid, matching nothing.
-    if (ch === '[') {
-      const end = bracketEnd(pattern, i)
-      if (end === -1) return null
-      out += bracketClass(pattern.slice(i + 1, end))
-      i = end + 1
-      continue
-    }
-    if (ch === '*') {
-      const star = translateStar(pattern, i)
-      out += star.source
-      i = star.next
-      continue
-    }
-    if (ch === '?') {
-      out += '[^/]'
-      i += 1
-      continue
-    }
-    out += escapeRegExp(ch)
-    i += 1
+    const step = translateAt(pattern, i)
+    if (step === null) return null
+    out += step.source
+    i = step.next
   }
   return out
 }

package/extensions/internal/shell-resolve.ts

@@ -37,11 +37,22 @@ const isFile = (file: string): boolean => {
  * Windows spellings on win32, where powershell.exe ships with the OS. */
 const powershellCandidates = (platform: string): string[] => (platform === 'win32' ? ['pwsh', 'pwsh.exe', 'powershell.exe'] : ['pwsh'])
 
-/** First PowerShell binary found on PATH, or undefined when none is installed. */
-export function resolvePowershellBinary(platform: string = process.platform, env: Record<string, string | undefined> = process.env): string | undefined {
-  const dirs = (env.PATH ?? '').split(path.delimiter).filter(Boolean)
+/** First PowerShell binary found on PATH, or undefined when none is installed.
+ *
+ * A PATH entry that is the launch directory, or project tooling below it, is skipped
+ * for the same reason resolveGitBash skips one: a repository that ships `pwsh.exe`
+ * must not become the shell its own hooks and spans run through. Go made this the
+ * default in 1.19 (`os/exec` refuses a program resolved "relative to the current
+ * directory", returning ErrDot), and Windows offers NoDefaultCurrentDirectoryInExePath
+ * for it; node honors neither (nodejs/node#46264), so the check belongs here. */
+export function resolvePowershellBinary(platform: string = process.platform, env: Record<string, string | undefined> = process.env, cwd: string = process.cwd()): string | undefined {
+  // `env.Path` as well as `env.PATH`, matching resolveGitBash: process.env is
+  // case-insensitive on Windows, but an env object handed in by a caller or a test is
+  // whatever spelling it was built with, and the two resolvers must read it alike.
+  const dirs = (env.PATH ?? env.Path ?? '').split(path.delimiter).filter(Boolean)
   for (const candidate of powershellCandidates(platform)) {
     for (const dir of dirs) {
+      if (isProjectTooling(dir, cwd)) continue
       const full = path.join(dir, candidate)
       try {
         fs.accessSync(full, fs.constants.X_OK)
@@ -111,11 +122,11 @@ const powershellShell = (file: string): ResolvedShell => ({
  */
 export function resolveShell(preferred: string | undefined, platform: string = process.platform, env: Record<string, string | undefined> = process.env, cwd: string = process.cwd(), installRoots?: string[]): ResolvedShell | undefined {
   if (preferred === 'powershell') {
-    const powershell = resolvePowershellBinary(platform, env)
+    const powershell = resolvePowershellBinary(platform, env, cwd)
     if (powershell) return powershellShell(powershell)
   }
   const bash = bashBinary(platform, env, cwd, installRoots)
   if (bash) return bashShell(bash)
-  const powershell = resolvePowershellBinary(platform, env)
+  const powershell = resolvePowershellBinary(platform, env, cwd)
   return powershell ? powershellShell(powershell) : undefined
 }

package/extensions/mcp/index.ts

@@ -49,7 +49,7 @@ import { disabledServerNames, loadConfigFrom, loadPluginServers, loadUserScope,
 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, connectWithRetries, isUnauthorized, type ServerCallTuning, type SessionDirs, serverCallTuning, withTimeout } from './transport.js'
+import { type AuthUi, callRequestOptions, callTimeoutMs, connect, connectTimeoutMs, connectWithRetries, isUnauthorized, mcpConnectTimeoutMs, type ServerCallTuning, type SessionDirs, 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
@@ -563,6 +563,23 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     if (!projectConnected) projectConnected = await connectGatedProjectServers(ctx, gated, authUi)
   }
 
+  /** Publishes the current alias set and the connection banner. `'connecting'`
+   * servers are excluded from both connected and failed counts: they are neither,
+   * and while the non-blocking startup race below is still in flight some legitimately
+   * are. Called once right after startup (whether or not every server settled by
+   * then) and again when a still-connecting tail finishes, so a server that connects
+   * late still gets its aliases published and counted. */
+  function publishConnectionSummary(ctx: ExtensionContext): void {
+    pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
+    const connected = [...status.values()].filter((s) => s.state === 'connected')
+    const failed = [...status.entries()].filter(([, s]) => s.state !== 'connected' && s.state !== 'connecting')
+    if (connected.length > 0 || failed.length > 0) {
+      const total = connected.reduce((sum, s) => sum + s.tools, 0)
+      const failNote = failed.length > 0 ? `, ${failed.length} failed` : ''
+      ctx.ui.notify(`MCP: ${total} tools from ${connected.length} servers${failNote}`, failed.length > 0 ? 'warning' : 'info')
+    }
+  }
+
   pi.on('session_start', async (_event, ctx) => {
     // Reset the status map so /mcp and the banner reflect only this session's config: a
     // server present last session but not this one must not linger as "connected". The
@@ -579,7 +596,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     projectConnected = false
     // Claude answers roots/list with the session's launch directory and exports the
     // project root as CLAUDE_PROJECT_DIR to stdio servers; both derive from ctx.cwd.
-    sessionDirs = { projectDir: repoRoot(ctx.cwd) ?? ctx.cwd, launchDir: ctx.cwd }
+    sessionDirs = { projectDir: repoRoot(ctx.cwd) ?? ctx.cwd, launchDir: ctx.cwd, sessionId: ctx.sessionManager?.getSessionId?.() }
     const authUi = authUiFor(ctx)
     sessionAuthUi = authUi
     // The allow/deny lists filter every scope, including a managed-mcp.json set. They
@@ -592,21 +609,27 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // file leaves the normal scopes untouched; a present but corrupt file fails closed to an
     // empty set (see loadManagedMcpServers).
     const managed = loadManagedMcpServers()
-    if (managed !== null) {
-      await connectManagedExclusive(managed, policy, authUi)
-    } else {
-      await connectNormalScopes(ctx, policy, authUi)
-    }
-
-    pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
-
-    const connected = [...status.values()].filter((s) => s.state === 'connected')
-    const failed = [...status.entries()].filter(([, s]) => s.state !== 'connected')
-    if (connected.length > 0 || failed.length > 0) {
-      const total = connected.reduce((sum, s) => sum + s.tools, 0)
-      const failNote = failed.length > 0 ? `, ${failed.length} failed` : ''
-      ctx.ui.notify(`MCP: ${total} tools from ${connected.length} servers${failNote}`, failed.length > 0 ? 'warning' : 'info')
-    }
+    const connecting = managed !== null ? connectManagedExclusive(managed, policy, authUi) : connectNormalScopes(ctx, policy, authUi)
+    // Claude: "MCP startup is non-blocking by default: servers connect in the
+    // background and their tools become available as they finish." A slow or
+    // unreachable server no longer costs the whole session's startup its own
+    // MCP_TIMEOUT x retries; alwaysLoad-style forced waiting and the ToolSearch/
+    // WaitForMcpServers mechanism that lets the model itself wait on a pending
+    // server's tools are not implemented, so a call to a tool that has not
+    // registered yet still just finds no such tool, same as before it connected.
+    //
+    // Claude also states non-interactive mode "waits for still-pending servers
+    // before the first turn regardless of this variable", because a -p run has no
+    // later turn to react to late-arriving tools; a headless ctx (no UI) keeps the
+    // prior fully-blocking wait for the same reason.
+    const settled = !ctx.hasUI
+      ? await connecting.then(() => true)
+      : await withTimeout(connecting, mcpConnectTimeoutMs(), 'mcp startup').then(
+          () => true,
+          () => false,
+        )
+    publishConnectionSummary(ctx)
+    if (!settled) void connecting.then(() => publishConnectionSummary(ctx))
   })
 
   pi.on('session_shutdown', async () => {

package/extensions/mcp/transport.ts

@@ -55,6 +55,12 @@ function envTimeout(name: string, fallback: number): number {
 export const connectTimeoutMs = (): number => envTimeout('MCP_TIMEOUT', DEFAULT_CONNECT_TIMEOUT_MS)
 export const callTimeoutMs = (): number => envTimeout('MCP_TOOL_TIMEOUT', DEFAULT_CALL_TIMEOUT_MS)
 
+// Claude: "How long blocking MCP startup waits, in milliseconds, for the connection
+// batch before snapshotting the tool list (default: 5000)." Distinct from MCP_TIMEOUT,
+// which bounds one server's own connect attempt, not the whole startup batch.
+const DEFAULT_MCP_CONNECT_TIMEOUT_MS = 5000
+export const mcpConnectTimeoutMs = (): number => envTimeout('MCP_CONNECT_TIMEOUT_MS', DEFAULT_MCP_CONNECT_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 {
@@ -137,6 +143,9 @@ function isStdio(config: ServerConfig): config is StdioServerConfig {
 export interface SessionDirs {
   projectDir: string
   launchDir: string
+  /** Claude: "An MCP server subprocess retains the ID it was spawned with", so this
+   * is captured once here at connect time rather than re-read per call. */
+  sessionId?: string
 }
 
 /** A client that, like Claude, declares the roots capability and answers roots/list
@@ -191,6 +200,7 @@ function stdioEnv(config: StdioServerConfig, fill: (value: string) => string, se
   const env: Record<string, string> = { ...getDefaultEnvironment(), CLAUDECODE: '1' }
   for (const [key, value] of Object.entries(config.env ?? {})) env[key] = fill(value)
   if (session) env.CLAUDE_PROJECT_DIR = session.projectDir
+  if (session?.sessionId) env.CLAUDE_CODE_SESSION_ID = session.sessionId
   if (config.pluginRoot !== undefined) env.CLAUDE_PLUGIN_ROOT = config.pluginRoot
   // The data dir is "created on first reference"; handing the path to a server is that
   // reference, so the server does not have to mkdir it before using it.

package/extensions/question.ts

@@ -6,9 +6,14 @@
  * Multiple questions per call are not batched; ask sequentially.
  */
 
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext, Theme } from '@earendil-works/pi-coding-agent'
 import { Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth } from '@earendil-works/pi-tui'
 import { Type } from 'typebox'
+import { claudeConfigDir } from './internal/config-dir.js'
+import { readManagedSettings } from './internal/managed-settings.js'
 
 interface OptionWithDesc {
   label: string
@@ -24,6 +29,8 @@ interface QuestionDetails {
   answer: string | null
   wasCustom?: boolean
   multiSelect?: boolean
+  /** Auto-continued on askUserQuestionTimeout rather than answered or cancelled. */
+  timedOut?: boolean
 }
 
 // Options with labels and optional descriptions
@@ -70,6 +77,33 @@ function questionList(params: Partial<QuestionSpec> & { questions?: QuestionSpec
 const HEADER_MAX = 12
 export const shortHeader = (header: string | undefined): string | undefined => (header === undefined ? undefined : header.slice(0, HEADER_MAX))
 
+/** Claude's three accepted askUserQuestionTimeout spellings (`60s`, `5m`, `10m`), as
+ * milliseconds. Anything else, including unset, means no auto-continue. */
+export function parseAskUserQuestionTimeout(value: unknown): number | undefined {
+  if (typeof value !== 'string') return undefined
+  const match = /^(\d+)([sm])$/.exec(value.trim())
+  if (!match) return undefined
+  const amount = Number(match[1])
+  return match[2] === 's' ? amount * 1000 : amount * 60 * 1000
+}
+
+/** Claude scopes askUserQuestionTimeout to "User or managed": a project's own
+ * settings.json cannot set it, so a checked-out repository can never make the
+ * user's own dialogs auto-answer themselves. Managed wins over the user's file, as
+ * every managed setting does. `home` defaults to the real one and is a parameter
+ * only so a test can point it at a fixture without mocking node:os. */
+export function askUserQuestionTimeoutMs(home: string = os.homedir()): number | undefined {
+  const managed = readManagedSettings() as { askUserQuestionTimeout?: unknown }
+  const fromManaged = parseAskUserQuestionTimeout(managed.askUserQuestionTimeout)
+  if (fromManaged !== undefined) return fromManaged
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(home), 'settings.json'), 'utf-8')) as { askUserQuestionTimeout?: unknown }
+    return parseAskUserQuestionTimeout(parsed.askUserQuestionTimeout)
+  } catch {
+    return undefined
+  }
+}
+
 function checkbox(checked: boolean | undefined): string {
   if (checked === undefined) return ''
   return checked ? '[x] ' : '[ ] '
@@ -98,10 +132,13 @@ interface QuestionView {
   checked: boolean[]
   editor: Editor
   theme: Theme
+  /** Claude: "You see a countdown for the last 20 seconds." Undefined the rest of
+   * the idle window, and always when there is no configured timeout at all. */
+  countdownSeconds?: number
 }
 
 function buildQuestionLines(view: QuestionView): string[] {
-  const { width, question, header, options, optionIndex, editMode, multiSelect, checked, editor, theme } = view
+  const { width, question, header, options, optionIndex, editMode, multiSelect, checked, editor, theme, countdownSeconds } = view
   const lines: string[] = []
   const add = (s: string) => lines.push(truncateToWidth(s, width))
 
@@ -129,6 +166,9 @@ function buildQuestionLines(view: QuestionView): string[] {
 
   lines.push('')
   add(theme.fg('dim', navHint(editMode, multiSelect)))
+  if (countdownSeconds !== undefined) {
+    add(theme.fg('warning', ` Auto-continuing in ${countdownSeconds}s if idle · press any key to stay`))
+  }
   add(theme.fg('accent', '─'.repeat(width)))
 
   return lines
@@ -202,6 +242,11 @@ export default function question(pi: ExtensionAPI) {
         return new Text(theme.fg('warning', 'Cancelled'), 0, 0)
       }
 
+      if (details.timedOut) {
+        const already = details.answer ? theme.fg('muted', ` (already selected: ${details.answer})`) : ''
+        return new Text(theme.fg('warning', '⏱ Auto-continued (no response)') + already, 0, 0)
+      }
+
       if (details.wasCustom) {
         return new Text(theme.fg('success', '✓ ') + theme.fg('muted', '(wrote) ') + theme.fg('accent', details.answer), 0, 0)
       }
@@ -240,8 +285,10 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
 
   // ui.custom() is terminal-only: with a UI but no terminal (RPC mode) it resolves
   // undefined immediately, which would read as a cancel without ever asking. Ask
-  // through the dialog primitives there instead.
-  const result = ctx.mode === 'tui' ? await askViaOverlay(params, ctx, allOptions, multiSelect) : await askViaDialogs(params, ctx, allOptions, multiSelect)
+  // through the dialog primitives there instead. askUserQuestionTimeout is a TUI
+  // concept (a countdown, a keypress resetting it): the dialog-primitive fallback
+  // has no keyboard or visible countdown to drive it, so it is not applied there.
+  const result = ctx.mode === 'tui' ? await askViaOverlay(params, ctx, allOptions, multiSelect, askUserQuestionTimeoutMs()) : await askViaDialogs(params, ctx, allOptions, multiSelect)
 
   // Build simple options list for details; header/multiSelect appear only when set,
   // so single-select details are unchanged.
@@ -255,6 +302,18 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
     }
   }
 
+  if (result.timedOut) {
+    // Claude: "tells Claude you may be away from your keyboard, so Claude proceeds
+    // on its own judgment and can re-ask later." Not framed as a cancel: `answer` is
+    // '' rather than null, so renderResult and a batch's own null-check both read it
+    // as "answered nothing, but not declined" rather than the user having said no.
+    const already = multiSelect && result.answer ? ` Already selected: ${result.answer}.` : ''
+    return {
+      content: [{ type: 'text', text: `No response after the configured idle timeout; the user may be away from the keyboard.${already} Proceed on your own judgment; you can ask again later if needed.` }],
+      details: { ...base, answer: result.answer, timedOut: true } as QuestionDetails,
+    }
+  }
+
   if (result.wasCustom) {
     return {
       content: [{ type: 'text', text: `User wrote: ${result.answer}` }],
@@ -268,15 +327,82 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
   }
 }
 
-/** Terminal path: the full custom overlay (options list, checkboxes, inline editor). */
-function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean): Promise<{ answer: string; wasCustom: boolean; index?: number } | null> {
-  return ctx.ui.custom<{ answer: string; wasCustom: boolean; index?: number } | null>((tui: Parameters<Parameters<ExtensionContext['ui']['custom']>[0]>[0], theme: Theme, _kb: unknown, done: (value: { answer: string; wasCustom: boolean; index?: number } | null) => void) => {
+/** Claude: "You see a countdown for the last 20 seconds." */
+const COUNTDOWN_WINDOW_MS = 20_000
+/** Granularity of the idle-timer tick: fine enough that the countdown's displayed
+ * second changes on time, coarse enough not to re-render needlessly often. */
+const IDLE_TICK_MS = 250
+
+/** Terminal path: the full custom overlay (options list, checkboxes, inline editor).
+ *
+ * `timeoutMs`, when set, is Claude's askUserQuestionTimeout: "After a question sits
+ * that long with no input, the dialog closes on its own: it submits any options
+ * you'd already selected and tells Claude you may be away from your keyboard, so
+ * Claude proceeds on its own judgment and can re-ask later. You see a countdown for
+ * the last 20 seconds. Press any key to restart the timer." Terminal focus-in
+ * restarting the timer, the other documented reset trigger, is not implemented:
+ * pi's TUI input stream is not confirmed to carry the terminal's own focus-report
+ * escape sequences, and guessing at that risks misreading ordinary input as a
+ * focus event on a terminal that reports it differently. Exported so the timer
+ * mechanics are testable directly, independent of where timeoutMs itself is read
+ * from (askUserQuestionTimeoutMs, tested separately).
+ */
+export function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean, timeoutMs?: number): Promise<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null> {
+  return ctx.ui.custom<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null>((tui: Parameters<Parameters<ExtensionContext['ui']['custom']>[0]>[0], theme: Theme, _kb: unknown, done: (value: { answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null) => void) => {
     let optionIndex = 0
     let editMode = false
     const checked: boolean[] = allOptions.map(() => false)
     let cachedLines: string[] | undefined
     let cachedWidth: number | undefined
 
+    // deadline stays undefined for the whole overlay life when no timeout is
+    // configured, so every idle-timer branch below is a no-op in that case.
+    let deadline: number | undefined = timeoutMs !== undefined ? Date.now() + timeoutMs : undefined
+    let idleTimer: ReturnType<typeof setInterval> | undefined
+    let lastCountdown: number | undefined
+
+    function stopIdleTimer(): void {
+      if (idleTimer !== undefined) clearInterval(idleTimer)
+      idleTimer = undefined
+    }
+
+    /** Every exit path (an answer, a cancel, or the timeout itself) goes through
+     * here, so the interval can never outlive the overlay it belongs to. */
+    function finish(value: { answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null): void {
+      stopIdleTimer()
+      done(value)
+    }
+
+    function resetIdleTimer(): void {
+      if (timeoutMs === undefined) return
+      deadline = Date.now() + timeoutMs
+    }
+
+    function fireTimeout(): void {
+      // Claude: "submits any options you'd already selected". Single-select has
+      // nothing pre-committed (a selection only exists once Enter confirms it), so
+      // its timeout answer is empty rather than whatever option merely had focus.
+      const answer = multiSelect ? selectedLabels(allOptions, checked) : ''
+      finish({ answer, wasCustom: false, timedOut: true })
+    }
+
+    if (timeoutMs !== undefined) {
+      idleTimer = setInterval(() => {
+        if (deadline === undefined) return
+        const remainingMs = deadline - Date.now()
+        if (remainingMs <= 0) {
+          fireTimeout()
+          return
+        }
+        const remainingSeconds = Math.ceil(remainingMs / 1000)
+        const nextCountdown = remainingMs <= COUNTDOWN_WINDOW_MS ? remainingSeconds : undefined
+        if (nextCountdown !== lastCountdown) {
+          lastCountdown = nextCountdown
+          refresh()
+        }
+      }, IDLE_TICK_MS)
+    }
+
     const editorTheme: EditorTheme = {
       borderColor: (s) => theme.fg('accent', s),
       selectList: {
@@ -292,7 +418,7 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
     editor.onSubmit = (value) => {
       const trimmed = value.trim()
       if (trimmed) {
-        done({ answer: trimmed, wasCustom: true })
+        finish({ answer: trimmed, wasCustom: true })
       } else {
         editMode = false
         editor.setText('')
@@ -306,6 +432,11 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
     }
 
     function handleInput(data: string) {
+      // Claude: "Press any key to restart the timer." Every branch below returns
+      // through this function, so resetting unconditionally on entry covers all of
+      // them, including the ones (arrow keys, space) that never reach `finish`.
+      resetIdleTimer()
+
       if (editMode) {
         if (matchesKey(data, Key.escape)) {
           editMode = false
@@ -337,7 +468,7 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
 
       if (matchesKey(data, Key.enter)) {
         if (multiSelect) {
-          done({ answer: selectedLabels(allOptions, checked), wasCustom: false })
+          finish({ answer: selectedLabels(allOptions, checked), wasCustom: false })
           return
         }
         const selected = allOptions[optionIndex]
@@ -345,20 +476,20 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
           editMode = true
           refresh()
         } else {
-          done({ answer: selected.label, wasCustom: false, index: optionIndex + 1 })
+          finish({ answer: selected.label, wasCustom: false, index: optionIndex + 1 })
         }
         return
       }
 
       if (matchesKey(data, Key.escape)) {
-        done(null)
+        finish(null)
       }
     }
 
     function render(width: number): string[] {
       if (cachedLines && cachedWidth === width) return cachedLines
       cachedWidth = width
-      cachedLines = buildQuestionLines({ width, question: params.question, header: shortHeader(params.header), options: allOptions, optionIndex, editMode, multiSelect, checked, editor, theme })
+      cachedLines = buildQuestionLines({ width, question: params.question, header: shortHeader(params.header), options: allOptions, optionIndex, editMode, multiSelect, checked, editor, theme, countdownSeconds: lastCountdown })
       return cachedLines
     }
 
@@ -369,6 +500,10 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
         cachedLines = undefined
       },
       handleInput,
+      // Belt and suspenders alongside finish()'s own stopIdleTimer: if the host ever
+      // tears the overlay down through a path that does not go through `done`
+      // (finish's only caller), the interval still gets cleared here.
+      dispose: stopIdleTimer,
     }
   })
 }
@@ -376,7 +511,7 @@ function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions:
 /** Dialog-primitive fallback for UI without a terminal (RPC mode supports
  * select/input/notify but not custom components). Mirrors the overlay's result
  * shape; a dismissed dialog reads as a cancel, same as Escape in the overlay. */
-async function askViaDialogs(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean): Promise<{ answer: string; wasCustom: boolean; index?: number } | null> {
+async function askViaDialogs(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean): Promise<{ answer: string; wasCustom: boolean; index?: number; timedOut?: boolean } | null> {
   const header = shortHeader(params.header)
   const title = header ? `[${header}] ${params.question}` : params.question
   // Number the labels: ctx.ui.select returns the chosen label string, so duplicate

package/extensions/session-title.ts

@@ -93,6 +93,11 @@ export default function sessionTitleExtension(pi: ExtensionAPI) {
   })
 
   pi.on('agent_settled', async (_event, ctx) => {
+    // Claude: "Set to 1 to disable automatic terminal title updates based on conversation
+    // context. In Agent SDK and claude -p sessions, this also skips the background
+    // small/fast-model request that generates the session title." setSessionName is pi's
+    // only title sink, so skipping the call here skips both effects at once.
+    if (process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE === '1') return
     if (titled) return
     // Never clobber an existing name: a user-chosen or resumed name wins.
     if (pi.getSessionName?.()) return

package/extensions/skills.ts

@@ -50,7 +50,12 @@ export function skillDirs(cwd: string, home: string, trusted: boolean): string[]
   // Claude's precedence: enterprise (the skills directory beside the managed
   // settings file) overrides personal, and personal overrides project; discovery
   // here is first-match, so higher precedence goes first.
-  const candidates = [path.join(path.dirname(managedSettingsFile()), '.claude', 'skills'), path.join(claudeConfigDir(home), 'skills')]
+  // Claude: "Set to 1 to skip loading skills from the system-wide managed skills
+  // directory. Useful for container or CI sessions that should not load
+  // operator-provisioned skills." The enterprise dir beside managed-settings.json is
+  // that directory here; personal and project skills are unaffected.
+  const enterprise = process.env.CLAUDE_CODE_DISABLE_POLICY_SKILLS === '1' ? [] : [path.join(path.dirname(managedSettingsFile()), '.claude', 'skills')]
+  const candidates = [...enterprise, path.join(claudeConfigDir(home), 'skills')]
   // Enabled plugins contribute their skills directories. pi's loader names a
   // skill by its directory, so a plugin skill registers without Claude's
   // /plugin: prefix; a rename-free approximation, disclosed in the README.

package/extensions/subagent/child.ts

@@ -12,6 +12,7 @@ import * as path from 'node:path'
 
 import type { AgentRunRequest } from '../internal/agent-run.js'
 import { claudeConfigDir } from '../internal/config-dir.js'
+import { sliceBytes } from '../internal/output-guard.js'
 import { repoRoot } from '../internal/project-root.js'
 import { autoMemoryEnabled, capIndexForPrompt, INDEX_MAX_BYTES, INDEX_MAX_LINES, memorySettingsFiles, readMemorySettings } from '../memory.js'
 import { type AgentConfig, type AgentMemoryScope, expandMcpToolPatterns, withPreloadedSkills } from './agents.js'
@@ -188,10 +189,24 @@ export function agentHooksEnv(agent: AgentConfig, agentId: string): Record<strin
   return { PI_CODE_AGENT_HOOKS: JSON.stringify({ agent: agent.name, id: agentId, hooks }) }
 }
 
+/** This string becomes the whole of one argv element to the spawned child
+ * (run.ts, `spawn(..., { shell: false })`). Linux's MAX_ARG_STRLEN, a per-argument
+ * limit distinct from the much larger total ARG_MAX, is 128KiB; confirmed on a real
+ * Linux host that a single argv string over it fails execve with E2BIG. Neither the
+ * model's task text nor a SubagentStart hook's additionalContext is capped
+ * upstream, so this is where the assembled string caps itself. The budget leaves
+ * headroom under the hard limit for the "Task: " prefix, the notice below, and
+ * platforms whose limit differs from Linux's. */
+const TASK_ARGV_MAX_BYTES = 96 * 1024
+
 /** The task argument with any SubagentStart hook context ahead of it, per Claude:
  * "added to the subagent's context at the start of its conversation, before its
- * first prompt". */
+ * first prompt". Capped as one combined string, since either the context or the
+ * task alone can already be oversized. */
 export function taskWithStartContext(task: string, contexts: string[]): string {
   const context = contexts.filter(Boolean).join('\n')
-  return context ? `${context}\n\nTask: ${task}` : `Task: ${task}`
+  const assembled = context ? `${context}\n\nTask: ${task}` : `Task: ${task}`
+  if (Buffer.byteLength(assembled, 'utf-8') <= TASK_ARGV_MAX_BYTES) return assembled
+  const kept = sliceBytes(assembled, TASK_ARGV_MAX_BYTES)
+  return `${kept}\n\n[truncated: too long for the child process to receive]`
 }

package/extensions/subagent/run.ts

@@ -6,11 +6,12 @@
  * worktree; everything about how the child was configured lives in child.ts.
  */
 
-import { spawn } from 'node:child_process'
+import { type ChildProcessByStdio, spawn } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
+import type { Readable } from 'node:stream'
 
 import type { AgentToolResult } from '@earendil-works/pi-agent-core'
 import type { Message } from '@earendil-works/pi-ai'
@@ -123,6 +124,29 @@ function appendPartialNote(result: SingleResult): void {
   if (result.partial) appendResultNote(result, '[Output is partial: the subagent stopped at its maxTurns limit.]')
 }
 
+/** The pi child, or the error spawning it threw synchronously. Node normally
+ * reports a spawn failure through the child's async 'error' event, but some
+ * failures (confirmed on Linux: posix_spawn detects E2BIG immediately) throw at
+ * the spawn() call site instead; catching it here, in one place with an explicit
+ * return type, keeps the caller's non-null stdout/stderr narrowing that a bare
+ * try/catch around an inline spawn() call loses. */
+function spawnChild(command: string, args: string[], options: { cwd: string; env: NodeJS.ProcessEnv }): { proc: ChildProcessByStdio<null, Readable, Readable> } | { error: Error } {
+  try {
+    return {
+      proc: spawn(command, args, {
+        ...options,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        // Its own group, so an abort reaches grandchildren too: killing only the
+        // direct child orphans a build or dev server the agent started.
+        detached: true,
+      }),
+    }
+  } catch (error) {
+    return { error: error as Error }
+  }
+}
+
 export async function runSingleAgent(options: RunAgentOptions): Promise<SingleResult> {
   const agent = options.agents.find((a) => a.name === options.agentName)
   if (!agent) return runSingleAgentInner(options)
@@ -244,16 +268,17 @@ async function runSingleAgentInner(options: RunAgentOptions): Promise<SingleResu
 
     const exitCode = await new Promise<number>((resolve) => {
       const invocation = getPiInvocation(args)
-      const proc = spawn(invocation.command, invocation.args, {
+      const spawned = spawnChild(invocation.command, invocation.args, {
         cwd: worktree?.dir ?? runCwd,
-        shell: false,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        // Its own group, so an abort reaches grandchildren too: killing only the
-        // direct child orphans a build or dev server the agent started.
-        detached: true,
         // The marker lets the child's subagent tool refuse to nest further.
         env: { ...process.env, PI_CODE_SUBAGENT: '1', ...agentHooksEnv(agent, options.agentId ?? '') },
       })
+      if ('error' in spawned) {
+        if (!currentResult.stderr) currentResult.stderr = spawned.error.message
+        resolve(1)
+        return
+      }
+      const proc = spawned.proc
       let buffer = ''
       let assistantTurns = 0
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.62",
+  "version": "1.0.63",
   "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, subagents, and goals",
   "keywords": [
     "pi",