pi-code 0.3.1 → 0.3.2

package/extensions/git-checkpoint.ts

@@ -106,18 +106,29 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
     const createdAt = new Date().toISOString()
     const add = await gitShadow(['add', '-A'])
     if (add.code !== 0) return undefined
-    const commit = await gitShadow(['commit', '-m', 'checkpoint'])
-    if (commit.code !== 0) {
-      // nothing changed since the last snapshot: reuse HEAD, or create the first empty commit
+    // Decide "nothing changed" from the index, not from the commit exit code: a commit can
+    // also fail on the user's global signing or hooks config, and reusing HEAD then would
+    // record a ref that predates the current tree, so /rewind restores the wrong state.
+    const status = await gitShadow(['status', '--porcelain'])
+    const nothingChanged = status.code === 0 && status.stdout.trim() === ''
+    if (nothingChanged) {
       const head = await gitShadow(['rev-parse', 'HEAD'])
       if (head.code === 0) return { ref: head.stdout.trim(), createdAt }
-      const empty = await gitShadow(['commit', '--allow-empty', '-m', 'checkpoint'])
+      const empty = await commitShadow(['--allow-empty'])
       if (empty.code !== 0) return undefined
+    } else {
+      const commit = await commitShadow([])
+      if (commit.code !== 0) return undefined // real failure: do not record a stale ref
     }
     const sha = await gitShadow(['rev-parse', 'HEAD'])
     return sha.code === 0 ? { ref: sha.stdout.trim(), createdAt } : undefined
   }
 
+  /** Commit in the shadow repo, isolated from the user's global signing and hook config. */
+  function commitShadow(extra: string[]): ReturnType<ExtensionAPI['exec']> {
+    return gitShadow(['-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', ...extra, '-m', 'checkpoint'])
+  }
+
   async function restoreCode(ctx: ExtensionCommandContext, checkpoint: Checkpoint): Promise<boolean> {
     if (!checkpoint.ref) {
       ctx.ui.notify('Checkpoint has no code snapshot; code left untouched', 'warning')

package/extensions/hooks.ts

@@ -102,7 +102,7 @@ export function matchingCommands(matchers: HookMatcher[] | undefined, name: stri
   return result
 }
 
-function tryParseJson(text: string): { hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string }; decision?: string; reason?: string } | undefined {
+function tryParseJson(text: string): { hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string }; decision?: string; reason?: string; continue?: boolean; stopReason?: string } | undefined {
   try {
     return JSON.parse(text)
   } catch {
@@ -115,8 +115,11 @@ export function interpretHookResult(code: number, stdout: string, stderr: string
   if (code === 2) return { block: true, reason: stderr.trim() || 'Blocked by hook' }
   const parsed = tryParseJson(stdout)
   const specific = parsed?.hookSpecificOutput
-  if (specific?.permissionDecision === 'deny') return { block: true, reason: specific.permissionDecisionReason ?? 'Blocked by hook' }
+  // pi's tool_call return is allow-or-block, so "ask" (confirm) maps to block-with-reason
+  // rather than a silent allow, which is the least-safe reading on a trust-gated path.
+  if (specific?.permissionDecision === 'deny' || specific?.permissionDecision === 'ask') return { block: true, reason: specific.permissionDecisionReason ?? 'Blocked by hook' }
   if (parsed?.decision === 'block') return { block: true, reason: parsed.reason ?? 'Blocked by hook' }
+  if (parsed?.continue === false) return { block: true, reason: parsed.stopReason ?? 'Blocked by hook' }
   return { block: false }
 }
 

package/extensions/internal/web-transport.ts

@@ -21,6 +21,9 @@ export interface TransportOptions {
   userAgent: string
 }
 
+/** Statuses the WHATWG Response constructor forbids a body on (per the fetch spec). */
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304])
+
 /** One request, no redirect following (the caller re-validates and re-pins per hop). */
 export function httpFetch(url: URL, opts: TransportOptions): Promise<Response> {
   const request = url.protocol === 'https:' ? httpsRequest : httpRequest
@@ -36,13 +39,23 @@ export function httpFetch(url: URL, opts: TransportOptions): Promise<Response> {
         // validation use the real host even though the socket connects to the pinned IP.
       },
       (res) => {
-        const headers = new Headers()
-        for (const [key, value] of Object.entries(res.headers)) {
-          if (typeof value === 'string') headers.set(key, value)
-          else if (Array.isArray(value)) headers.set(key, value.join(', '))
+        try {
+          const headers = new Headers()
+          for (const [key, value] of Object.entries(res.headers)) {
+            if (typeof value === 'string') headers.set(key, value)
+            else if (Array.isArray(value)) headers.set(key, value.join(', '))
+          }
+          const status = res.statusCode ?? 0
+          // The Response constructor throws for a non-null body on a null-body status
+          // (204/205/304) and for status 0. That throw fires here, off the Promise
+          // executor, so without this guard it escapes as an uncaughtException and pi
+          // exits. Give those statuses a null body; reject anything else that throws.
+          const body = NULL_BODY_STATUSES.has(status) ? null : (Readable.toWeb(res) as ReadableStream<Uint8Array>)
+          resolve(new Response(body, { status, headers }))
+        } catch (err) {
+          res.resume() // drain so the socket can close
+          reject(err)
         }
-        const body = Readable.toWeb(res) as ReadableStream<Uint8Array>
-        resolve(new Response(body, { status: res.statusCode ?? 0, headers }))
       },
     )
     req.on('error', reject)

package/extensions/mcp.ts

@@ -113,20 +113,24 @@ interface McpContentBlock {
 export type ToolContent = { type: 'text'; text: string } | { type: 'image'; data: string; mimeType: string }
 
 export function mapContent(content: McpContentBlock[] | undefined, structured?: unknown): ToolContent[] {
+  // capForContext every text output, whatever its source: a server can blow the tool-output
+  // budget through a resource block, a JSON-stringified block, or the structured fallback,
+  // not only a text block.
+  const text = (value: string): ToolContent => ({ type: 'text', text: capForContext(value) })
   if (!content || content.length === 0) {
-    return [{ type: 'text', text: structured !== undefined ? JSON.stringify(structured, null, 2) : '(empty result)' }]
+    return [text(structured !== undefined ? JSON.stringify(structured, null, 2) : '(empty result)')]
   }
   return content.map((block) => {
     if (block.type === 'text') {
-      return { type: 'text', text: capForContext(block.text ?? '') }
+      return text(block.text ?? '')
     }
     if (block.type === 'image' && block.data) {
       return { type: 'image', data: block.data, mimeType: block.mimeType ?? 'image/png' }
     }
     if (block.type === 'resource' && block.resource) {
-      return { type: 'text', text: `[Resource: ${block.resource.uri ?? 'unknown'}]\n${block.resource.text ?? ''}` }
+      return text(`[Resource: ${block.resource.uri ?? 'unknown'}]\n${block.resource.text ?? ''}`)
     }
-    return { type: 'text', text: JSON.stringify(block) }
+    return text(JSON.stringify(block))
   })
 }
 
@@ -165,33 +169,53 @@ async function connect(name: string, config: ServerConfig): Promise<Client> {
       cwd: config.cwd?.replace(/^~(?=\/|$)/, os.homedir()),
       stderr: 'ignore',
     })
-    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `connect ${name}`)
+    await connectWithTimeout(client, transport, `connect ${name}`)
     return client
   }
   const headers: Record<string, string> = {}
   for (const [key, value] of Object.entries(config.headers ?? {})) headers[key] = interpolateEnv(value)
-  const token = config.bearerToken ?? (config.bearerTokenEnv ? process.env[config.bearerTokenEnv] : undefined)
+  const token = config.bearerToken ? interpolateEnv(config.bearerToken) : config.bearerTokenEnv ? process.env[config.bearerTokenEnv] : undefined
   if (token) headers.Authorization = `Bearer ${token}`
   const url = new URL(interpolateEnv(config.url))
   if (config.type === 'sse') {
     const transport = new SSEClientTransport(url, { requestInit: { headers } }) // NOSONAR: explicitly declared legacy transport
-    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `connect ${name} (sse)`)
+    await connectWithTimeout(client, transport, `connect ${name} (sse)`)
     return client
   }
   try {
     const transport = new StreamableHTTPClientTransport(url, { requestInit: { headers } })
-    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `connect ${name}`)
+    await connectWithTimeout(client, transport, `connect ${name}`)
     return client
   } catch (error) {
     // An explicitly declared streamable transport must not silently degrade to SSE.
     if (config.type !== undefined || String(error).includes('Unauthorized')) throw error
     const fallback = new Client({ name: 'pi-code-mcp', version: '0.1.0' })
     const transport = new SSEClientTransport(url, { requestInit: { headers } }) // NOSONAR: deliberate legacy fallback
-    await withTimeout(fallback.connect(transport), CONNECT_TIMEOUT_MS, `connect ${name} (sse)`)
+    await connectWithTimeout(fallback, transport, `connect ${name} (sse)`)
     return fallback
   }
 }
 
+/**
+ * Connect with a deadline, closing the client if the deadline (not a connect error) wins.
+ * Without this, a slow-but-successful server finishes connecting after the race is lost and
+ * lingers unreferenced: process/socket alive, never in `clients`, invisible to shutdown.
+ */
+async function connectWithTimeout(client: Client, transport: Parameters<Client['connect']>[0], label: string): Promise<void> {
+  const connecting = client.connect(transport)
+  try {
+    await withTimeout(connecting, CONNECT_TIMEOUT_MS, label)
+  } catch (error) {
+    // Only a timeout can orphan a still-opening transport; a connect rejection means the
+    // SDK already tore it down, so closing again would be redundant.
+    if (String(error).includes('timed out after')) {
+      connecting.catch(() => {}) // a late rejection must not surface as unhandled
+      void client.close().catch(() => {})
+    }
+    throw error
+  }
+}
+
 async function listAllTools(client: Client): Promise<Array<{ name: string; description?: string; inputSchema?: unknown }>> {
   const tools: Array<{ name: string; description?: string; inputSchema?: unknown }> = []
   let cursor: string | undefined
@@ -236,7 +260,9 @@ export default async function mcpExtension(pi: ExtensionAPI) {
             description: tool.description ?? `MCP tool ${tool.name} from ${name}`,
             parameters: Type.Unsafe(normalizeSchema(tool.inputSchema)),
             async execute(_id, params) {
-              const result = await withTimeout(client.callTool({ name: tool.name, arguments: params as Record<string, unknown> }), CALL_TIMEOUT_MS, toolName)
+              // Pass the timeout to the SDK too: its own default request timeout is 60s and
+              // would otherwise reject first, so the outer race at CALL_TIMEOUT_MS was dead.
+              const result = await withTimeout(client.callTool({ name: tool.name, arguments: params as Record<string, unknown> }, undefined, { timeout: CALL_TIMEOUT_MS }), CALL_TIMEOUT_MS, toolName)
               const content = mapContent(result.content as McpContentBlock[], result.structuredContent)
               const details: { error?: string } = {}
               if (result.isError) {

package/extensions/plan-mode/index.ts

@@ -114,6 +114,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
       restoreTools()
       ctx.ui.notify('Plan mode disabled. Full access restored.')
     }
+    // Persist the toggle so a resume does not restore a state the user left.
+    persistState()
     updateStatus(ctx)
   }
 
@@ -158,6 +160,9 @@ export default function planModeExtension(pi: ExtensionAPI): void {
       restoreTools()
       updateStatus(ctx)
 
+      // Persist before the turn: a crash before the first turn_end must resume into
+      // execution, not back into plan mode.
+      persistState()
       const execMessage = todoItems.length > 0 ? `Execute the plan. Start with: ${todoItems[0].text}` : 'Execute the plan you just created.'
       pi.sendMessage({ customType: 'plan-mode-execute', content: execMessage, display: true }, { triggerTurn: true })
     } else if (choice === 'Refine the plan') {
@@ -351,6 +356,13 @@ After completing a step, include a [DONE:n] tag in your response.`,
 
   // Restore state on session start/resume
   pi.on('session_start', async (_event, ctx) => {
+    // One extension instance serves every session, so clear prior state first: a fresh
+    // session (/new, no plan entry) must not inherit the last session's plan or execution.
+    planModeEnabled = false
+    executionMode = false
+    todoItems = []
+    planFromTool = false
+
     if (pi.getFlag('plan') === true) {
       planModeEnabled = true
     }
@@ -375,6 +387,10 @@ After completing a step, include a [DONE:n] tag in your response.`,
 
     if (planModeEnabled) {
       enterPlanTools()
+    } else {
+      // A prior session in this instance may have shrunk the tool set; undo that when
+      // the restored/fresh state is not plan mode.
+      restoreTools()
     }
     updateStatus(ctx)
   })

package/extensions/plan-mode/utils.ts

@@ -191,9 +191,11 @@ export function cleanStepText(text: string): string {
   return cleaned
 }
 
-// Horizontal whitespace before the newline: \s would include \n itself and overlap
-// the following \n, which is what backtracks super-linearly.
-const PLAN_HEADER = /\*{0,2}Plan:\*{0,2}[^\S\n]*\n/i
+// Anchored to line start (m flag) so a prose line merely ending in "plan:" is not taken
+// for the header, which would slice the plan section mid-list and drop earlier steps.
+// Horizontal whitespace only ([^\S\n]): \s would include \n itself and overlap the
+// following \n, which is what backtracks super-linearly.
+const PLAN_HEADER = /^[^\S\n]*\*{0,2}Plan:\*{0,2}[^\S\n]*\n/im
 
 const isBlank = (ch: string | undefined): boolean => ch !== undefined && ch !== '\n' && ch.trim() === ''
 

package/extensions/status-line.ts

@@ -40,6 +40,8 @@ export default function statusLine(pi: ExtensionAPI) {
   }
 
   pi.on('session_start', async (_event, ctx) => {
+    // One instance serves every session, so a fresh session must not inherit the count.
+    turnCount = 0
     showIdle(ctx, ctx.ui.theme.fg('dim', '○'))
   })
 

package/extensions/subagent/background.ts

@@ -83,6 +83,13 @@ export function startBackgroundRun(agent: string, task: string, invocation: Back
     env: { ...process.env, PI_CODE_SUBAGENT: '1' },
   })
   let stdout = ''
+  // Node fires both 'error' and 'close' on a spawn failure (ENOENT); complete once.
+  let completed = false
+  const complete = (): void => {
+    if (completed) return
+    completed = true
+    onComplete(run)
+  }
   proc.stdout.on('data', (data) => {
     stdout += data.toString()
   })
@@ -92,12 +99,12 @@ export function startBackgroundRun(agent: string, task: string, invocation: Back
     run.exitCode = code ?? 0
     run.output = text
     run.turns = turns
-    onComplete(run)
+    complete()
   })
   proc.on('error', () => {
     run.state = 'failed'
     run.exitCode = 1
-    onComplete(run)
+    complete()
   })
   return id
 }

package/extensions/subagent/index.ts

@@ -486,6 +486,10 @@ async function checkProjectAgentGate(params: SubagentParamsStatic, agents: Agent
   for (const t of params.tasks ?? []) requestedAgentNames.add(t.agent)
   const requestedProjectAgents = [...requestedAgentNames].map((name) => agents.find((a) => a.name === name)).filter((a): a is AgentConfig => a?.source === 'project')
 
+  // No project agents means nothing repo-controlled to gate; skip the approval check so a
+  // user-scope run never prompts or persists a trust decision it does not need.
+  if (requestedProjectAgents.length === 0) return null
+
   // isProjectTrusted alone is true for a repo pi never asked about; see project-approval.
   const approved = await isProjectApproved(ctx)
   const gate = projectAgentGate(requestedProjectAgents.length, approved, ctx.hasUI, params.confirmProjectAgents ?? true)
@@ -692,8 +696,11 @@ async function runParallelMode(tasks: TaskItemParam[], mode: ModeContext): Promi
       signal,
       // Per-task update callback
       onUpdate: (partial) => {
-        if (partial.details?.results[0]) {
-          allResults[index] = partial.details.results[0]
+        const live = partial.details?.results[0]
+        if (live) {
+          // Keep the running sentinel until the child closes: the streamed result carries
+          // exitCode 0 mid-run, which would otherwise count and render the task as done.
+          allResults[index] = { ...live, exitCode: -1 }
           emitParallelUpdate()
         }
       },

package/package.json

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