pi-code 1.0.64 → 1.0.66

package/extensions/env-settings.ts

@@ -38,7 +38,7 @@ import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { readManagedSettings } from './internal/managed-settings.js'
-import { isProjectApprovedSilently } from './internal/project-approval.js'
+import { approvalRecheck, isProjectApprovedSilently } from './internal/project-approval.js'
 import { claudeSettingsChain } from './internal/settings-chain.js'
 import { watchSettingsFiles } from './internal/settings-watch.js'
 import { isRecord } from './internal/values.js'
@@ -160,7 +160,12 @@ export default function envSettingsExtension(pi: ExtensionAPI) {
   pi.on('session_start', async (_event, ctx: ExtensionContext) => {
     const home = os.homedir()
     const approved = isProjectApprovedSilently(ctx)
-    const reapply = (): void => apply(home, approved ? projectEnv(ctx.cwd, home) : {})
+    // The watcher's reapply closes over the cwd value, never ctx: the poll has no awaiter,
+    // and every getter of a replaced session's ctx throws, which would exit pi.
+    const cwd = ctx.cwd
+    // A reload asks again rather than reusing `approved`: see approvalRecheck.
+    const stillApproved = approvalRecheck(ctx)
+    const reapply = (): void => apply(home, approved && stillApproved() ? projectEnv(cwd, home) : {})
     reapply()
     // Claude: "Claude Code watches your settings files and reloads them when they change,
     // so it applies most edits to the running session without a restart." `env` is not
@@ -168,11 +173,15 @@ export default function envSettingsExtension(pi: ExtensionAPI) {
     // edit has to reach process.env now rather than at the next session. applyEnvSettings
     // tracks what it owns, so a key removed from the file is restored, not left behind.
     disposeWatch()
-    disposeWatch = watchSettingsFiles(claudeSettingsChain(ctx.cwd, home, approved), reapply)
+    disposeWatch = watchSettingsFiles(claudeSettingsChain(cwd, home, approved), reapply)
   })
 
   pi.on('session_shutdown', async () => {
     disposeWatch()
     disposeWatch = () => {}
+    // pi's CLI loads a fresh extension instance for every session replacement, and its
+    // empty `owned` cannot restore what this one set: everything is handed back here, and
+    // the next instance re-applies managed and user env at factory time, as at startup.
+    applyEnvSettings({}, process.env, owned)
   })
 }

package/extensions/hooks/config.ts

@@ -251,9 +251,12 @@ function withoutUserConfigShellCommands(raw: string, source: string): string {
   for (const matchers of Object.values(parsed?.hooks ?? {})) {
     if (!Array.isArray(matchers)) continue
     for (const entry of matchers) {
-      const record = entry as { hooks?: unknown }
-      if (!Array.isArray(record.hooks)) continue
-      const kept = record.hooks.filter((hook) => {
+      // A malformed entry is left for mergeHooksJson to report by name; this pass must
+      // not throw on it, because the inline-manifest caller has no catch.
+      if (!isRecord(entry) || !Array.isArray(entry.hooks)) continue
+      const record = entry
+      const kept = (record.hooks as unknown[]).filter((hook) => {
+        if (!isRecord(hook)) return true
         const candidate = hook as { command?: unknown; args?: unknown }
         if (Array.isArray(candidate.args) || typeof candidate.command !== 'string' || !USER_CONFIG_REF.test(candidate.command)) return true
         console.warn(`pi-code-hooks: ignoring a hook in ${source}: a shell-form command cannot reference \${user_config.*}; use exec form with "args", or read CLAUDE_PLUGIN_OPTION_<KEY> from the environment`)

package/extensions/hooks/index.ts

@@ -103,7 +103,7 @@ import { isMcpToolAliases, MCP_TOOLS_CHANNEL } from '../internal/mcp-alias.js'
 import { resolveModelOverride } from '../internal/model-lookup.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from '../internal/plan-mode-state.js'
 import { installedPlugins, managedForceEnabled } from '../internal/plugins.js'
-import { isProjectApproved } from '../internal/project-approval.js'
+import { approvalRecheck, isProjectApproved } from '../internal/project-approval.js'
 import { repoRoot } from '../internal/project-root.js'
 import { watchSettingsFiles } from '../internal/settings-watch.js'
 import { isSkillHooksEvent, SKILL_HOOKS_CHANNEL } from '../internal/skill-hooks.js'
@@ -453,9 +453,14 @@ export default function hooksExtension(pi: ExtensionAPI) {
     // subdirectory session too.
     projectDir = repoRoot(ctx.cwd) ?? ctx.cwd
     resolveConfig(ctx.cwd, trusted)
-    // Claude picks up direct settings edits mid-session via a file watcher.
+    // Claude picks up direct settings edits mid-session via a file watcher. The reload
+    // closes over the cwd value, never ctx: the poll has no awaiter, and every getter of
+    // a replaced session's ctx throws, which would exit pi as an uncaughtException.
+    const watchCwd = ctx.cwd
+    // The reload asks again rather than reusing `trusted`: see approvalRecheck.
+    const stillApproved = approvalRecheck(ctx)
     disposeSettingsWatch()
-    disposeSettingsWatch = watchSettingsFiles(hookFiles(ctx.cwd, os.homedir(), trusted), () => resolveConfig(ctx.cwd, trusted))
+    disposeSettingsWatch = watchSettingsFiles(hookFiles(watchCwd, os.homedir(), trusted), () => resolveConfig(watchCwd, trusted && stillApproved()))
     // A disabled or managed-only resolution leaves config empty (or managed-only),
     // so the SessionStart run below fires exactly what remains active.
     pendingSessionContext = []
@@ -759,6 +764,10 @@ export default function hooksExtension(pi: ExtensionAPI) {
   })
 
   pi.on('session_shutdown', async (event, ctx) => {
+    // pi's CLI loads a fresh extension instance for every session replacement, so no later
+    // session_start reaches this watcher: left armed, it polls for the life of the process.
+    disposeSettingsWatch()
+    disposeSettingsWatch = () => {}
     const reason = claudeSpelling(SESSION_END_REASON, event.reason)
     // SessionEnd rides Claude's short shared budget (see sessionEndTimeoutMs) so a
     // slow hook cannot stall session exit, /new or /resume.

package/extensions/hooks/matcher.ts

@@ -135,9 +135,11 @@ function collectCommands(matchers: HookMatcher[] | undefined, applies: (entry: H
       if (raw.spent === true) continue
       const hook = withCommand(raw)
       // Claude runs a handler defined in more than one settings file once; a
-      // plugin's or skill's copy of the same handler stays separate, and http
-      // handlers with the same URL but different headers are distinct.
-      const key = `${hook.origin ?? 'settings'}\n${hook.command}\n${hook.headers ? JSON.stringify(hook.headers) : ''}`
+      // plugin's or skill's copy of the same handler stays separate. Handlers that
+      // share a command but differ in what they run or when (http headers, exec-form
+      // args, an `if` filter, an mcp_tool input) are different handlers: `if` is applied
+      // after this, so collapsing two filters left the other tool call with no guard.
+      const key = `${hook.origin ?? 'settings'}\n${hook.command}\n${JSON.stringify([hook.headers, hook.args, hook.if, hook.input])}`
       if (seen.has(key)) continue
       seen.add(key)
       result.push(hook)

package/extensions/internal/agent-run.ts

@@ -9,6 +9,8 @@
  * are skipped rather than failing the event.
  */
 
+import { sharedSlot } from './shared-slot.js'
+
 export interface AgentRunRequest {
   /** The agent's task prompt, with `$ARGUMENTS` already substituted. */
   prompt: string
@@ -29,20 +31,21 @@ export interface AgentRunRequest {
 /** Run a subagent to completion and return its final assistant text. */
 export type AgentRunner = (request: AgentRunRequest) => Promise<string>
 
-let runner: AgentRunner | undefined
+const slot = sharedSlot<AgentRunner>('agent-runner')
 
 /** The subagent extension registers its runner here; pass undefined to clear it. */
 export function setAgentRunner(fn: AgentRunner | undefined): void {
-  runner = fn
+  slot.set(fn)
 }
 
 /** Test seam: whether a runner is registered. */
 export function hasAgentRunner(): boolean {
-  return runner !== undefined
+  return slot.get() !== undefined
 }
 
 /** Run a subagent for an agent hook. Rejects when no runner is registered. */
 export function runAgent(request: AgentRunRequest): Promise<string> {
+  const runner = slot.get()
   if (!runner) return Promise.reject(new Error('no subagent runner registered for agent hooks'))
   return runner(request)
 }

package/extensions/internal/mcp-call.ts

@@ -7,6 +7,8 @@
  * callMcpTool. It is the direct-call analogue of the MCP_TOOLS_CHANNEL alias bus.
  */
 
+import { sharedSlot } from './shared-slot.js'
+
 export interface McpToolResult {
   text: string
   isError: boolean
@@ -14,15 +16,16 @@ export interface McpToolResult {
 
 export type McpToolCaller = (server: string, tool: string, input: Record<string, unknown>) => Promise<McpToolResult>
 
-let caller: McpToolCaller | undefined
+const slot = sharedSlot<McpToolCaller>('mcp-tool-caller')
 
 /** The mcp extension registers its caller here; pass undefined to clear it. */
 export function setMcpToolCaller(fn: McpToolCaller | undefined): void {
-  caller = fn
+  slot.set(fn)
 }
 
 /** Invoke a tool on a connected MCP server. Throws when no server is connected. */
 export function callMcpTool(server: string, tool: string, input: Record<string, unknown>): Promise<McpToolResult> {
+  const caller = slot.get()
   if (!caller) return Promise.reject(new Error(`no MCP server connected to serve ${server}/${tool}`))
   return caller(server, tool, input)
 }

package/extensions/internal/model-complete.ts

@@ -72,5 +72,8 @@ export async function completeText(model: Model<Api>, prompt: string, options: C
     messages: [{ role: 'user', content: prompt, timestamp: Date.now() }],
   }
   const message = await complete(model, context, { maxTokens: options.maxTokens ?? 1024, signal: options.signal })
+  // pi-ai reports a provider failure or a fired signal by resolving, never rejecting: the
+  // message then has no text, and returned as an answer it is indistinguishable from one.
+  if (message.stopReason === 'error' || message.stopReason === 'aborted') throw new Error(message.errorMessage ?? `completion ${message.stopReason}`)
   return { text: assistantText(message), usage: message.usage }
 }

package/extensions/internal/project-approval.ts

@@ -129,6 +129,22 @@ export function isProjectApprovedSilently(ctx: Pick<ApprovalContext, 'cwd' | 'is
   return deps.savedDecision(ctx.cwd) === true
 }
 
+/**
+ * A re-check of the approval decision for code that outlives session_start, such as a
+ * settings watcher's reload. The answer given at session_start cannot be reused: a
+ * repository with nothing Claude-shaped reads as approved without a question, so config
+ * that appears later (a branch checkout, an unpacked archive) would inherit an answer
+ * nobody gave. ctx is read once, here: the returned function holds values only, because
+ * a poll outlives the session and every getter of a replaced session's ctx throws. It
+ * never prompts, so a project that turned Claude-shaped mid-session stays out until the
+ * next session asks.
+ */
+export function approvalRecheck(ctx: Pick<ApprovalContext, 'cwd' | 'isProjectTrusted'>, deps: ApprovalDeps = defaultDeps): () => boolean {
+  const cwd = ctx.cwd
+  const piTrusted = ctx.isProjectTrusted?.() === true
+  return () => isProjectApprovedSilently({ cwd, isProjectTrusted: () => piTrusted }, deps)
+}
+
 /**
  * The approval decision for a file that is itself the thing to gate.
  *

package/extensions/internal/settings-watch.ts

@@ -6,7 +6,7 @@
  */
 
 import * as fs from 'node:fs'
-import { parseNumericEnv } from './values.js'
+import { errorMessage, parseNumericEnv } from './values.js'
 
 // Captured at module load: the poll must run on real time even under a test's
 // fake timers (the stat watcher it replaced lived in libuv and was immune too);
@@ -37,7 +37,13 @@ export function watchSettingsFiles(files: string[], reload: () => void): () => v
     const next = files.map(snapshot)
     if (next.some((content, index) => content !== last[index])) {
       last = next
-      reload()
+      // The poll has no awaiter: a throw here is an uncaughtException, and pi exits on
+      // one. A reload that cannot cope with what it read costs that reload, not the session.
+      try {
+        reload()
+      } catch (error) {
+        console.warn(`pi-code: settings reload failed: ${errorMessage(error)}`)
+      }
     }
   }, interval)
   // A watcher alone must never keep a one-shot run alive.

package/extensions/internal/shared-slot.ts

@@ -0,0 +1,23 @@
+/**
+ * A process-wide slot for a function one extension registers and another calls.
+ *
+ * pi loads every extension entry through its own module graph, so a module-level `let`
+ * in a file two extensions import is a separate variable in each: the setter and the
+ * caller never meet, and the seam reads as "nothing registered" for the life of the
+ * process. `globalThis` is the one object the graphs share, and a registered symbol
+ * resolves to the same key from every copy of this module. pi's event bus carries the
+ * cross-extension data (see mcp-alias); a slot is for a call that returns a result.
+ *
+ * Each session replacement loads fresh extension instances, which register again and
+ * replace the previous instance's function.
+ */
+export function sharedSlot<T>(name: string): { get: () => T | undefined; set: (value: T | undefined) => void } {
+  const key = Symbol.for(`pi-code.${name}`)
+  const holder = globalThis as Record<symbol, unknown>
+  return {
+    get: () => holder[key] as T | undefined,
+    set: (value) => {
+      holder[key] = value
+    },
+  }
+}

package/extensions/internal/subagent-hooks.ts

@@ -6,17 +6,20 @@
  * pattern as mcp-call.
  */
 
+import { sharedSlot } from './shared-slot.js'
+
 export type SubagentStartHookRunner = (agentType: string, agentId: string) => Promise<string[]>
 
-let runner: SubagentStartHookRunner | undefined
+const slot = sharedSlot<SubagentStartHookRunner>('subagent-start-hook-runner')
 
 export function setSubagentStartHookRunner(fn: SubagentStartHookRunner | undefined): void {
-  runner = fn
+  slot.set(fn)
 }
 
 /** Context strings SubagentStart hooks contribute; empty when no runner is
  * registered or the runner fails (hooks must never block a spawn). */
 export async function runSubagentStartHooks(agentType: string, agentId: string): Promise<string[]> {
+  const runner = slot.get()
   if (!runner) return []
   try {
     return await runner(agentType, agentId)

package/extensions/mcp/config.ts

@@ -11,7 +11,7 @@ import { claudeConfigDir } from '../internal/config-dir.js'
 import type { OAuthServerConfig } from '../internal/mcp-oauth.js'
 import { type InstalledPlugin, pluginComponentPath } from '../internal/plugins.js'
 import { findNearestFile } from '../internal/project-root.js'
-import { errorMessage } from '../internal/values.js'
+import { errorMessage, isRecord } from '../internal/values.js'
 
 export interface StdioServerConfig {
   type?: 'stdio'
@@ -105,12 +105,26 @@ export function projectConfigPaths(cwd: string): string[] {
   return ['.mcp.json', path.join('.pi', 'mcp.json')].map((rel) => findNearestFile(cwd, rel) ?? path.join(cwd, rel))
 }
 
+/** The object entries of a raw `mcpServers` map. A string or null entry (a JSON "comment"
+ * key, a nulled-out server) would throw in the connect batch outside its per-server catch
+ * and sink every server with it, the project trust prompt included, so it is dropped here
+ * by name. */
+function serverEntries(raw: unknown, source: string): Record<string, ServerConfig> {
+  const servers: Record<string, ServerConfig> = {}
+  for (const [name, entry] of Object.entries(isRecord(raw) ? raw : {})) {
+    // Shape only: the fields are validated where a transport is chosen.
+    if (isRecord(entry)) servers[name] = entry as unknown as ServerConfig
+    else console.warn(`pi-code-mcp: ignoring mcpServers entry "${name}" in ${source}: not an object`)
+  }
+  return servers
+}
+
 export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
   const servers: Record<string, ServerConfig> = {}
   for (const file of files) {
     try {
       const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'))
-      Object.assign(servers, parsed.mcpServers ?? {})
+      Object.assign(servers, serverEntries(parsed?.mcpServers, file))
     } catch (error) {
       // A missing file is the normal case. A present file that does not parse is
       // not: one trailing comma silently disabled every server in it.
@@ -128,7 +142,7 @@ export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
  */
 export function loadUserScope(home: string, cwd: string): Record<string, ServerConfig> {
   const servers = loadConfigFrom(userConfigPaths(home))
-  Object.assign(servers, projectRecord(home, cwd).mcpServers ?? {})
+  Object.assign(servers, serverEntries(projectRecord(home, cwd).mcpServers, claudeJsonPath(home)))
   return servers
 }
 

package/extensions/output-styles.ts

@@ -31,7 +31,7 @@ import { installedPlugins, pluginComponentPath } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { ancestorDirs } from './internal/project-root.js'
 import { claudeSettingsChain, localSettingsFile, readSettingsChain } from './internal/settings-chain.js'
-import { isDirectory } from './internal/values.js'
+import { errorMessage, isDirectory } from './internal/values.js'
 
 export interface OutputStyle {
   name: string
@@ -121,6 +121,25 @@ export function pluginStyleDirs(home: string): string[] {
   })
 }
 
+/** One style file, or undefined when it cannot be used. A directory named *.md or an
+ * unreadable file is skipped silently. pi's frontmatter parser is strict YAML and throws:
+ * one unparseable file must cost that style, not every style of the session. */
+function readStyleFile(dir: string, entry: string): OutputStyle | undefined {
+  const file = path.join(dir, entry)
+  let content: string
+  try {
+    content = fs.readFileSync(file, 'utf-8')
+  } catch {
+    return undefined
+  }
+  try {
+    return parseStyle(content, entry.replace(/\.md$/, ''))
+  } catch (error) {
+    console.warn(`pi-code-output-styles: skipping ${file}: ${errorMessage(error).split('\n')[0]}`)
+    return undefined
+  }
+}
+
 /** All output styles, project entries overriding user entries of the same name. */
 export function loadStyles(dirs: string[]): OutputStyle[] {
   const byName = new Map<string, OutputStyle>()
@@ -131,16 +150,9 @@ export function loadStyles(dirs: string[]): OutputStyle[] {
     } catch {
       continue
     }
-    for (const entry of entries) {
-      if (!entry.endsWith('.md')) continue
-      let content: string
-      try {
-        content = fs.readFileSync(path.join(dir, entry), 'utf-8')
-      } catch {
-        continue // a directory named *.md or an unreadable file must not take down session start
-      }
-      const style = parseStyle(content, entry.replace(/\.md$/, ''))
-      byName.set(style.name, style)
+    for (const entry of entries.filter((name) => name.endsWith('.md'))) {
+      const style = readStyleFile(dir, entry)
+      if (style) byName.set(style.name, style)
     }
   }
   return [...byName.values()]

package/extensions/question.ts

@@ -190,6 +190,9 @@ export default function question(pi: ExtensionAPI) {
     description:
       'Ask the user a question and let them pick from options. Use when you need user input to proceed. Pass question and options, for example {"question": "Which one?", "options": [{"label": "alpha"}, {"label": "beta"}]}. To ask 2-4 questions at once, pass questions instead, with the same fields per entry.',
     parameters: QuestionParams,
+    // The host shows a custom dialog in one editor slot, so two questions running in
+    // parallel leave the first unanswerable and the run unable to finish.
+    executionMode: 'sequential',
 
     async execute(_toolCallId, rawParams, _signal, _onUpdate, ctx) {
       const specs = questionList(rawParams as Partial<QuestionSpec> & { questions?: QuestionSpec[] })

package/extensions/status-line.ts

@@ -35,7 +35,7 @@ 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'
+import { approvalRecheck, isProjectApprovedSilently } from './internal/project-approval.js'
 import { gitRoot, repoRoot } from './internal/project-root.js'
 import { readSettingsChain } from './internal/settings-chain.js'
 import { watchSettingsFiles } from './internal/settings-watch.js'
@@ -503,10 +503,15 @@ export default function statusLine(pi: ExtensionAPI) {
     armRefresh()
     // Claude re-runs the script when the statusLine settings change mid-session; a
     // command change re-resolves and re-runs.
+    // The reload asks again rather than reusing `trusted` (see approvalRecheck), and reads
+    // the chain that answer allows: a statusLine command is executed, not just displayed.
+    const watchCwd = ctx.cwd
+    const stillApproved = approvalRecheck(ctx)
     disposeSettingsWatch()
     disposeSettingsWatch = watchSettingsFiles(files, () => {
       const previousCommand = config?.command
-      config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
+      const liveFiles = hookFiles(watchCwd, os.homedir(), trusted && stillApproved())
+      config = readDisableAllHooks(liveFiles) ? undefined : readStatusLineConfig(liveFiles)
       armRefresh()
       // The debounce batches rapid triggers, but a command the user just edited has
       // nothing to batch with: run it now so the result of the edit is immediate.
@@ -559,5 +564,9 @@ export default function statusLine(pi: ExtensionAPI) {
   pi.on('session_shutdown', async () => {
     clearInterval(refreshTimer)
     clearTimeout(debounceTimer)
+    // pi's CLI loads a fresh extension instance for every session replacement, so no later
+    // session_start reaches this watcher: left armed, it polls for the life of the process.
+    disposeSettingsWatch()
+    disposeSettingsWatch = () => {}
   })
 }

package/extensions/subagent/run.ts

@@ -133,16 +133,22 @@ function appendPartialNote(result: SingleResult): void {
  * 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,
-      }),
+    const 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,
+    })
+    // A third failure shape: at the descriptor limit (EMFILE, ENFILE) node returns a child
+    // with no stdio and emits 'error' on the next tick. The callers wire stdout first, so
+    // the deferred event would find no listener, and an unhandled 'error' exits pi.
+    if (!proc.stdout) {
+      proc.on('error', () => {})
+      return { error: new Error('spawn returned no stdio: the file descriptor limit is likely exhausted (EMFILE)') }
     }
+    return { proc }
   } catch (error) {
     return { error: error as Error }
   }
@@ -338,7 +344,9 @@ async function runSingleAgentInner(options: RunAgentOptions): Promise<SingleResu
       proc.on('close', (code) => {
         cleanup()
         if (buffer.trim()) processLine(buffer)
-        resolve(code ?? 0)
+        // A capped run was stopped by this module's own SIGTERM, which pi's print mode
+        // answers with exit 143: that is not the agent failing, as background.ts also holds.
+        resolve(currentResult.partial ? 0 : (code ?? 0))
       })
 
       proc.on('error', (error: Error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "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",
@@ -63,15 +63,15 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.4",
-    "@earendil-works/pi-agent-core": "^0.84.2",
-    "@earendil-works/pi-ai": "^0.84.2",
-    "@earendil-works/pi-coding-agent": "^0.84.2",
-    "@earendil-works/pi-tui": "^0.84.2",
+    "@earendil-works/pi-agent-core": "^0.85.1",
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
     "@types/node": "^26.1.1",
-    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/coverage-v8": "^5.0.0",
     "fast-check": "^4.9.0",
     "knip": "^6.34.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   }
 }