pi-code 1.0.51 → 1.0.52

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/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/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}`)
+    }
   }
 }
 

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/mcp-oauth.ts

@@ -244,7 +244,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/mcp/index.ts

@@ -563,8 +563,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/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'
@@ -322,14 +323,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)

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

@@ -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'
@@ -858,7 +861,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 +958,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 +1439,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 +1572,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 +1615,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 +1672,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.52",
   "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",