pi-code 1.0.62 → 1.0.64

package/extensions/internal/project-root.ts

@@ -16,11 +16,10 @@ import * as path from 'node:path'
 /** The project root marker. `.git` is a file in worktrees and submodules, a directory
  * in an ordinary clone.
  *
- * `package.json` used to count too, which made every package of a monorepo its own
- * project: its own memory directory, its own settings.local.json, its own
- * CLAUDE_PROJECT_DIR, its own trust decision. Claude's project is the repository, and
- * a repository can add a package.json wherever it likes, so a marker it controls was
- * also a marker it could move. */
+ * Only `.git`: a package.json marker would make every package of a monorepo its own
+ * project (its own memory directory, settings.local.json, CLAUDE_PROJECT_DIR and trust
+ * decision), and a repository can add a package.json wherever it likes, so a marker it
+ * controls is a marker it can move. Claude's project is the repository. */
 export const ROOT_MARKERS = ['.git']
 
 /** Project root at or above `from`, or undefined outside a repository. */
@@ -32,11 +31,12 @@ export function repoRoot(from: string): string | undefined {
 
 /** The git checkout at or above `from`, or undefined outside one.
  *
- * Narrower than repoRoot on purpose, and used where a key must be stable rather than
- * merely near: repoRoot also stops at package.json, which every package of a monorepo
- * ships, so a decision keyed on it changes the moment the session starts one directory
- * deeper. `.git` cannot be committed into a repository, so it is not a marker the
- * repository can add to move its own key.
+ * Narrower than repoRoot on purpose: repoRoot resolves a worktree to its main checkout,
+ * which is the right key for shared state (settings.local.json, auto memory) but is a
+ * sibling of the worktree, never an ancestor. The upward walks above bound themselves
+ * here instead, since a boundary that is not on the path from cwd to / is never reached
+ * and the walk would run on to the filesystem root. `.git` cannot be committed into a
+ * repository, so it is not a marker the repository can add to move its own key.
  */
 export function gitRoot(from: string): string | undefined {
   let currentDir = from
@@ -89,7 +89,7 @@ function statOf(target: string): fs.Stats | null {
 }
 
 function findNearest(cwd: string, relative: string, wantDir: boolean): string | null {
-  const boundary = repoRoot(cwd) ?? cwd
+  const boundary = gitRoot(cwd) ?? cwd
   let currentDir = cwd
   while (true) {
     const candidate = path.join(currentDir, relative)
@@ -117,7 +117,7 @@ export function findNearestFile(cwd: string, relative: string): string | null {
  * matching Claude's "every .claude/<kind> between the working directory and the
  * repository root" discovery where the entry closest to cwd wins a name clash. */
 export function ancestorDirs(cwd: string, relative: string): string[] {
-  const boundary = repoRoot(cwd) ?? cwd
+  const boundary = gitRoot(cwd) ?? cwd
   const found: string[] = []
   let currentDir = cwd
   while (true) {
@@ -134,7 +134,7 @@ export function ancestorDirs(cwd: string, relative: string): string[] {
 /** Every `relative` file between the repository root and cwd, ordered root first,
  * matching Claude's root-down ordering for hierarchy-loaded context. */
 export function ancestorFiles(cwd: string, relative: string): string[] {
-  const boundary = repoRoot(cwd) ?? cwd
+  const boundary = gitRoot(cwd) ?? cwd
   const found: string[] = []
   let currentDir = cwd
   while (true) {

package/extensions/internal/settings-chain.ts

@@ -52,12 +52,31 @@ export function claudeSettingsChain(cwd: string, home: string, includeProject: b
   const files = [path.join(claudeConfigDir(home), 'settings.json')]
   if (!includeProject) return files
   files.push(path.join(cwd, '.claude', 'settings.json'))
+  // Compared as the directory the placement rule returned, not re-derived from a
+  // joined path: path.join normalizes separators, so a cwd given POSIX-style on
+  // Windows would never equal its own joined form and the legacy entry would repeat.
   const localDir = localSettingsDir(cwd, home, platform, owned)
   if (localDir !== cwd) files.push(path.join(cwd, '.claude', 'settings.local.json'))
   files.push(path.join(localDir, '.claude', 'settings.local.json'))
   return files
 }
 
+/** The settings.local.json the chain reads last, which is also where a setting a
+ * command persists (an output-style choice, an MCP consent) must be written for the
+ * chain to read it back: a file at any other level is never consulted. */
+export function localSettingsFile(cwd: string, home: string, platform: NodeJS.Platform = process.platform, owned: (paths: string[]) => boolean = ownedByUser): string {
+  return path.join(localSettingsDir(cwd, home, platform, owned), '.claude', 'settings.local.json')
+}
+
+/** One settings file as a JSON object, or undefined when missing, unparseable or not
+ * an object: the single-file case of the chain, for the user-only settings a
+ * repository must not influence (a notification channel, a question timeout, a
+ * retention period). */
+export function readSettingsFile(file: string): Record<string, unknown> | undefined {
+  const first = readSettingsChain([file]).next()
+  return first.done ? undefined : first.value
+}
+
 /** Every readable settings object in the chain, in order, so the last one a caller
  * sees for a key is the one that wins. A file that is missing, unparseable, or not a
  * JSON object is skipped: a corrupt settings.json must not end the chain, or the

package/extensions/internal/settings-watch.ts

@@ -6,6 +6,7 @@
  */
 
 import * as fs from 'node:fs'
+import { parseNumericEnv } from './values.js'
 
 // Captured at module load: the poll must run on real time even under a test's
 // fake timers (the stat watcher it replaced lived in libuv and was immune too);
@@ -29,7 +30,8 @@ function snapshot(file: string): string | undefined {
  * small, so re-reading them on the poll is negligible. The interval is
  * env-tunable for tests. */
 export function watchSettingsFiles(files: string[], reload: () => void): () => void {
-  const interval = Number(process.env.PI_CODE_SETTINGS_WATCH_INTERVAL_MS) || 2000
+  const configured = parseNumericEnv(process.env.PI_CODE_SETTINGS_WATCH_INTERVAL_MS)
+  const interval = configured !== undefined && configured > 0 ? configured : 2000
   let last = files.map(snapshot)
   const timer = realSetInterval(() => {
     const next = files.map(snapshot)

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)
@@ -59,7 +70,9 @@ export function resolvePowershellBinary(platform: string = process.platform, env
 function isProjectTooling(dir: string, cwd: string): boolean {
   const relative = path.relative(cwd, dir)
   if (relative === '') return true
-  if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+  // Lexical containment: `..tools/...` is a directory inside cwd, only `..` itself or
+  // `../...` leaves it (the shape claude-rules.ts's containment check spells out).
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return false
   return relative.split(path.sep).some((segment) => PROJECT_TOOLING_DIRS.has(segment))
 }
 
@@ -111,11 +124,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/internal/tool-target.ts

@@ -1,11 +1,10 @@
 /**
  * Which file a tool call touched.
  *
- * Two extensions attach instruction files when a file tool touches a path they cover
- * (claude-rules for a path-scoped rule, context-imports for a nested CLAUDE.md), and
- * both got the same detail wrong: pi's edit and write tools accept `file_path` as an
- * alias for `path`, so a handler reading only `path` did nothing for a model that used
- * the alias. One reader, one place to be wrong.
+ * pi's read, edit and write tools accept `file_path` as an alias for `path`, so every
+ * reader of a file tool's target must accept both, and a handler reading only `path`
+ * does nothing for a model that used the alias. This is the one reader (claude-rules,
+ * context-imports and the command path-scope guard all go through it).
  */
 
 /** The tools that name a file pi-code acts on. */

package/extensions/internal/values.ts

@@ -1,8 +1,7 @@
 /**
- * The shapes every extension here needed its own copy of: an error's message, a plain
- * object check, whether a path is a directory, and the text of a message content. Each
- * was written three to five times with the same body, and the error one appeared in
- * seventeen files.
+ * The small shared shapes: an error's message, a plain-object check, whether a path
+ * is a directory, the text of a message content, a regex escape, a numeric env
+ * value. One copy each; a private copy in an extension is the drift to look for.
  */
 
 import * as fs from 'node:fs'
@@ -36,3 +35,20 @@ export function contentText(content: unknown, separator = ''): string {
     .map((part) => part.text)
     .join(separator)
 }
+
+/** Escape a string for literal use inside a RegExp. One copy: five private ones had
+ * the same body and would have drifted the first time one of them was fixed. */
+export function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+}
+
+/** A numeric environment value, or undefined when blank or not a number. Accepts the
+ * spellings docs/mcp.md promises (`2e3`, `64_000`); the caller decides the range and
+ * whether fractions are meaningful, so no flooring here. */
+export function parseNumericEnv(raw: string | undefined): number | undefined {
+  if (raw === undefined) return undefined
+  const cleaned = raw.replaceAll('_', '')
+  if (cleaned.trim() === '') return undefined
+  const value = Number(cleaned)
+  return Number.isFinite(value) ? value : undefined
+}

package/extensions/mcp/config.ts

@@ -6,10 +6,12 @@
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
 import { claudeConfigDir } from '../internal/config-dir.js'
 import type { OAuthServerConfig } from '../internal/mcp-oauth.js'
 import { type InstalledPlugin, pluginComponentPath } from '../internal/plugins.js'
 import { findNearestFile } from '../internal/project-root.js'
+import { errorMessage } from '../internal/values.js'
 
 export interface StdioServerConfig {
   type?: 'stdio'
@@ -91,7 +93,9 @@ function claudeJsonPath(home: string): string {
 /** User-scoped MCP config (the user's own; safe to load without project trust). The .pi
  * tree is pi's own and is not relocated by CLAUDE_CONFIG_DIR. */
 export function userConfigPaths(home: string): string[] {
-  return [claudeJsonPath(home), path.join(home, '.pi', 'agent', 'mcp.json')]
+  // mcp.json lives in pi's agent directory, which PI_CODING_AGENT_DIR relocates; the
+  // other agent-directory readers (trust store, OAuth tokens) already follow it.
+  return [claudeJsonPath(home), path.join(getAgentDir(), 'mcp.json')]
 }
 
 /** Project-scoped MCP config, each file the nearest of its name at or above cwd
@@ -107,8 +111,10 @@ export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
     try {
       const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
       Object.assign(servers, parsed.mcpServers ?? {})
-    } catch {
-      // missing or invalid file: skip silently, /mcp reports what loaded
+    } catch (error) {
+      // A missing file is the normal case. A present file that does not parse is
+      // not: one trailing comma silently disabled every server in it.
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') console.warn(`pi-code-mcp: ignoring ${file}: ${errorMessage(error)}`)
     }
   }
   return servers
@@ -132,7 +138,8 @@ function projectRecord(home: string, cwd: string): { mcpServers?: Record<string,
   try {
     const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath(home), 'utf-8'))
     return claudeJson.projects?.[cwd] ?? {}
-  } catch {
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') console.warn(`pi-code-mcp: ignoring ${claudeJsonPath(home)}: ${errorMessage(error)}`)
     return {}
   }
 }

package/extensions/mcp/index.ts

@@ -49,12 +49,11 @@ 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
-// (imported by the test suite) reachable from this entry point unchanged. The managed
-// settings path helpers now live in the shared internal module.
+// (imported by the test suite) reachable from this entry point unchanged.
 export type { HttpServerConfig, ServerConfig, StdioServerConfig } from './config.js'
 export { expandCwd, interpolateEnv, loadConfigFrom, loadPluginServers, loadUserScope, projectConfigPaths, userConfigPaths, warnOnTypelessUrl } from './config.js'
 export type { McpToolInfo } from './listing.js'
@@ -85,6 +84,12 @@ function authUiFor(ctx: ExtensionContext): AuthUi | undefined {
 
 export default async function mcpExtension(pi: ExtensionAPI) {
   const clients = new Map<string, Client>()
+  // Names with a connect in flight. A name enters `clients` only once its connect
+  // resolves, and shutdown clears that map without awaiting anything in flight, so
+  // without this set a session switch during a slow connect (or a backoff sleep) let
+  // the next session_start connect the same name again; the first client then resolved
+  // into an entry the second overwrote and was never closed.
+  const connecting = new Set<string>()
   // The session's OAuth UI seams, captured at session_start. The reconnect paths below
   // run outside that handler, and passing undefined there made an INTERACTIVE session
   // report the headless "cannot log in" advice on a re-auth it could actually perform.
@@ -99,6 +104,11 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   // Shutdown closes clients while they are still in the map; the onclose handlers
   // must not schedule reconnects for that deliberate teardown.
   let shuttingDown = false
+  // Bumped by every session_start and session_shutdown. A late-connecting server's
+  // deferred summary captured the ctx of the session that started it; pi disposes that
+  // ctx on /new, /resume, /fork and reload (any use of it throws), so the publish must
+  // check it still belongs to the live session before touching ctx.
+  let sessionGeneration = 0
   const callTuning = (name: string): ServerCallTuning => {
     const config = serverConfigs.get(name)
     return config ? serverCallTuning(config) : {}
@@ -189,7 +199,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   async function reconnectWithBackoff(name: string, config: ServerConfig): Promise<void> {
     for (let attempt = 0; attempt < 5; attempt++) {
       await new Promise((resolve) => setTimeout(resolve, 1000 * 2 ** attempt))
-      if (shuttingDown || clients.has(name)) return
+      if (shuttingDown || clients.has(name) || connecting.has(name)) return
       await connectServers({ [name]: config }, sessionAuthUi, true)
       if (clients.has(name)) return
     }
@@ -410,10 +420,15 @@ export default async function mcpExtension(pi: ExtensionAPI) {
         console.warn(`pi-code-mcp: skipping duplicate server name ${name}`)
         continue
       }
+      // The one guard for every connect path (session_start scopes, backoff, auth
+      // reconnect): a name still connecting from the previous session is adopted when
+      // that connect resolves, not connected again.
+      if (connecting.has(name)) continue
       // 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)
+      connecting.add(name)
       pending.push([name, config])
     }
     await Promise.all(
@@ -423,6 +438,14 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           // First connections retry transient failures (Claude: up to three times for
           // HTTP/SSE); the backoff reconnect below carries its own schedule instead.
           const client = noRetry ? await connect(name, config, authUi, sessionDirs) : await connectWithRetries(name, config, authUi, sessionDirs)
+          // A session switch resets shuttingDown before this resolves and adopts the
+          // client; still set, pi is exiting and the shutdown handler already closed
+          // every client it could see, so this late one must close itself.
+          if (shuttingDown) {
+            await withTimeout(client.close(), 3000, 'close').catch(() => {})
+            status.delete(name)
+            return
+          }
           clients.set(name, client)
           const tools = await withTimeout(listAllTools(client), connectTimeoutMs(), `list tools ${name}`)
           registerTools(name, config, tools)
@@ -460,6 +483,8 @@ export default async function mcpExtension(pi: ExtensionAPI) {
             clients.delete(name)
             void leaked.close().catch(() => {})
           }
+        } finally {
+          connecting.delete(name)
         }
       }),
     )
@@ -563,6 +588,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
@@ -570,6 +612,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // withdrawn tool keeps its registration and surfaces the server's own error), which
     // is why serverToolCount reads from `registered` to recover the true count here.
     status.clear()
+    const generation = ++sessionGeneration
     // A same-process session switch (/new, /resume) shut the last session down;
     // this one may reconnect again. projectConnected guards against connecting the project
     // scope twice within one session, so it belongs to the session that set it: leaving it
@@ -579,7 +622,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,20 +635,35 @@ 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) {
+      // The rejection path exists for the throw a disposed ctx would raise if the
+      // generation check were ever wrong: from a bare `.then` it would be an unhandled
+      // rejection, and pi installs no handler, so Node would take the process down.
+      void connecting
+        .then(() => {
+          if (generation === sessionGeneration) publishConnectionSummary(ctx)
+        })
+        .catch(() => {})
     }
   })
 
@@ -613,6 +671,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // Closing fires each client's onclose while it is still in the map; the flag
     // stops those handlers (and any in-flight backoff loop) from reconnecting.
     shuttingDown = true
+    sessionGeneration++
     // Close in parallel with a per-client timeout so one hung server can't stall pi's exit.
     await Promise.all([...clients.values()].map((client) => withTimeout(client.close(), 3000, 'close').catch(() => {})))
     // Drop the closed clients and their status now rather than waiting on each client's

package/extensions/mcp/policy.ts

@@ -6,10 +6,9 @@
 
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import { claudeConfigDir } from '../internal/config-dir.js'
 import { managedSettingsFile } from '../internal/managed-settings.js'
-import { findNearestFile } from '../internal/project-root.js'
-import { errorMessage } from '../internal/values.js'
+import { claudeSettingsChain } from '../internal/settings-chain.js'
+import { errorMessage, escapeRegExp } from '../internal/values.js'
 import { interpolateEnv, type ServerConfig } from './config.js'
 
 export interface ProjectServerPolicy {
@@ -38,11 +37,17 @@ export function projectServerPolicy(cwd: string, home: string, projectApproved:
     }
   }
   const names = (value: unknown): string[] => (Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [])
-  const userSettings = read(path.join(claudeConfigDir(home), 'settings.json'))
-  const projectSettings = read(findNearestFile(cwd, path.join('.claude', 'settings.json')) ?? path.join(cwd, '.claude', 'settings.json'))
-  const localSettings = read(findNearestFile(cwd, path.join('.claude', 'settings.local.json')) ?? path.join(cwd, '.claude', 'settings.local.json'))
-  const disabled = new Set([...names(userSettings.disabledMcpjsonServers), ...names(projectSettings.disabledMcpjsonServers), ...names(localSettings.disabledMcpjsonServers)])
-  const consentSources = projectApproved ? [userSettings, localSettings] : [userSettings]
+  // The files come from the one settings chain, so placement follows Claude's rules
+  // everywhere: the project's settings.json is read from cwd only (never an ancestor),
+  // and settings.local.json from the main checkout, with the chain's legacy cwd copy
+  // read too. Resolving them by nearest-file here gave a subdirectory session an
+  // ancestor's project file and a worktree session its own local file instead.
+  const [userFile, projectFile, ...localFiles] = claudeSettingsChain(cwd, home, true)
+  const userSettings = read(userFile)
+  const projectSettings = read(projectFile)
+  const localSettings = localFiles.map(read)
+  const disabled = new Set([...names(userSettings.disabledMcpjsonServers), ...names(projectSettings.disabledMcpjsonServers), ...localSettings.flatMap((settings) => names(settings.disabledMcpjsonServers))])
+  const consentSources = projectApproved ? [userSettings, ...localSettings] : [userSettings]
   const consented = new Set(consentSources.flatMap((settings) => names(settings.enabledMcpjsonServers)))
   const consentAll = consentSources.some((settings) => settings.enableAllProjectMcpServers === true)
   return { disabled, consented, consentAll }
@@ -127,10 +132,7 @@ export function mcpAllowDeny(scopeFiles: string[] = [], managedFile: string = ma
 
 /** `*` in a policy URL pattern matches any run of characters; everything else is literal. */
 function wildcardRegExp(pattern: string): RegExp {
-  const source = pattern
-    .split('*')
-    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`))
-    .join('.*')
+  const source = pattern.split('*').map(escapeRegExp).join('.*')
   return new RegExp(`^${source}$`)
 }
 

package/extensions/mcp/transport.ts

@@ -18,6 +18,7 @@ import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/webso
 import { ListRootsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
 import { FileOAuthProvider, type OAuthServerConfig } from '../internal/mcp-oauth.js'
 import { resolveShell } from '../internal/shell-resolve.js'
+import { parseNumericEnv } from '../internal/values.js'
 import { expandCwd, type HttpServerConfig, interpolateEnv, type ServerConfig, type StdioServerConfig } from './config.js'
 import { runInteractiveOAuth, serializeInteractiveOAuth } from './oauth-flow.js'
 
@@ -36,25 +37,24 @@ 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 = parseNumericEnv(raw)
-  return value !== undefined && value > 0 ? value : fallback
+  return value !== undefined && value > 0 ? Math.floor(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)
 
+// 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 +137,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 +194,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/memory.ts

@@ -12,7 +12,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import { StringEnum } from '@earendil-works/pi-ai'
-import { type ExtensionAPI, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
+import { type ExtensionAPI, getAgentDir, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
 import { atomicWriteFile } from './internal/atomic-write.js'
 import { claudeConfigDir } from './internal/config-dir.js'
@@ -63,7 +63,7 @@ function memoryProject(cwd: string): string {
 }
 
 export function memoryDir(cwd: string): string {
-  return path.join(os.homedir(), '.pi', 'agent', 'memory', projectSlug(memoryProject(cwd)))
+  return path.join(getAgentDir(), 'memory', projectSlug(memoryProject(cwd)))
 }
 
 /** The store location, honoring an `autoMemoryDirectory` override. Claude requires
@@ -142,7 +142,7 @@ export function stripNonLoaded(text: string): string {
 export function migrateLegacyStore(cwd: string): void {
   const current = memoryDir(cwd)
   if (fs.existsSync(current)) return
-  const base = path.join(os.homedir(), '.pi', 'agent', 'memory')
+  const base = path.join(getAgentDir(), 'memory')
   // projectSlug(cwd) differs from current only for a subdirectory session (current is
   // keyed on the repo root); for a repo-root session it equals current and is skipped.
   const candidates = [path.join(base, projectSlug(cwd)), path.join(base, legacySlug(cwd))]
@@ -177,7 +177,7 @@ export function indexWouldOverflow(index: string, name: string, description: str
 /** Where the index stands against the read limits, measured on the loaded content
  * (frontmatter and comments stripped): 'over' past either bound, 'near' within
  * 10% of one, else 'ok'. Claude reminds near a limit and errors over it. */
-export function indexReadState(index: string): 'ok' | 'near' | 'over' {
+function indexReadState(index: string): 'ok' | 'near' | 'over' {
   const loaded = stripNonLoaded(index)
   const lines = loaded.split('\n').length
   const bytes = Buffer.byteLength(loaded, 'utf-8')

package/extensions/notify.ts

@@ -16,12 +16,12 @@
  */
 
 import { execFile } from 'node:child_process'
-import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import { claudeConfigDir } from './internal/config-dir.js'
+import { readSettingsFile } from './internal/settings-chain.js'
 
 /** How a finished turn is announced, from Claude's `preferredNotifChannel`. */
 export type NotifChannel = 'desktop' | 'bell' | 'both' | 'off'
@@ -56,12 +56,7 @@ export function isAway(lastInputAt: number | undefined, now: number, thresholdMs
  * preference, so only user scope is read; a checked-out repo does not get to silence
  * or change your notifications. */
 function readPreferredNotifChannel(home: string): unknown {
-  try {
-    const settings = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(home), 'settings.json'), 'utf-8'))
-    return settings?.preferredNotifChannel
-  } catch {
-    return undefined
-  }
+  return readSettingsFile(path.join(claudeConfigDir(home), 'settings.json'))?.preferredNotifChannel
 }
 
 function windowsToastScript(title: string, body: string): string {