pi-code 1.0.53 → 1.0.55

package/extensions/commands.ts

@@ -174,10 +174,19 @@ export function shellExecutionDisabled(cwd: string, home: string, trusted: boole
   if (readManagedSettings().disableSkillShellExecution === true) return true
   const files = claudeSettingsChain(cwd, home, trusted)
   return files.some((file) => {
+    let raw: string
     try {
-      return (JSON.parse(fs.readFileSync(file, 'utf-8')) as Record<string, unknown>).disableSkillShellExecution === true
+      raw = fs.readFileSync(file, 'utf-8')
     } catch {
-      return false // missing or invalid file: not a policy statement
+      return false // no such file: genuinely not a policy statement
+    }
+    try {
+      return (JSON.parse(raw) as Record<string, unknown>).disableSkillShellExecution === true
+    } catch {
+      // Present but unreadable: the user may believe this file disables skill shells, so
+      // say so rather than silently leaving them enabled.
+      console.warn(`pi-code: ignoring ${file}: not valid JSON; skill shell execution stays as the other settings leave it`)
+      return false
     }
   })
 }
@@ -316,7 +325,11 @@ export default function commandsExtension(pi: ExtensionAPI) {
     // escape as unhandled; surface it as a no-op instead of leaving the session silently
     // on the command's override model.
     set: (model) => {
-      void pi.setModel(model as Parameters<typeof pi.setModel>[0]).catch(() => {})
+      // A refused switch leaves the turn on the session model rather than the one the
+      // command named, and the reply gives no sign of it, so the refusal is reported.
+      void pi.setModel(model as Parameters<typeof pi.setModel>[0]).catch((error: unknown) => {
+        console.warn(`pi-code-commands: could not switch to ${typeof model === 'object' && model !== null && 'id' in model ? String((model as { id: unknown }).id) : String(model)}: ${error instanceof Error ? error.message : String(error)}`)
+      })
     },
   })
   /** The thinking level to restore after a command's `effort:` override drove its run,
@@ -496,8 +509,12 @@ export default function commandsExtension(pi: ExtensionAPI) {
       let parsed: ParsedCommand
       try {
         parsed = parseCommandFile(fs.readFileSync(command.filePath, 'utf-8'))
-      } catch {
-        continue // an unreadable command file must not take down session start
+      } catch (error) {
+        // An unreadable file must not take down session start, but the command is then
+        // absent from /help and unresolvable by the model, which looks like one that was
+        // never written.
+        console.warn(`pi-code-commands: ignoring ${command.filePath}: ${error instanceof Error ? error.message : String(error)}`)
+        continue
       }
       discovered.set(command.name, command)
       // A user-only command stays off the tool description; it is still in the

package/extensions/git-checkpoint.ts

@@ -210,7 +210,7 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     }
     // Written on every start, so repos that predate the sidecar pick it up too.
     rememberWorkTree(shadowDir, ctx.cwd)
-    await mirrorLocalExcludes(ctx.cwd)
+    await mirrorLocalExcludes(ctx)
   }
 
   /** git reads ignore rules from the tree's .gitignore files, the user's global excludes,
@@ -219,7 +219,8 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
    * would be snapshotted and restored. Mirror it into the shadow on every start; the
    * global excludes stay untouched (core.excludesFile is single-valued, so pointing it
    * at the repo file would replace them). */
-  async function mirrorLocalExcludes(cwd: string): Promise<void> {
+  async function mirrorLocalExcludes(ctx: ExtensionContext): Promise<void> {
+    const cwd = ctx.cwd
     if (!shadowDir) return
     // Resolved through git so a linked worktree maps to its common dir; outside a repo
     // git exits 128 and there is nothing to mirror.
@@ -233,8 +234,10 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
       } else {
         fs.rmSync(target, { force: true })
       }
-    } catch {
-      // A failed mirror only means local excludes are not honored this session.
+    } catch (error) {
+      // Without the mirror, files the user excluded locally are snapshotted into the
+      // checkpoint store and restored by /rewind, so this is not a silent fallback.
+      ctx.ui.notify(`Checkpoints cannot honor this repository's .git/info/exclude: ${error instanceof Error ? error.message : String(error)}`, 'warning')
     }
   }
 

package/extensions/hooks/config.ts

@@ -200,7 +200,10 @@ function mergeHooksJson(config: HooksConfig, raw: string, source: string, source
   let parsed: { hooks?: HooksConfig }
   try {
     parsed = JSON.parse(raw)
-  } catch {
+  } catch (error) {
+    // Every hook this source declares is now absent, a policy hook among them, so the
+    // failure is named rather than left to look like a file with no hooks in it.
+    console.warn(`pi-code-hooks: ignoring the hooks in ${source}: ${error instanceof Error ? error.message : String(error)}`)
     return
   }
   for (const [event, matchers] of Object.entries(parsed?.hooks ?? {})) {

package/extensions/hooks/matcher.ts

@@ -59,8 +59,10 @@ function compileMatcher(matcher: string): CompiledMatcher {
   } else {
     try {
       compiled = { regex: new RegExp(matcher, 'i') }
-    } catch {
-      // An invalid regex matcher falls back to exact-name matching, as before.
+    } catch (error) {
+      // The fallback matches the literal text, which almost never matches a tool name, so
+      // the hook simply never fires. Say so: the matcher reads as merely wrong otherwise.
+      console.warn(`pi-code-hooks: matcher ${matcher} is not a valid regular expression (${error instanceof Error ? error.message : String(error)}); it will only match a tool of that exact name`)
       compiled = { tokens: exactTokens(matcher) }
     }
   }

package/extensions/internal/plugins.ts

@@ -31,10 +31,19 @@ export interface InstalledPlugin {
 }
 
 function readJson(file: string): Record<string, unknown> {
+  let raw: string
   try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
-    return parsed !== null && typeof parsed === 'object' ? parsed : {}
+    raw = fs.readFileSync(file, 'utf-8')
   } catch {
+    return {} // no such file: nothing to read, and most callers expect that
+  }
+  try {
+    const parsed = JSON.parse(raw)
+    return parsed !== null && typeof parsed === 'object' ? parsed : {}
+  } catch (error) {
+    // A manifest that does not parse leaves the plugin with no components at all, and
+    // settings that do not parse drop the enablement or configuration they carried.
+    console.warn(`pi-code-plugins: ignoring ${file}: ${error instanceof Error ? error.message : String(error)}`)
     return {}
   }
 }

package/extensions/mcp/oauth-flow.ts

@@ -28,6 +28,12 @@ function asOAuthRequiredError(name: string, error: unknown): OAuthRequiredError
  * (stored-token) connects do not pass through here and stay fully parallel. */
 let oauthQueue: Promise<unknown> = Promise.resolve()
 
+/** Test seam: the queue is module state that outlives a test, so one login left pending
+ * would serialize every later login in the same file behind it. */
+export function resetOAuthQueue(): void {
+  oauthQueue = Promise.resolve()
+}
+
 export function serializeInteractiveOAuth<T>(run: () => Promise<T>): Promise<T> {
   const result = oauthQueue.then(run, run)
   oauthQueue = result.then(

package/extensions/mcp/policy.ts

@@ -97,11 +97,19 @@ function parsePolicyEntry(entry: unknown): McpPolicyEntry | undefined {
  * honored scope sets the key; an empty list is an explicit lockdown (deny all). */
 export function mcpAllowDeny(scopeFiles: string[] = [], managedFile: string = managedSettingsFile()): McpPolicy {
   const read = (file: string): Record<string, unknown> => {
+    let raw: string
     try {
-      const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
+      raw = fs.readFileSync(file, 'utf-8')
+    } catch {
+      return {} // no such file: genuinely no policy
+    }
+    try {
+      const parsed = JSON.parse(raw)
       return parsed && typeof parsed === 'object' ? parsed : {}
     } catch {
-      // Missing or invalid file contributes no policy.
+      // Present but unreadable: its allow and deny lists are not in force, and a deny list
+      // silently dropped leaves every server allowed.
+      console.warn(`pi-code-mcp: ignoring ${file}: not valid JSON; its MCP allow and deny lists are not applied`)
       return {}
     }
   }

package/extensions/mcp/transport.ts

@@ -336,15 +336,29 @@ export async function connectWithRetries(name: string, config: ServerConfig, aut
  * environment helperEnv built. It runs through the platform shell (/bin/sh; Git Bash
  * or PowerShell on Windows). A failure, a 10s timeout, or a machine with no shell
  * yields no extra headers rather than blocking the connection. */
-function runHeadersHelper(command: string, env: NodeJS.ProcessEnv): Promise<Record<string, string>> {
+export function runHeadersHelper(command: string, env: NodeJS.ProcessEnv, resolve_ = resolveShell): Promise<Record<string, string>> {
   return new Promise((resolve) => {
-    const shell = resolveShell(undefined)
+    // The resolver is a parameter so a test can drive both outcomes on any platform:
+    // stubbing the platform cannot produce a shell-less host on a machine that has one.
+    const shell = resolve_(undefined)
     if (!shell) {
       resolve({})
       return
     }
+    const server = env.CLAUDE_CODE_MCP_SERVER_NAME ?? 'the server'
     execFile(shell.file, shell.argsFor(command), { timeout: 10_000, env }, (error, stdout) => {
-      resolve(error ? {} : parseHelperHeaders(stdout))
+      if (error) {
+        // The connect proceeds unauthenticated and the server answers 401, which reads as
+        // a login problem rather than a helper that never produced a header.
+        console.warn(`pi-code-mcp: the headersHelper for ${server} failed: ${error.message}; connecting without the headers it would have supplied`)
+        resolve({})
+        return
+      }
+      const headers = parseHelperHeaders(stdout)
+      if (Object.keys(headers).length === 0 && stdout.trim().length > 0) {
+        console.warn(`pi-code-mcp: the headersHelper for ${server} produced no usable headers; it must print a JSON object of header names to string values`)
+      }
+      resolve(headers)
     })
   })
 }

package/extensions/memory.ts

@@ -149,8 +149,10 @@ export function migrateLegacyStore(cwd: string): void {
     if (legacy === current || !fs.existsSync(legacy)) continue
     try {
       fs.renameSync(legacy, current)
-    } catch {
-      // A failed migration must not take down session start; the store stays put.
+    } catch (error) {
+      // A failed migration must not take down session start, but the session then has no
+      // memories while they sit under the old slug, which reads as having lost them.
+      console.warn(`pi-code-memory: could not move ${legacy} to ${current}: ${error instanceof Error ? error.message : String(error)}; this session starts without those memories`)
     }
     return
   }
@@ -230,7 +232,12 @@ function readMemory(dir: string, name: string): MemoryToolResult {
   try {
     const body = fs.readFileSync(path.join(dir, `${name}.md`), 'utf-8')
     return { content: [{ type: 'text', text: capForContext(body) }], details: {} }
-  } catch {
+  } catch (error) {
+    // Only a missing file is "no such memory"; anything else (a directory in its place, a
+    // permission problem) sends the model hunting for a name that is actually there.
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      return { content: [{ type: 'text', text: `Memory ${name} could not be read: ${error instanceof Error ? error.message : String(error)}` }], details: {} }
+    }
     return { content: [{ type: 'text', text: `No memory named ${name}.` }], details: {} }
   }
 }

package/extensions/subagent/agents.ts

@@ -177,8 +177,11 @@ function parseAgentFile(content: string, source: AgentSource, filePath: string,
   let parsed: { frontmatter: Record<string, unknown>; body: string }
   try {
     parsed = parseFrontmatter<Record<string, unknown>>(content)
-  } catch {
-    return null // malformed YAML must not abort discovery for the whole directory
+  } catch (error) {
+    // Malformed YAML must not abort discovery for the whole directory, but a silent drop
+    // reads as "that agent does not exist", so it is named like the other rejections here.
+    console.warn(`pi-code-subagent: ignoring agent ${filePath}: its frontmatter could not be parsed (${error instanceof Error ? error.message : String(error)})`)
+    return null
   }
   const { frontmatter, body } = parsed
   const name = agentName(frontmatter, filePath, pluginName)

package/extensions/subagent/background.ts

@@ -204,7 +204,7 @@ export function resumeBackgroundRun(id: string, task: string, onComplete: (run:
   if (!fs.existsSync(run.spawn.cwd)) return 'cwd-gone'
   // Persisted so the rebuild happens once: rebuilding per resume leaked one temp
   // prompt dir every follow-up.
-  const rebuilt = withRebuiltPrompt(run.spawn)
+  const rebuilt = withRebuiltPrompt(run.spawn, run.agent)
   run.spawn = { ...run.spawn, args: rebuilt.args }
   if (rebuilt.dir) run.rebuiltPromptDir = rebuilt.dir
   // The task prompt is always the final argument: both spawn paths push it last and the
@@ -228,7 +228,7 @@ export function resumeBackgroundRun(id: string, task: string, onComplete: (run:
 
 /** Re-point --system-prompt at a fresh file when the original is gone; `dir` is the
  * temp dir created for it, which the run then owns. */
-function withRebuiltPrompt(spawnSpec: BackgroundSpawn): { args: string[]; dir?: string } {
+function withRebuiltPrompt(spawnSpec: BackgroundSpawn, agent: string): { args: string[]; dir?: string } {
   const flag = spawnSpec.args.indexOf('--system-prompt')
   if (flag === -1 || !spawnSpec.promptBody) return { args: spawnSpec.args }
   const current = spawnSpec.args[flag + 1]
@@ -240,9 +240,12 @@ function withRebuiltPrompt(spawnSpec: BackgroundSpawn): { args: string[]; dir?:
     const rebuilt = [...spawnSpec.args]
     rebuilt[flag + 1] = file
     return { args: rebuilt, dir }
-  } catch {
+  } catch (error) {
     // Cannot rewrite it: drop the pair rather than hand pi a path it will treat as
-    // prompt text, which would replace the agent persona with a temp path.
+    // prompt text, which would replace the agent persona with a temp path. The child then
+    // runs as a plain assistant instead of the agent asked for, and nothing in its output
+    // says so, hence the notice.
+    console.warn(`pi-code-subagent: resuming ${agent} without its agent prompt: ${error instanceof Error ? error.message : String(error)}`)
     return { args: spawnSpec.args.filter((_arg, i) => i !== flag && i !== flag + 1) }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "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",