pi-code 1.0.62 → 1.0.64

package/extensions/subagent/modes.ts

@@ -152,18 +152,6 @@ export async function runBackgroundMode(params: SubagentParamsStatic, context: B
     return backgroundCapResult(makeDetails)
   }
   const runCwd = params.cwd ?? defaultCwd
-  // The same isolation boundary as the foreground path: no worktree, no run.
-  let worktree: AgentWorktree | undefined
-  if (agent.isolation === 'worktree') {
-    const created = await createAgentWorktree(runCwd, agent.name)
-    if ('error' in created) {
-      return {
-        content: [{ type: 'text', text: `isolation: worktree could not be created for ${agent.name}: ${created.error}` }],
-        details: makeDetails('single')([]),
-      }
-    }
-    worktree = created
-  }
   // Anchor project/local memory at the session project (defaultCwd), which is the one
   // projectApproved gated; see the foreground path for why runCwd must not be used.
   const memorySection = agentMemoryPromptSection(agent, defaultCwd, projectApproved)
@@ -176,6 +164,21 @@ export async function runBackgroundMode(params: SubagentParamsStatic, context: B
     // foreground path).
     args.push('--system-prompt', tmpPrompt.filePath)
   }
+  // The same isolation boundary as the foreground path: no worktree, no run. Created
+  // after the temp prompt, so a prompt write that throws has nothing to leak; the cap
+  // refusal below removes it again.
+  let worktree: AgentWorktree | undefined
+  if (agent.isolation === 'worktree') {
+    const created = await createAgentWorktree(runCwd, agent.name)
+    if ('error' in created) {
+      removeTmpPrompt(tmpPrompt)
+      return {
+        content: [{ type: 'text', text: `isolation: worktree could not be created for ${agent.name}: ${created.error}` }],
+        details: makeDetails('single')([]),
+      }
+    }
+    worktree = created
+  }
   // The id is preset so SubagentStart hooks run pre-spawn with the id the run
   // will actually carry, and their context lands before the child's first prompt.
   const presetId = `bg-${randomUUID().slice(0, 8)}`
@@ -216,8 +219,10 @@ export async function runBackgroundMode(params: SubagentParamsStatic, context: B
     presetId,
   )
   if (id === null) {
-    // Lost the cap race to a parallel batch: the atomic check inside startBackgroundRun refused.
+    // Lost the cap race to a parallel batch: the atomic check inside startBackgroundRun
+    // refused. A pristine worktree is removed by the same cleanup a finished run uses.
     removeTmpPrompt(tmpPrompt)
+    if (worktree) await cleanupAgentWorktree(runCwd, worktree).catch(() => {})
     return backgroundCapResult(makeDetails)
   }
   pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: agent.name, agentId: id })

package/extensions/subagent/params.ts

@@ -23,8 +23,7 @@ export const ChainItem = Type.Object({
 })
 
 const AgentScopeSchema = StringEnum(['user', 'project', 'both'] as const, {
-  description: 'Which agent directories to use. Default: "user". Use "both" to include project-local agents.',
-  default: 'user',
+  description: 'Which agent directories to use. Omitted, an approved project resolves to "both" and an unapproved one to "user"; "both" includes project-local agents.',
 })
 
 export const SubagentParams = Type.Object({

package/extensions/subagent/run.ts

@@ -6,16 +6,18 @@
  * 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'
 import { withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 
+import { killProcessTree } from '../internal/process-tree.js'
 import { runSubagentStartHooks } from '../internal/subagent-hooks.js'
 import { type AgentConfig, resolveModelAlias } from './agents.js'
 import { agentHooksEnv, agentInvocationArgs, agentMemoryPromptSection, childPromptBody, taskWithStartContext, unresolvedToolsError, withMemoryTools } from './child.js'
@@ -123,6 +125,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. */
+export 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 +269,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
 
@@ -323,19 +349,7 @@ async function runSingleAgentInner(options: RunAgentOptions): Promise<SingleResu
         resolve(1)
       })
 
-      const killGroup = (sig: NodeJS.Signals): void => {
-        try {
-          // A child that never spawned has no pid and no group; the direct kill is all there is.
-          if (proc.pid) process.kill(-proc.pid, sig)
-          else proc.kill(sig)
-        } catch {
-          try {
-            proc.kill(sig)
-          } catch {
-            /* already gone */
-          }
-        }
-      }
+      const killGroup = (sig: NodeJS.Signals): void => killProcessTree(proc, sig)
       if (signal) {
         onAbort = () => {
           wasAborted = true

package/extensions/thinking.ts

@@ -1,9 +1,9 @@
 /**
  * Thinking Keyword Escalation
  *
- * Claude Code raises reasoning effort for a single turn when the prompt carries a
- * think keyword: `ultrathink` asks for the maximum, `think hard`/`think harder` for
- * a high level, and a bare `think` for a medium one. The word stays in the prompt
+ * Claude Code raises reasoning effort for a single turn when the prompt carries
+ * `ultrathink`, the only keyword: `think`, `think hard` and similar phrases pass
+ * through as ordinary prompt text. The word stays in the prompt
  * (the input is observed, never consumed or transformed), the escalation only ever
  * raises the level, and the prior level is restored once the turn settles, mirroring
  * how commands.ts restores a per-command model override on agent_settled.

package/extensions/web.ts

@@ -16,6 +16,7 @@ import { Type } from 'typebox'
 import { htmlToMarkdown, removeTags } from './internal/html-markdown.js'
 import { completeText } from './internal/model-complete.js'
 import { capForContext } from './internal/output-guard.js'
+import { parseNumericEnv } from './internal/values.js'
 import { httpFetch } from './internal/web-transport.js'
 
 const SEARCH_ENDPOINT = 'https://html.duckduckgo.com/html/?q='
@@ -265,10 +266,8 @@ async function fetchText(rawUrl: string, crossHost: CrossHost, transport = httpF
 const FETCH_CACHE_TTL_DEFAULT_MS = 15 * 60 * 1000
 
 function fetchCacheTtlMs(): number {
-  const raw = process.env.CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS
-  if (raw === undefined || raw.trim() === '') return FETCH_CACHE_TTL_DEFAULT_MS
-  const parsed = Number(raw)
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : FETCH_CACHE_TTL_DEFAULT_MS
+  const parsed = parseNumericEnv(process.env.CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS)
+  return parsed !== undefined && parsed >= 0 ? parsed : FETCH_CACHE_TTL_DEFAULT_MS
 }
 const FETCH_CACHE_MAX_ENTRIES = 50
 

package/package.json

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