pi-code 1.0.51 → 1.0.53

package/extensions/claude-rules.ts

@@ -39,12 +39,47 @@ function unquote(value: string): string {
   return value.replace(/^["']|["']$/g, '')
 }
 
+/** Split a YAML flow sequence on its top-level commas. A comma inside a brace group
+ * (`*.{ts,tsx}`, which Claude expands) or inside quotes belongs to its entry, so
+ * splitting on every comma produced patterns that match nothing. */
 function splitInline(value: string): string[] {
-  return value
-    .replace(/^\[|\]$/g, '')
-    .split(',')
-    .map((entry) => unquote(entry.trim()))
-    .filter(Boolean)
+  const entries: string[] = []
+  let current = ''
+  let depth = 0
+  let quote: string | undefined
+  for (const char of value.replace(/^\[/, '').replace(/\]$/, '')) {
+    if (quote !== undefined) {
+      if (char === quote) quote = undefined
+      current += char
+      continue
+    }
+    if (char === '"' || char === "'") {
+      quote = char
+      current += char
+      continue
+    }
+    if (char === '{') depth++
+    else if (char === '}') depth = Math.max(0, depth - 1)
+    else if (char === ',' && depth === 0) {
+      entries.push(current)
+      current = ''
+      continue
+    }
+    current += char
+  }
+  entries.push(current)
+  return entries.map((entry) => unquote(entry.trim())).filter(Boolean)
+}
+
+/** A flow sequence that opens on the `paths:` line and closes on a later one, joined
+ * back into a single value. An unterminated list runs to the end of the frontmatter. */
+function joinFlowSequence(lines: string[], index: number, opening: string): string {
+  let joined = opening
+  for (let i = index + 1; i < lines.length; i++) {
+    joined += ` ${lines[i].trim()}`
+    if (lines[i].includes(']')) break
+  }
+  return joined
 }
 
 function parsePaths(frontmatter: string): string[] {
@@ -52,7 +87,7 @@ function parsePaths(frontmatter: string): string[] {
   const index = lines.findIndex((line) => /^\s*paths\s*:/.test(line))
   if (index === -1) return []
   const inline = lines[index].replace(/^\s*paths\s*:/, '').trim()
-  if (inline) return splitInline(inline)
+  if (inline) return splitInline(inline.startsWith('[') && !inline.includes(']') ? joinFlowSequence(lines, index, inline) : inline)
   const items: string[] = []
   // Matched with string ops rather than a regex: the equivalent pattern needs two
   // adjacent whitespace quantifiers, which backtracks super-linearly on long lines.

package/extensions/commands.ts

@@ -43,10 +43,10 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
-
 import { matchesBashRules } from './internal/bash-rules.js'
 import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, type PathRuleTool, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
+import { claudeEffortLevel } from './internal/effort.js'
 import { managedSettingsFile, readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
@@ -187,7 +187,9 @@ function commandVars(ctx: { cwd: string }, filePath: string, plugin?: CommandPlu
   const varCtx = ctx as unknown as VarContext
   return {
     CLAUDE_SESSION_ID: varCtx.sessionManager?.getSessionId?.(),
-    CLAUDE_EFFORT: varCtx.thinkingLevel,
+    // Claude vocabulary only, and unset when thinking is off: the variable promises
+    // low|medium|high|xhigh|max, and an unset one stays literal in the body.
+    CLAUDE_EFFORT: claudeEffortLevel(varCtx.thinkingLevel),
     CLAUDE_SKILL_DIR: path.dirname(filePath),
     CLAUDE_PROJECT_DIR: repoRoot(ctx.cwd) ?? ctx.cwd,
     CLAUDE_PLUGIN_ROOT: plugin?.root,

package/extensions/env-settings.ts

@@ -40,7 +40,7 @@ import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-a
 import { claudeConfigDir } from './internal/config-dir.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
-import { findNearestFile } from './internal/project-root.js'
+import { claudeSettingsChain } from './internal/settings-chain.js'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -137,12 +137,14 @@ export function sanitizeProjectEnv(env: Record<string, string>, warn: (key: stri
   return kept
 }
 
-/** The project scope's env: .claude/settings.json with settings.local.json overlaid,
- * each the nearest of its name at or above cwd (matching the hooks settings chain). */
-function projectEnv(cwd: string): Record<string, string> {
-  const base = envFromSettings(readSettingsFile(findNearestFile(cwd, path.join('.claude', 'settings.json')) ?? path.join(cwd, '.claude', 'settings.json')))
-  const local = envFromSettings(readSettingsFile(findNearestFile(cwd, path.join('.claude', 'settings.local.json')) ?? path.join(cwd, '.claude', 'settings.local.json')))
-  return sanitizeProjectEnv({ ...base, ...local })
+/** The project scope's env, resolved through the shared settings chain so placement
+ * matches every other consumer: the shared settings.json comes from the session's own
+ * directory and never an ancestor, settings.local.json from the repository root. Later
+ * files win. */
+function projectEnv(cwd: string, home: string): Record<string, string> {
+  const merged: Record<string, string> = {}
+  for (const file of claudeSettingsChain(cwd, home, true).slice(1)) Object.assign(merged, envFromSettings(readSettingsFile(file)))
+  return sanitizeProjectEnv(merged)
 }
 
 export default function envSettingsExtension(pi: ExtensionAPI) {
@@ -157,6 +159,6 @@ export default function envSettingsExtension(pi: ExtensionAPI) {
   apply(os.homedir(), {})
 
   pi.on('session_start', async (_event, ctx: ExtensionContext) => {
-    apply(os.homedir(), isProjectApprovedSilently(ctx) ? projectEnv(ctx.cwd) : {})
+    apply(os.homedir(), isProjectApprovedSilently(ctx) ? projectEnv(ctx.cwd, os.homedir()) : {})
   })
 }

package/extensions/git-checkpoint.ts

@@ -18,6 +18,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { claudeConfigDir } from './internal/config-dir.js'
 
 const CUSTOM_TYPE = 'git-checkpoint'
 /** Sidecar inside the bare shadow repo recording the work tree it snapshots. */
@@ -37,6 +38,21 @@ interface Checkpoint {
  * for the life of the machine. */
 export const CHECKPOINT_RETENTION_DAYS = 30
 
+/** The retention period in effect: Claude keeps checkpoints for 30 days and says to
+ * "change the period with cleanupPeriodDays". Read from the user scope, which is where a
+ * setting about the user's own disk belongs; a non-positive or unreadable value keeps the
+ * default rather than sweeping everything away. */
+export function checkpointRetentionDays(home: string = os.homedir()): number {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(home), 'settings.json'), 'utf-8'))
+    const declared = (parsed as { cleanupPeriodDays?: unknown }).cleanupPeriodDays
+    if (typeof declared === 'number' && Number.isFinite(declared) && declared > 0) return declared
+  } catch {
+    // No user settings, or unreadable: the default period stands.
+  }
+  return CHECKPOINT_RETENTION_DAYS
+}
+
 /** Claude keeps the 100 most recent checkpoints per session. Older ones drop off the
  * rewind list; their commits stay in the shadow repo until the retention sweep. */
 export const MAX_CHECKPOINTS_PER_SESSION = 100
@@ -179,7 +195,7 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
       shadowDir = path.join(checkpointsRoot, `${sessionSlug(sessionFile)}-${cwdSlug(ctx.cwd)}`)
       ctx.ui.notify(`Checkpoints for this session were recorded in ${recorded}; starting fresh checkpoints for ${ctx.cwd} (earlier ones are not restorable here)`, 'warning')
     }
-    pruneCheckpointRepos(checkpointsRoot, CHECKPOINT_RETENTION_DAYS, shadowDir)
+    pruneCheckpointRepos(checkpointsRoot, checkpointRetentionDays(os.homedir()), shadowDir)
     const check = await pi.exec('git', ['--git-dir', shadowDir, 'rev-parse', '--git-dir'], { cwd: ctx.cwd })
     if (check.code !== 0) {
       const init = await pi.exec('git', ['init', '--bare', '-b', 'main', shadowDir], { cwd: ctx.cwd })

package/extensions/hooks/decisions.ts

@@ -147,7 +147,19 @@ function surfaceHookFailures(commands: HookCommand[], results: HookRunResult[],
     // Claude shows a `<hook> hook error` notice when {..}-shaped stdout cannot be
     // read as JSON output (exit 2 still blocks and reads its own channels).
     const jsonError = result.code === 2 ? undefined : hookJsonError(result.stdout)
-    if (jsonError !== undefined) notify(`${commands[i].command} hook error: ${jsonError}`)
+    if (jsonError !== undefined) {
+      notify(`${commands[i].command} hook error: ${jsonError}`)
+      continue
+    }
+    // A non-zero exit that is neither a block (2) nor a timeout, with nothing parseable
+    // on stdout, is Claude's non-blocking error: the action proceeds and the notice
+    // carries the first line of stderr. Without it a mistyped path in settings.json
+    // leaves a policy hook silently disabled, since the shell exits 127 and says so only
+    // on stderr. A spawn failure is reported above and skipped here.
+    if (!result.spawnFailed && !result.timedOut && result.code !== 0 && result.code !== 2) {
+      const firstLine = result.stderr.trim().split('\n')[0]
+      notify(`${commands[i].command} hook error: Failed with non-blocking status code: ${firstLine || result.code}`)
+    }
   }
 }
 
@@ -250,8 +262,6 @@ export interface PromptDecision {
   block: boolean
   reason?: string
   context: string
-  /** Claude's suppressOriginalPrompt: the hook's context replaces the prompt. */
-  suppress?: boolean
 }
 
 /** Additional context a UserPromptSubmit hook contributes: an explicit
@@ -279,17 +289,13 @@ export async function runUserPromptSubmit(config: HooksConfig, prompt: string, r
   }
   if (onSystemMessage) surfaceSystemMessages(results, onSystemMessage)
   const contexts: string[] = []
-  let suppress = false
   for (const result of results) {
     const decision = interpretHookResult(result.code, result.stdout, result.stderr)
     if (decision.block) return { block: true, reason: decision.reason, context: '' }
-    // Claude's suppressOriginalPrompt: any hook setting it hides the original
-    // prompt, and the collected context is what reaches the model.
-    if (tryParseJson(result.stdout)?.hookSpecificOutput?.suppressOriginalPrompt === true) suppress = true
     const context = promptContext(result.stdout)
     if (context) contexts.push(context)
   }
-  return { block: false, context: contexts.join('\n'), suppress }
+  return { block: false, context: contexts.join('\n') }
 }
 
 /** The feedback lines one PostToolUse/PostToolUseFailure result appends next to the

package/extensions/hooks/index.ts

@@ -96,6 +96,7 @@
 
 import * as os from 'node:os'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { claudeEffortLevel } from '../internal/effort.js'
 import { INSTRUCTIONS_CHANNEL, isInstructionLoadEvent } from '../internal/instruction-events.js'
 import { readManagedSettings } from '../internal/managed-settings.js'
 import { isMcpToolAliases, MCP_TOOLS_CHANNEL } from '../internal/mcp-alias.js'
@@ -186,6 +187,25 @@ const IDLE_PROMPT_DELAY_MS = 60_000
  * Claude Code restores on resume. */
 const MODEL_SELECT_SOURCE: Record<string, string> = { set: 'command', cycle: 'picker', restore: 'resume' }
 
+/** One Stop hook result read as a verdict. Claude: `continue` "takes precedence over any
+ * event-specific decision fields", and stopReason is the message shown when it is false,
+ * so a hook asking to stop wins over its own block whatever exit code carried it. Any
+ * blocking spelling counts, including the prompt and agent hook reply schemas, and a
+ * non-error additionalContext feeds back the same way so the block cap still bounds it. */
+function stopVerdict(result: HookRunResult, stopMessages: string[]): { block: boolean; reason: string } {
+  const parsed = tryParseJson(result.stdout)
+  if (parsed?.continue === false) {
+    if (parsed.stopReason) stopMessages.push(String(parsed.stopReason))
+    return { block: false, reason: '' }
+  }
+  if (result.code === 2) return { block: true, reason: jsonBlockVerdict(parsed, 'Stop blocked by hook')?.reason ?? (result.stderr.trim() || 'Stop blocked by hook') }
+  const verdict = jsonBlockVerdict(parsed, 'Stop blocked by hook')
+  if (verdict) return { block: true, reason: verdict.reason }
+  const context = parsed?.hookSpecificOutput?.additionalContext
+  if (typeof context === 'string' && context.length > 0) return { block: true, reason: context }
+  return { block: false, reason: '' }
+}
+
 export default function hooksExtension(pi: ExtensionAPI) {
   let config: HooksConfig = {}
   let projectDir = ''
@@ -228,7 +248,9 @@ export default function hooksExtension(pi: ExtensionAPI) {
     const common: Record<string, unknown> = { session_id: ctx.sessionManager.getSessionId(), cwd: ctx.cwd, permission_mode: permissionMode }
     const transcript = ctx.sessionManager.getSessionFile()
     if (transcript) common.transcript_path = transcript
-    if (ctx.thinkingLevel) common.effort = { level: ctx.thinkingLevel }
+    // Claude vocabulary only: pi's minimal maps to low and off carries no effort.
+    const effort = claudeEffortLevel(ctx.thinkingLevel)
+    if (effort) common.effort = { level: effort }
     return common
   }
   /** Claude's prompt-hook `model` override, resolved against the models this user
@@ -512,7 +534,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
     const response = (alias === undefined && !event.isError ? claudeToolResponse(event.toolName, event.input, textContent(event.content), event.isError, ctx.cwd) : undefined) ?? { content: event.content, details: event.details, isError: event.isError }
     const startedAt = toolStartTimes.get(event.toolCallId)
     toolStartTimes.delete(event.toolCallId)
-    const payload = { hook_event_name: eventName, tool_name: translatedName ?? event.toolName, tool_input: translatedInput ?? event.input, tool_response: response, ...(startedAt === undefined ? {} : { duration_ms: Date.now() - startedAt }) }
+    // Claude delivers a failure as top-level fields rather than a tool_response: "error
+    // information as top-level fields ... error ... is_interrupt". is_interrupt is false
+    // here because pi reports a cancelled tool through the result, not this event.
+    const failure = event.isError ? { error: textContent(event.content), is_interrupt: false } : { tool_response: response }
+    const payload = { hook_event_name: eventName, tool_name: translatedName ?? event.toolName, tool_input: translatedInput ?? event.input, ...failure, ...(startedAt === undefined ? {} : { duration_ms: Date.now() - startedAt }) }
     const run = boundRunner(ctx, { tool_use_id: event.toolCallId })
     const results = await Promise.all(commands.map((command) => run(command, payload, timeoutMs(command))))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
@@ -576,10 +602,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
       return { action: 'handled' }
     }
     // Claude injects a UserPromptSubmit hook's context ahead of the prompt; transform is
-    // pi's seam for rewriting the submitted text. With suppressOriginalPrompt the
-    // context replaces the prompt entirely (honored only when context exists, since
-    // an empty submission would be no turn at all).
-    if (decision.context) return { action: 'transform', text: decision.suppress ? decision.context : `${decision.context}\n\n${event.text}` }
+    // pi's seam for rewriting the submitted text. The prompt itself always survives:
+    // "UserPromptSubmit: can't replace the prompt; it only injects additionalContext
+    // alongside it". suppressOriginalPrompt scopes to the block message, which never
+    // carries the prompt here, so it needs nothing of its own.
+    if (decision.context) return { action: 'transform', text: `${decision.context}\n\n${event.text}` }
     return { action: 'continue' }
   })
 
@@ -593,12 +620,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
   // handler on a UI dialog, which would starve the Stop hook and idle notification
   // until the user answers it. agent_end can fire slightly early before a rare
   // automatic retry or compaction; that is the better tradeoff.
-  pi.on('agent_end', async (event, ctx) => {
-    // Claude's Notification event, for the one type pi can honestly source: the
-    // agent finished and is waiting for input. Per Claude, idle_prompt fires when
-    // the turn ended about 60 seconds ago and the user hasn't typed since, so it
-    // arms here and input or the next turn cancels it. Observational only; exit
-    // codes and JSON output are ignored, as Claude documents for this event.
+  /** Claude's Notification event, for the one type pi can honestly source: the agent
+   * finished and is waiting for input. idle_prompt fires when the turn ended about 60
+   * seconds ago and the user has not typed since, so it arms here and input or the next
+   * turn cancels it. Observational only; exit codes and JSON output are ignored. */
+  const armIdlePrompt = (ctx: ExtensionContext): void => {
     cancelIdlePrompt()
     const notifyCommands = matchingCommands(config.Notification, ['idle_prompt'])
     if (notifyCommands.length > 0) {
@@ -608,6 +634,9 @@ export default function hooksExtension(pi: ExtensionAPI) {
       }, IDLE_PROMPT_DELAY_MS)
       idlePromptTimer.unref?.()
     }
+  }
+  pi.on('agent_end', async (event, ctx) => {
+    armIdlePrompt(ctx)
 
     // In a subagent child, the agent-frontmatter Stop hooks were converted to
     // SubagentStop and fire here, at the child's own end, notify-style; before the
@@ -643,24 +672,12 @@ export default function hooksExtension(pi: ExtensionAPI) {
     const run = boundRunner(ctx)
     const results = await Promise.all(commands.map((command) => run(command, payload, timeoutMs(command))))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
+    const stopMessages: string[] = []
     const block = results
       .filter((result) => !result.timedOut)
-      .map((result) => {
-        const parsed = tryParseJson(result.stdout)
-        if (result.code === 2) return { block: true, reason: jsonBlockVerdict(parsed, 'Stop blocked by hook')?.reason ?? (result.stderr.trim() || 'Stop blocked by hook') }
-        // Any JSON blocking spelling counts, including the prompt/agent hook reply
-        // schemas (permissionDecision deny, ok:false), which arrive as stdout here.
-        const verdict = jsonBlockVerdict(parsed, 'Stop blocked by hook')
-        if (verdict) return { block: true, reason: verdict.reason }
-        // Claude's non-error continue: additionalContext feeds back and the
-        // conversation continues so Claude can act on it. It rides the same
-        // continuation path (and the same block cap) so a hook emitting it every
-        // firing cannot loop the turn forever.
-        const context = parsed?.hookSpecificOutput?.additionalContext
-        if (typeof context === 'string' && context.length > 0) return { block: true, reason: context }
-        return { block: false, reason: '' }
-      })
+      .map((result) => stopVerdict(result, stopMessages))
       .find((verdict) => verdict.block)
+    for (const message of stopMessages) ctx.ui.notify(message, 'warning')
     if (!block) {
       // A non-blocking Stop breaks the streak: the next block starts a fresh count.
       stopHookActive = false
@@ -689,6 +706,17 @@ export default function hooksExtension(pi: ExtensionAPI) {
     const payload = { hook_event_name: 'PreCompact', trigger: trigger.value, custom_instructions: event.customInstructions ?? '' }
     const results = await runNotifyHooks(matchingCommands(config.PreCompact, trigger.names), payload, boundRunner(ctx))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
+    // Claude: "Exit with code 2 to block compaction. For a manual /compact, the stderr
+    // message is shown to the user. You can also block by returning JSON with
+    // `decision: block`." pi cancels through the result, and a blocked automatic
+    // compaction is worth a notice too: the context stays full either way.
+    for (const [index, result] of results.entries()) {
+      const parsed = tryParseJson(result.stdout)
+      const blocked = result.code === 2 && !result.timedOut ? { reason: result.stderr.trim() || 'Compaction blocked by hook' } : jsonBlockVerdict(parsed, 'Compaction blocked by hook')
+      if (!blocked) continue
+      ctx.ui.notify(`Compaction blocked by ${matchingCommands(config.PreCompact, trigger.names)[index]?.command ?? 'hook'}: ${blocked.reason}`, 'warning')
+      return { cancel: true }
+    }
   })
 
   pi.on('session_compact', async (event, ctx) => {

package/extensions/hooks/matcher.ts

@@ -4,7 +4,7 @@
  * commands an event fires. Owns the module-level compiled-matcher cache.
  */
 
-import { matchesBashRules } from '../internal/bash-rules.js'
+import { matchesBashIfFilter } from '../internal/bash-rules.js'
 import { matchesPathRules, type PathAnchors } from '../internal/path-rules.js'
 import type { HookCommand, HookMatcher } from './config.js'
 
@@ -159,14 +159,16 @@ export interface IfFilterTarget {
 
 /** Claude's `if` handler field: permission-rule syntax evaluated only on tool
  * events; on any other event a hook carrying `if` never runs. A bare tool name
- * matches by name; `Bash(pattern)` evaluates against the command via the shared
- * bash-rule matcher and file-tool patterns against the path via the shared
- * permission path rules. A pattern for any other tool matches nothing, which is
+ * matches by name; `Bash(pattern)` evaluates against the command through the if-filter
+ * matcher, which is best effort and errs toward running the hook, and file-tool patterns
+ * against the path via the shared permission path rules. A pattern for any other tool matches nothing, which is
  * also what an unparseable rule does. */
 export function passesIfFilter(hook: HookCommand, target: IfFilterTarget | undefined): boolean {
   if (hook.if === undefined) return true
   if (target === undefined) return false
-  const parsed = /^([A-Za-z_|]+?)(?:\((.*)\))?$/.exec(hook.if.trim())
+  // Digits and hyphens are part of a tool name: an MCP tool is mcp__<server>__<tool> and
+  // server names carry both, so a stricter class silently matched nothing.
+  const parsed = /^([\w|-]+?)(?:\((.*)\))?$/.exec(hook.if.trim())
   if (!parsed) return false
   const fold = (name: string): string => name.toLowerCase().replaceAll('-', '_')
   const ruleTools = new Set(parsed[1].split('|').map(fold))
@@ -177,7 +179,7 @@ export function passesIfFilter(hook: HookCommand, target: IfFilterTarget | undef
   const input = target.input as Record<string, unknown> | null
   if (fold(target.piName) === 'bash' || (target.claudeName !== undefined && fold(target.claudeName) === 'bash')) {
     const command = typeof input?.command === 'string' ? input.command : ''
-    return command.length > 0 && matchesBashRules(command, [pattern])
+    return command.length > 0 && matchesBashIfFilter(command, pattern)
   }
   let filePath = ''
   if (typeof input?.path === 'string') filePath = input.path

package/extensions/internal/atomic-write.ts

@@ -0,0 +1,14 @@
+/**
+ * Replace a file through a temp file and a rename, so a crash mid-write cannot leave the
+ * target truncated. Used wherever pi-code rewrites a file the user owns and would have to
+ * repair by hand: settings and the memory index.
+ */
+
+import * as fs from 'node:fs'
+
+/** The tmp name carries the pid so concurrent processes do not collide. */
+export function atomicWriteFile(filePath: string, content: string): void {
+  const tmp = `${filePath}.${process.pid}.tmp`
+  fs.writeFileSync(tmp, content)
+  fs.renameSync(tmp, filePath)
+}

package/extensions/internal/bash-rules.ts

@@ -30,6 +30,50 @@ function matchesRule(segment: string, rule: string): boolean {
   return segment === normalized
 }
 
+/** Leading `VAR=value` assignments, which Claude strips before matching an `if` pattern. */
+const LEADING_ASSIGNMENTS = /^(?:[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S*)\s+)+/
+
+/** The bodies of `$(...)`, `` `...` ``, `<(...)` and `>(...)`, which run commands of their own. */
+function substitutionBodies(command: string): string[] {
+  const bodies: string[] = []
+  for (const match of command.matchAll(/\$\(([^()]*)\)|`([^`]*)`|[<>]\(([^()]*)\)/g)) {
+    const body = match[1] ?? match[2] ?? match[3]
+    if (body?.trim()) bodies.push(body.trim())
+  }
+  return bodies
+}
+
+/** Whether the first word of a segment is something only the shell can resolve. */
+const headUnresolvable = (segment: string): boolean => /[$`]/.test(segment.split(/\s+/, 1)[0] ?? '')
+
+/** Whether a pattern names more than the command itself, like `git push *` against `git *`. */
+const namesMoreThanCommand = (rule: string): boolean => rule.split('*', 1)[0].trim().includes(' ')
+
+/**
+ * Claude's `if` filter for a Bash call, which decides whether a hook gets to SEE the
+ * call. That makes it the mirror of a permission rule: a grant must hold for every
+ * segment and fails closed on anything it cannot read, while this runs the hook when any
+ * segment matches and when the input cannot be resolved at all. Claude: "When Claude Code
+ * can't determine which commands the Bash input runs, it runs your hook regardless of the
+ * pattern. Because the `if` filter is best-effort, use the permission system rather than
+ * a hook to enforce a hard allow or deny."
+ *
+ * Each top-level segment is checked with its leading assignments stripped, and so is the
+ * body of every substitution, since one can sit at any argument position. An unresolvable
+ * command name runs the hook whatever the pattern; a substitution anywhere runs it when
+ * the pattern names more than the command.
+ */
+export function matchesBashIfFilter(command: string, rule: string): boolean {
+  const trimmed = rule.trim()
+  const candidates = splitSegments(command).flatMap((segment) => {
+    const stripped = segment.replace(LEADING_ASSIGNMENTS, '')
+    return [stripped, ...substitutionBodies(stripped).flatMap((body) => splitSegments(body).map((inner) => inner.replace(LEADING_ASSIGNMENTS, '')))]
+  })
+  if (candidates.some((candidate) => matchesRule(candidate, trimmed))) return true
+  if (candidates.some(headUnresolvable)) return true
+  return namesMoreThanCommand(trimmed) && (hasSubstitution(command) || /\$[A-Za-z_{]/.test(command))
+}
+
 export function matchesBashRules(command: string, rules: string[]): boolean {
   if (hasSubstitution(command)) return false
   const segments = splitSegments(command)

package/extensions/internal/command-file.ts

@@ -377,7 +377,14 @@ export function substituteArgsDetailed(body: string, args: string, names: string
       return all || argsDefault
     }
     if (shorthandIdx !== undefined) return fill(parts[Number(shorthandIdx)], token)
-    if (name !== undefined) return fill(parts[names.indexOf(name)], '')
+    if (name !== undefined) {
+      // Claude: "A named placeholder counts even when its position has no argument,
+      // because it expands to an empty string", unlike an indexed one, which stays
+      // literal and does not count. Otherwise a skill using named arguments still got
+      // the ARGUMENTS: block appended.
+      consumed = true
+      return fill(parts[names.indexOf(name)], '')
+    }
     consumed = true
     return all // $ARGUMENTS or $@
   })

package/extensions/internal/effort.ts

@@ -0,0 +1,13 @@
+/**
+ * pi's thinking levels translated to Claude's effort vocabulary, which is
+ * `low | medium | high | xhigh | max`. pi adds two levels outside it: `minimal`, which
+ * reads as Claude's lowest, and `off`, which has no effort at all. Every surface that
+ * exposes the level to a script or a hook goes through here, so `off` and `minimal`
+ * never leak into a payload or an environment variable that promises Claude's set.
+ */
+
+/** The Claude effort level for a pi thinking level, or undefined when thinking is off. */
+export function claudeEffortLevel(thinkingLevel: string | undefined): string | undefined {
+  if (!thinkingLevel || thinkingLevel === 'off') return undefined
+  return thinkingLevel === 'minimal' ? 'low' : thinkingLevel
+}

package/extensions/internal/mcp-oauth.ts

@@ -121,8 +121,11 @@ export class FileOAuthProvider implements OAuthClientProvider {
     }
   }
 
+  /** The localhost spelling, which is what a server with a pre-registered redirect URI
+   * expects: Claude sent the 127.0.0.1 form for one version and "servers that exact-match
+   * the registered redirect URI rejected the sign-in with a redirect URI mismatch". */
   get redirectUrl(): string {
-    return `http://127.0.0.1:${this.port}/callback`
+    return `http://localhost:${this.port}/callback`
   }
 
   get clientMetadata(): OAuthClientMetadata {
@@ -193,13 +196,24 @@ export class FileOAuthProvider implements OAuthClientProvider {
  * taken, an ephemeral port is used. */
 export async function startCallbackServer(preferredPort?: number): Promise<{ server: http.Server; port: number }> {
   const server = http.createServer()
-  const listen = (port: number): Promise<void> => new Promise((resolve, reject) => server.listen(port, '127.0.0.1', resolve).once('error', reject))
+  const listen = (port: number, host: string): Promise<void> => new Promise((resolve, reject) => server.listen(port, host, resolve).once('error', reject))
   try {
-    await listen(preferredPort ?? 0)
+    await listen(preferredPort ?? 0, '127.0.0.1')
   } catch {
-    await listen(0)
+    await listen(0, '127.0.0.1')
   }
-  return { server, port: (server.address() as { port: number }).port }
+  const port = (server.address() as { port: number }).port
+  // The redirect names localhost, which resolves to ::1 first on a host with IPv6, so a
+  // second listener answers there too. Best effort: where it cannot bind, the IPv4
+  // listener above still answers every browser that resolves localhost to 127.0.0.1.
+  const ipv6 = http.createServer()
+  ipv6.on('error', () => {})
+  await new Promise<void>((resolve) => {
+    ipv6.listen(port, '::1', () => resolve()).once('error', () => resolve())
+  })
+  server.on('close', () => ipv6.close())
+  ipv6.on('request', (request, response) => server.emit('request', request, response))
+  return { server, port }
 }
 
 export function waitForAuthCode(server: http.Server, timeoutMs: number, expectedState?: string): Promise<string> {
@@ -244,7 +258,12 @@ export function openBrowser(url: string): void {
   else if (process.platform === 'win32') command = 'cmd'
   const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
   try {
-    spawn(command, args, { stdio: 'ignore', detached: true }).unref()
+    const child = spawn(command, args, { stdio: 'ignore', detached: true })
+    // A missing launcher (a container or an SSH session with no xdg-open) reports itself
+    // asynchronously through 'error'; with no listener node raises it as an
+    // uncaughtException and pi exits. The caller has already shown the URL to open by hand.
+    child.on('error', () => {})
+    child.unref()
   } catch {
     // the notified URL is the fallback
   }

package/extensions/internal/project-approval.ts

@@ -33,6 +33,8 @@ const CLAUDE_SHAPED = [
   path.join('.claude', 'rules'),
   path.join('.claude', 'skills'),
   path.join('.claude', 'commands'),
+  // Injected into the prompt verbatim, and context-imports treats it as approval-gated.
+  path.join('.claude', 'CLAUDE.md'),
   'CLAUDE.local.md',
   '.mcp.json',
   path.join('.pi', 'mcp.json'),

package/extensions/mcp/config.ts

@@ -21,6 +21,10 @@ export interface StdioServerConfig {
   timeout?: number
   /** Plugin servers alias their tools mcp__plugin_<plugin>_<server>__<tool>. */
   aliasPrefix?: string
+  /** The server name as its manifest declares it, without the plugin: scope the registry
+   * key carries. pi-side tool names derive from this, so a plugin server contributes
+   * <server>_<tool> the way a user server does. */
+  baseName?: string
   /** Root of the plugin that supplied this server; exported as CLAUDE_PLUGIN_ROOT. */
   pluginRoot?: string
   /** Loaded from the project scope, whose helpers run credential-stripped. */
@@ -42,6 +46,10 @@ export interface HttpServerConfig {
   timeout?: number
   /** Plugin servers alias their tools mcp__plugin_<plugin>_<server>__<tool>. */
   aliasPrefix?: string
+  /** The server name as its manifest declares it, without the plugin: scope the registry
+   * key carries. pi-side tool names derive from this, so a plugin server contributes
+   * <server>_<tool> the way a user server does. */
+  baseName?: string
   /** Root of the plugin that supplied this server; exported as CLAUDE_PLUGIN_ROOT. */
   pluginRoot?: string
   /** Loaded from the project scope, whose helpers run credential-stripped. */
@@ -213,7 +221,11 @@ export function loadPluginServers(plugins: InstalledPlugin[], projectDir?: strin
   for (const plugin of plugins) {
     for (const [name, config] of Object.entries(rawPluginServerEntries(plugin))) {
       const substituted = substitutedPluginServer(plugin, name, config, projectDir)
-      if (substituted) servers[name] = { ...substituted, aliasPrefix: `mcp__plugin_${fold(plugin.name)}_${fold(name)}__`, pluginRoot: plugin.root }
+      // Claude: "The server itself registers under the scoped name
+      // plugin:<plugin-name>:<server-name>", which is what an mcp_tool hook names and what
+      // keeps a same-named user server from replacing a plugin's. The tool alias keeps its
+      // own flat spelling, mcp__plugin_<plugin>_<server>__<tool>.
+      if (substituted) servers[`plugin:${plugin.name}:${name}`] = { ...substituted, aliasPrefix: `mcp__plugin_${fold(plugin.name)}_${fold(name)}__`, baseName: name, pluginRoot: plugin.root }
     }
   }
   return servers

package/extensions/mcp/index.ts

@@ -131,7 +131,9 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   function registerTools(name: string, config: ServerConfig, tools: McpToolInfo[]): number {
     let count = 0
     for (const tool of tools) {
-      const toolName = formatToolName(name, tool.name)
+      // A plugin server's registry key carries its plugin: scope; its tools keep the bare
+      // server name, as their Claude alias does.
+      const toolName = formatToolName(config.baseName ?? name, tool.name)
       const owner = registered.get(toolName)
       if (owner === name) continue // already registered for this server: a refresh re-listing it
       if (RESERVED_NAMES.has(toolName) || owner !== undefined) {
@@ -563,8 +565,12 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // is why serverToolCount reads from `registered` to recover the true count here.
     status.clear()
     // A same-process session switch (/new, /resume) shut the last session down;
-    // this one may reconnect again.
+    // 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
+    // set here left every project server disconnected for the rest of the process, since
+    // the shutdown had already dropped their clients.
     shuttingDown = false
+    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 }

package/extensions/mcp/transport.ts

@@ -284,12 +284,33 @@ export async function connect(name: string, config: ServerConfig, authUi?: AuthU
   }
 }
 
+/** Transport-level failure codes worth another attempt. */
+const TRANSIENT_CODES = new Set(['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET'])
+
+/** Every `code` reachable from an error: its own, those of its `cause` chain, and those
+ * of an AggregateError's members. fetch reports a refused connection as a bare
+ * `TypeError: fetch failed` whose cause carries ECONNREFUSED, so the text says nothing. */
+function errorCodes(error: unknown, seen = new Set<unknown>()): string[] {
+  if (error === null || typeof error !== 'object' || seen.has(error)) return []
+  seen.add(error)
+  const codes: string[] = []
+  const code = (error as { code?: unknown }).code
+  if (typeof code === 'string') codes.push(code)
+  const inner = (error as { errors?: unknown }).errors
+  if (Array.isArray(inner)) for (const one of inner) codes.push(...errorCodes(one, seen))
+  codes.push(...errorCodes((error as { cause?: unknown }).cause, seen))
+  return codes
+}
+
 /** Whether a connect failure is worth retrying: a 5xx response, a refused or reset
- * connection, or a timeout. Auth and not-found errors need a configuration change. */
-function isTransientConnectError(error: unknown): boolean {
+ * connection, or a timeout, per Claude's "a 5xx response, a connection refused, or a
+ * timeout ... retries up to three times". Auth and not-found errors need a configuration
+ * change instead. Exported for the test that pins the shape node actually throws. */
+export function isTransientConnectError(error: unknown): boolean {
   if (isUnauthorized(error)) return false
-  const code = typeof error === 'object' && error !== null ? (error as { code?: unknown }).code : undefined
-  if (typeof code === 'number') return code >= 500
+  const status = typeof error === 'object' && error !== null ? (error as { code?: unknown }).code : undefined
+  if (typeof status === 'number') return status >= 500
+  if (errorCodes(error).some((code) => TRANSIENT_CODES.has(code))) return true
   return /ECONNREFUSED|ECONNRESET|ETIMEDOUT|timed out after/.test(String(error))
 }
 

package/extensions/memory.ts

@@ -14,6 +14,7 @@ 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 } from 'typebox'
+import { atomicWriteFile } from './internal/atomic-write.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
@@ -79,6 +80,9 @@ export function resolveMemoryDir(cwd: string, override?: string): string {
 export function autoMemoryEnabled(setting: unknown, env: NodeJS.ProcessEnv): boolean {
   const disable = (env.CLAUDE_CODE_DISABLE_AUTO_MEMORY ?? '').trim().toLowerCase()
   if (disable === '1' || disable === 'true') return false
+  // Claude: "Set to 0 to force auto memory on even when --bare mode or
+  // autoMemoryEnabled: false would otherwise disable it."
+  if (disable === '0' || disable === 'false') return true
   return setting !== false
 }
 
@@ -322,14 +326,6 @@ function readIndexQuietly(dir: string): string {
   }
 }
 
-/** Write through a temp file and rename onto the target, so a crash mid-write cannot
- * truncate it. The tmp name carries the pid so concurrent processes do not collide. */
-function atomicWriteFile(filePath: string, content: string): void {
-  const tmp = `${filePath}.${process.pid}.tmp`
-  fs.writeFileSync(tmp, content)
-  fs.renameSync(tmp, filePath)
-}
-
 /** Replace the index through a rename so a crash mid-write cannot truncate it. */
 function writeIndex(indexPath: string, content: string): void {
   atomicWriteFile(indexPath, content)
@@ -543,7 +539,8 @@ export default function memoryExtension(pi: ExtensionAPI) {
         `  Auto memory: ${isEnabled ? 'on' : 'off'}`,
         `  Store:       ${store}`,
         `  Index:       ${path.join(store, INDEX_FILE)}`,
-        `  User memory (CLAUDE.md):    ${path.join(home, '.claude', 'CLAUDE.md')}`,
+        // The loader reads it from the configured directory, so CLAUDE_CONFIG_DIR moves it.
+        `  User memory (CLAUDE.md):    ${path.join(claudeConfigDir(home), 'CLAUDE.md')}`,
         `  Project memory (CLAUDE.md): ${path.join(ctx.cwd, 'CLAUDE.md')}`,
         // Claude's /memory lists every documented location, including files that
         // do not exist yet.

package/extensions/output-styles.ts

@@ -23,6 +23,7 @@ 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 { atomicWriteFile } from './internal/atomic-write.js'
 
 import { claudeConfigDir } from './internal/config-dir.js'
 import { readManagedSettings } from './internal/managed-settings.js'
@@ -101,10 +102,10 @@ function isDirectory(target: string): boolean {
  */
 export function styleDirs(cwd: string, home: string, trusted: boolean): string[] {
   const dirs = [path.join(claudeConfigDir(home), 'output-styles')]
-  // Claude loads every .claude/output-styles between cwd and the repository root,
-  // using the one closest to cwd for a name clash: styleForName is first-match,
-  // so the nearest directory goes first.
-  if (trusted) dirs.push(...ancestorDirs(cwd, path.join('.claude', 'output-styles')))
+  // Claude loads every .claude/output-styles between cwd and the repository root, using
+  // the one closest to cwd for a name clash. loadStyles keys by name and later dirs win,
+  // so the ancestors go farthest first and the nearest lands last.
+  if (trusted) dirs.push(...ancestorDirs(cwd, path.join('.claude', 'output-styles')).reverse())
   return dirs.filter((dir) => isDirectory(dir))
 }
 
@@ -173,16 +174,31 @@ export function styleForName(styles: OutputStyle[], name: string | undefined): O
   return name ? styles.find((style) => style.name === name) : undefined
 }
 
-function persistActiveStyle(file: string, name: string): void {
-  let config: Record<string, unknown> = {}
+/** Record the choice in the local settings file, returning a message to show when it
+ * cannot be recorded. The file also carries permissions, hooks and env, so a present but
+ * unparseable one is left alone rather than replaced by the style choice alone. */
+function persistActiveStyle(file: string, name: string): string | undefined {
+  const label = path.basename(file)
+  let raw: string | undefined
   try {
-    config = JSON.parse(fs.readFileSync(file, 'utf-8'))
-  } catch {
-    // start from an empty config when the file is missing or invalid
+    raw = fs.readFileSync(file, 'utf-8')
+  } catch (error) {
+    // Only a missing file means start fresh; anything else is the user's file to keep.
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return `${label} could not be read; the style applies to this session only`
+  }
+  let config: Record<string, unknown> = {}
+  if (raw !== undefined) {
+    try {
+      const parsed: unknown = JSON.parse(raw)
+      if (parsed !== null && typeof parsed === 'object') config = parsed as Record<string, unknown>
+    } catch {
+      return `${label} is not valid JSON; the style applies to this session only`
+    }
   }
   config.outputStyle = name
   fs.mkdirSync(path.dirname(file), { recursive: true })
-  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`)
+  atomicWriteFile(file, `${JSON.stringify(config, null, 2)}\n`)
+  return undefined
 }
 
 export default function outputStylesExtension(pi: ExtensionAPI) {
@@ -236,8 +252,8 @@ export default function outputStylesExtension(pi: ExtensionAPI) {
           return
         }
         activeName = picked.name
-        persistActiveStyle(localSettingsPath, picked.name)
-        ctx.ui.notify(`Output style set to ${picked.name} (applies next turn)`, 'info')
+        const failure = persistActiveStyle(localSettingsPath, picked.name)
+        ctx.ui.notify(failure ?? `Output style set to ${picked.name} (applies next turn)`, failure ? 'error' : 'info')
         return
       }
       if (!ctx.hasUI) {
@@ -253,8 +269,8 @@ export default function outputStylesExtension(pi: ExtensionAPI) {
       if (!choice) return
       const picked = styles[labels.indexOf(choice)]
       activeName = picked.name
-      persistActiveStyle(localSettingsPath, picked.name)
-      ctx.ui.notify(`Output style set to ${picked.name} (applies next turn)`, 'info')
+      const failure = persistActiveStyle(localSettingsPath, picked.name)
+      ctx.ui.notify(failure ?? `Output style set to ${picked.name} (applies next turn)`, failure ? 'error' : 'info')
     },
   })
 }

package/extensions/status-line.ts

@@ -31,8 +31,8 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-
 import { hookFiles, readDisableAllHooks, runHookCommand } from './hooks/index.js'
+import { claudeEffortLevel } from './internal/effort.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from './internal/plan-mode-state.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
@@ -296,10 +296,10 @@ export default function statusLine(pi: ExtensionAPI) {
     const sessionName = ctx.sessionManager.getSessionName?.()
     if (sessionName) payload.session_name = sessionName
     if (ctx.thinkingLevel) {
-      // pi's off/minimal are outside Claude's effort vocabulary: minimal maps to
-      // low, and off omits effort entirely (thinking disabled says the rest).
+      // Thinking disabled says the rest, so off carries no effort field of its own.
       payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
-      if (ctx.thinkingLevel !== 'off') payload.effort = { level: ctx.thinkingLevel === 'minimal' ? 'low' : ctx.thinkingLevel }
+      const effort = claudeEffortLevel(ctx.thinkingLevel)
+      if (effort) payload.effort = { level: effort }
     }
     if (styleName) payload.output_style = { name: styleName }
     // The current utilization of the account's rate-limit windows, when the
@@ -457,14 +457,20 @@ export default function statusLine(pi: ExtensionAPI) {
     // Claude's disableAllHooks also turns off the custom statusLine command; the
     // built-in segment still renders as the fallback.
     config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
-    if (config?.refreshInterval) {
-      refreshTimer = setInterval(() => scheduleRefresh(), config.refreshInterval * 1000)
+    // Re-armed rather than armed once: a refreshInterval added or changed mid-session
+    // had no effect until the next session, though Claude applies a settings change as
+    // soon as the file is saved.
+    const armRefresh = (): void => {
+      clearInterval(refreshTimer)
+      refreshTimer = config?.refreshInterval ? setInterval(() => scheduleRefresh(), config.refreshInterval * 1000) : undefined
     }
+    armRefresh()
     // Claude re-runs the script when the statusLine settings change mid-session; a
     // command change re-resolves and re-runs.
     disposeSettingsWatch()
     disposeSettingsWatch = watchSettingsFiles(files, () => {
       config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
+      armRefresh()
       scheduleRefresh()
     })
     show(ctx, segmentText(ctx, ctx.ui.theme.fg('dim', '○')))

package/extensions/subagent/background.ts

@@ -177,6 +177,13 @@ export function backgroundStatusText(): string {
   return formatStatus(runs.values())
 }
 
+/** Every run this process knows about, live and finished. The registry is module state
+ * that outlives a session switch; a per-session list is not, because pi re-invokes each
+ * extension factory per session. */
+export function allBackgroundRuns(): BackgroundRun[] {
+  return [...runs.values()]
+}
+
 /** A finished run, so a caller can continue its session with a follow-up task. */
 export function backgroundRun(id: string): BackgroundRun | undefined {
   return runs.get(id)
@@ -200,7 +207,10 @@ export function resumeBackgroundRun(id: string, task: string, onComplete: (run:
   const rebuilt = withRebuiltPrompt(run.spawn)
   run.spawn = { ...run.spawn, args: rebuilt.args }
   if (rebuilt.dir) run.rebuiltPromptDir = rebuilt.dir
-  const args = rebuilt.args.map((arg) => (arg.startsWith('Task: ') ? `Task: ${task}` : arg))
+  // The task prompt is always the final argument: both spawn paths push it last and the
+  // invocation helper only prepends. Matching a 'Task: ' prefix missed it whenever
+  // SubagentStart hooks placed their context ahead of it, so the resume re-ran the old task.
+  const args = rebuilt.args.map((arg, index) => (index === rebuilt.args.length - 1 ? `Task: ${task}` : arg))
   run.state = 'running'
   run.task = task
   run.output = undefined

package/extensions/subagent/index.ts

@@ -34,7 +34,7 @@ import { runSubagentStartHooks } from '../internal/subagent-hooks.js'
 import { autoMemoryEnabled, capIndexForPrompt, INDEX_MAX_BYTES, INDEX_MAX_LINES, memorySettingsFiles, readMemorySettings } from '../memory.js'
 import { skillDirs } from '../skills.js'
 import { type AgentConfig, type AgentMemoryScope, type AgentScope, type AgentSource, discoverAgents, expandMcpToolPatterns, resolveModelAlias, withPreloadedSkills } from './agents.js'
-import { activeBackgroundRuns, type BackgroundRun, backgroundRun, backgroundStatusText, cancelAllBackgroundRuns, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
+import { activeBackgroundRuns, allBackgroundRuns, type BackgroundRun, backgroundRun, backgroundStatusText, cancelAllBackgroundRuns, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
 import { type DisplayItem, formatToolCall, formatUsageStats, getDisplayItems, getFinalOutput } from './render.js'
 import { type AgentWorktree, cleanupAgentWorktree, createAgentWorktree } from './worktree.js'
 
@@ -388,8 +388,11 @@ async function runSingleAgentInner(options: RunAgentOptions): Promise<SingleResu
         resolve(code ?? 0)
       })
 
-      proc.on('error', () => {
+      proc.on('error', (error: Error) => {
         cleanup()
+        // A child that never started leaves no stdout and no stderr, so this message is the
+        // only diagnostic; without it the failure reads as "(no output)".
+        if (!currentResult.stderr) currentResult.stderr = error.message
         resolve(1)
       })
 
@@ -566,7 +569,7 @@ function runOutputTail(run: BackgroundRunView): string | undefined {
 /** The /tasks listing: one line per background run, plus the short output tail the
  * registry's own status lines omit. A pure formatter so it tests against a plain list. */
 export function tasksStatusText(runs: ReadonlyArray<BackgroundRunView>): string {
-  if (runs.length === 0) return 'No background subagent runs in this session.'
+  if (runs.length === 0) return 'No background subagent runs.'
   return runs
     .map((run) => {
       const plural = run.turns === 1 ? '' : 's'
@@ -761,7 +764,7 @@ export function setKnownMcpAliases(aliases: ReadonlyArray<{ pi: string; claude:
 /** pi's built-in ToolName union (core/tools/index.d.ts; the package's export map
  * does not expose allToolNames, so this mirrors it) plus the tools pi-code's own
  * extensions register in a child. Claude's capitalized spellings fold onto these. */
-const CHILD_TOOL_NAMES = new Set(['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls', 'web_fetch', 'web_search', 'list_mcp_resources', 'read_mcp_resource'])
+const CHILD_TOOL_NAMES = new Set(['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls', 'web_fetch', 'web_search', 'list_mcp_resources', 'read_mcp_resource', 'todo', 'question', 'memory', 'slash_command', 'plan_mode_complete'])
 
 /** Claude: when no entry in a `tools` list resolves to a tool, the subagent fails
  * to launch with an error naming the entries, instead of running tool-less. */
@@ -782,7 +785,12 @@ function agentInvocationArgs(agent: AgentConfig, aliasModel?: string): string[]
   // order (invocation model, frontmatter model, this variable, the session model).
   // pi reads a thinking level from the model pattern's :suffix when a model is
   // pinned, and from --thinking otherwise.
-  const model = agent.model ?? aliasModel ?? process.env.CLAUDE_CODE_SUBAGENT_MODEL
+  // Claude exempts the two built-ins from the environment variable: "Setting
+  // CLAUDE_CODE_SUBAGENT_MODEL by itself doesn't change the model the built-in Explore and
+  // Plan subagents run on." A model they name themselves, or one the invocation names,
+  // still applies.
+  const exemptFromEnvModel = agent.source === 'builtin' && (agent.name === 'Explore' || agent.name === 'Plan')
+  const model = agent.model ?? aliasModel ?? (exemptFromEnvModel ? undefined : process.env.CLAUDE_CODE_SUBAGENT_MODEL)
   if (model) args.push('--model', agent.effort ? `${model}:${agent.effort}` : model)
   else if (agent.effort) args.push('--thinking', agent.effort)
   // Claude's mcp__<server> / mcp__* patterns expand against the parent's MCP roster;
@@ -858,7 +866,7 @@ interface BackgroundContext {
   projectApproved: boolean
 }
 
-async function runBackgroundMode(params: SubagentParamsStatic, context: BackgroundContext, onStarted?: (id: string) => void): Promise<ToolResult> {
+async function runBackgroundMode(params: SubagentParamsStatic, context: BackgroundContext): Promise<ToolResult> {
   const { agents, defaultCwd, pi, makeDetails, skillRoots, availableModels, projectApproved } = context
   const task = params.task
   const agentName = params.agent
@@ -955,7 +963,6 @@ async function runBackgroundMode(params: SubagentParamsStatic, context: Backgrou
     removeTmpPrompt(tmpPrompt)
     return backgroundCapResult(makeDetails)
   }
-  onStarted?.(id)
   pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: agent.name, agentId: id })
   return {
     content: [{ type: 'text', text: `Started background run ${id} (${agent.name}). A notification will arrive on completion; check progress with {status: true}.` }],
@@ -1437,21 +1444,6 @@ export default function subagentExtension(pi: ExtensionAPI) {
     if (isMcpToolAliases(data)) setKnownMcpAliases(data)
   })
 
-  // /tasks resolves these against the registry at print time. background.ts owns the
-  // run records but does not enumerate them, so the ids started here are remembered;
-  // a run the registry has since evicted simply drops out of the listing.
-  const startedBackgroundRuns = new Set<string>()
-
-  // The registry self-caps and evicts old runs, so an id kept here after its record is
-  // gone is dead weight. Drop those on every add, bounding the set to the registry's
-  // live capacity rather than letting it grow for the whole session.
-  const rememberBackgroundRun = (id: string): void => {
-    for (const known of startedBackgroundRuns) {
-      if (!backgroundRun(known)) startedBackgroundRuns.delete(known)
-    }
-    startedBackgroundRuns.add(id)
-  }
-
   const notifyBackgroundCompletion = (run: { id: string; agent: string; state: string; turns: number; output?: string; stderr?: string }): void => {
     // Runs through driveRun's guard, same as the background-mode callback above.
     // The stop event fires here too, so SubagentStop hooks see resumed runs end.
@@ -1585,7 +1577,6 @@ export default function subagentExtension(pi: ExtensionAPI) {
 
       if (params.resume) {
         const onResumed = (run: { id: string; agent: string }): void => {
-          rememberBackgroundRun(run.id)
           pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: run.agent, agentId: run.id })
         }
         return { content: [{ type: 'text', text: resumeResultText(params.resume, params.task, notifyBackgroundCompletion, onResumed) }], details: makeDetails('single')([]) }
@@ -1629,7 +1620,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
       // unavailable tier still falls back to the session model.
       const availableModels = ctx.modelRegistry?.getAvailable?.() ?? []
 
-      if (wantsBackground(params, agents)) return runBackgroundMode(params, { agents, defaultCwd: ctx.cwd, pi, makeDetails, skillRoots, availableModels, projectApproved }, (id) => rememberBackgroundRun(id))
+      if (wantsBackground(params, agents)) return runBackgroundMode(params, { agents, defaultCwd: ctx.cwd, pi, makeDetails, skillRoots, availableModels, projectApproved })
 
       const mode: ModeContext = {
         agents,
@@ -1686,8 +1677,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
   pi.registerCommand('tasks', {
     description: 'Show background subagent runs',
     handler: async (_args, ctx) => {
-      const runs = [...startedBackgroundRuns].map((id) => backgroundRun(id)).filter((run): run is BackgroundRun => run !== undefined)
-      ctx.ui.notify(tasksStatusText(runs), 'info')
+      ctx.ui.notify(tasksStatusText(allBackgroundRuns()), 'info')
     },
   })
 

package/package.json

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