pi-code 1.0.7 → 1.0.9

package/extensions/mcp.ts

@@ -649,6 +649,23 @@ type HttpFamilyTransport = SSEClientTransport | StreamableHTTPClientTransport //
 
 type MakeTransport = (authProvider?: OAuthClientProvider) => HttpFamilyTransport
 
+/** Interactive OAuth logins block on a confirm dialog and open a browser tab, so two
+ * at once (a user-scope and a consented project-scope server both 401ing, connecting in
+ * parallel) would stack dialogs and browser tabs. This chains them so a second
+ * interactive login waits for the first to settle; the tail is reset to a resolved
+ * promise regardless of outcome, so a failed login never poisons the queue. Silent
+ * (stored-token) connects do not pass through here and stay fully parallel. */
+let oauthQueue: Promise<unknown> = Promise.resolve()
+
+function serializeInteractiveOAuth<T>(run: () => Promise<T>): Promise<T> {
+  const result = oauthQueue.then(run, run)
+  oauthQueue = result.then(
+    () => {},
+    () => {},
+  )
+  return result
+}
+
 /**
  * Connect an http-family server, running Claude's OAuth login when the server
  * demands one. Stored tokens ride the first attempt so the SDK refreshes
@@ -671,7 +688,7 @@ async function connectHttpFamily(name: string, config: { url: string }, makeTran
   } catch (error) {
     if (bearerToken || !isUnauthorized(error)) throw error
     if (!authUi) throw new OAuthRequiredError(`${name} requires a login; run pi interactively to authenticate`)
-    return await runInteractiveOAuth(name, config, makeTransport, label, authUi, newClient)
+    return await serializeInteractiveOAuth(() => runInteractiveOAuth(name, config, makeTransport, label, authUi, newClient))
   }
 }
 
@@ -933,7 +950,9 @@ export default async function mcpExtension(pi: ExtensionAPI) {
               ctx.ui.notify(`${commandName}: prompt returned no content`, 'info')
               return
             }
-            pi.sendUserMessage(content)
+            // A bare send throws (and is silently swallowed) while the agent is
+            // streaming, so mid-stream invocations queue as a follow-up turn.
+            pi.sendUserMessage(content, ctx.isIdle() ? {} : { deliverAs: 'followUp' })
           } catch (error) {
             ctx.ui.notify(`${commandName}: ${error instanceof Error ? error.message : String(error)}`, 'error')
           }
@@ -1111,17 +1130,11 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     )
   }
 
-  /** Connect the project scope under the per-server policy. Returns whether the scope
-   * is settled, so a refused confirm can be retried on a later session start. */
-  async function connectProjectScope(ctx: ExtensionContext): Promise<boolean> {
-    // The stored decision, read without prompting: consent recorded inside the
-    // project only counts once the project itself has been approved.
-    const approved = isProjectApprovedSilently(ctx)
-    const policy = projectServerPolicy(ctx.cwd, os.homedir(), approved)
-    const { allowed, denied } = mcpAllowDeny()
-    const { consented, gated } = splitByPolicy(applyServerPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), allowed, denied), policy)
-    const authUi = authUiFor(ctx)
-    if (Object.keys(consented).length > 0) await connectServers(consented, authUi)
+  /** Connect the approval-gated project servers, behind the whole-project confirm.
+   * Returns whether the scope is settled, so a refused confirm can be retried on a
+   * later session start. The consented half of the project scope connects earlier,
+   * concurrently with the user scope, from session_start itself. */
+  async function connectGatedProjectServers(ctx: ExtensionContext, gated: Record<string, ServerConfig>, authUi?: AuthUi): Promise<boolean> {
     if (Object.keys(gated).length === 0) return true
     if (!(await isProjectApproved(ctx))) return false
     await connectServers(gated, authUi)
@@ -1146,16 +1159,28 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // entry cannot shadow a trusted user server by reusing its name. A gated project
     // server still awaiting the approval prompt does not preempt the user server: that is
     // a deliberate narrowing of Claude's rule to keep the safe default.
+    // The stored project decision, read without prompting: consent recorded inside
+    // the project only counts once the project itself has been approved.
     const projectPolicy = projectServerPolicy(ctx.cwd, os.homedir(), isProjectApprovedSilently(ctx))
-    const projectWinners = new Set(Object.keys(splitByPolicy(applyServerPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), allowed, denied), projectPolicy).consented))
+    const { consented, gated } = splitByPolicy(applyServerPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), allowed, denied), projectPolicy)
+    const projectWinners = new Set(Object.keys(consented))
     const userServers = Object.fromEntries(Object.entries(scoped).filter(([name]) => !clients.has(name) && !projectWinners.has(name)))
-    if (Object.keys(userServers).length > 0) await connectServers(userServers, authUiFor(ctx))
+    const authUi = authUiFor(ctx)
+    // The consented project servers carry no ordering dependency on the user scope:
+    // projectWinners already excludes their names from userServers, so the two batches
+    // are disjoint and connect concurrently, and startup pays the slower scope rather
+    // than the sum of both. Reconnect attempts after a refused confirm are safe:
+    // connectServers skips names that already connected.
+    const connects: Promise<void>[] = []
+    if (Object.keys(userServers).length > 0) connects.push(connectServers(userServers, authUi))
+    if (!projectConnected && Object.keys(consented).length > 0) connects.push(connectServers(consented, authUi))
+    await Promise.all(connects)
     // A project .mcp.json can run arbitrary commands on connect, so only honor it once
     // the project is trusted. Per-server settings refine that: disabled servers never
-    // connect, servers the user consented to individually connect without the
-    // whole-project confirm, and the rest stay behind it. Reconnect attempts after a
-    // refusal are safe: connectServers skips names that already connected.
-    if (!projectConnected) projectConnected = await connectProjectScope(ctx)
+    // connect, servers the user consented to individually connected above without the
+    // whole-project confirm, and the rest stay behind it, sequentially after both
+    // scopes so the confirm dialog never races a connect.
+    if (!projectConnected) projectConnected = await connectGatedProjectServers(ctx, gated, authUi)
 
     pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
 

package/extensions/memory.ts

@@ -12,7 +12,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import { StringEnum } from '@earendil-works/pi-ai'
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { type ExtensionAPI, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
 import { capForContext } from './internal/output-guard.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
@@ -138,29 +138,39 @@ export function indexWouldOverflow(index: string, name: string, description: str
   return next.split('\n').length > INDEX_MAX_LINES || Buffer.byteLength(next, 'utf-8') > INDEX_MAX_BYTES
 }
 
-/** Write a memory and its index line, or say why it cannot be written. */
-export function saveMemory(dir: string, indexPath: string, name: string | undefined, description: string | undefined, content: string | undefined, now: string = new Date().toISOString()): { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> } {
+type MemoryToolResult = { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> }
+
+/** Write a memory and its index line, or say why it cannot be written. The whole
+ * read-modify-write holds the index's mutation queue: tool calls run in parallel, so
+ * two unqueued saves both read the same index and the second silently drops the first's
+ * line. The queue keys ONLY on the index, the shared file every save touches, and never
+ * also on the memory file: a second nested queue self-deadlocks when a memory name
+ * canonicalizes to the same key as the index (e.g. `memory.md` and `MEMORY.md` under a
+ * case-insensitive filesystem, since the queue keys on realpath). */
+export async function saveMemory(dir: string, indexPath: string, name: string | undefined, description: string | undefined, content: string | undefined, now: string = new Date().toISOString()): Promise<MemoryToolResult> {
   if (!name || !description || !content) {
     return { content: [{ type: 'text', text: 'save requires name, description, and content.' }], details: {} }
   }
-  const index = readIndex(dir)
-  // Claude reports an explicit error rather than writing a memory the next session
-  // would never load, and says what to do about it.
-  if (indexWouldOverflow(index, name, description)) {
-    return {
-      content: [{ type: 'text', text: `Memory index is full (${INDEX_MAX_LINES} entries or ${INDEX_MAX_BYTES} bytes). Delete or consolidate memories before saving ${name}.` }],
-      details: {},
+  return withFileMutationQueue(indexPath, async (): Promise<MemoryToolResult> => {
+    const index = readIndex(dir)
+    // Claude reports an explicit error rather than writing a memory the next session
+    // would never load, and says what to do about it.
+    if (indexWouldOverflow(index, name, description)) {
+      return {
+        content: [{ type: 'text', text: `Memory index is full (${INDEX_MAX_LINES} entries or ${INDEX_MAX_BYTES} bytes). Delete or consolidate memories before saving ${name}.` }],
+        details: {},
+      }
     }
-  }
-  fs.mkdirSync(dir, { recursive: true })
-  // A memory with frontmatter records its write time; one without is left as-is.
-  fs.writeFileSync(path.join(dir, `${name}.md`), stampModified(content, now))
-  writeIndex(indexPath, upsertIndexLine(index, name, description))
-  return { content: [{ type: 'text', text: `Saved memory ${name}.` }], details: {} }
+    fs.mkdirSync(dir, { recursive: true })
+    // A memory with frontmatter records its write time; one without is left as-is.
+    fs.writeFileSync(path.join(dir, `${name}.md`), stampModified(content, now))
+    writeIndex(indexPath, upsertIndexLine(index, name, description))
+    return { content: [{ type: 'text', text: `Saved memory ${name}.` }], details: {} }
+  })
 }
 
 /** The read action: a memory's body, capped for context, or a not-found message. */
-function readMemory(dir: string, name: string): { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> } {
+function readMemory(dir: string, name: string): MemoryToolResult {
   try {
     const body = fs.readFileSync(path.join(dir, `${name}.md`), 'utf-8')
     return { content: [{ type: 'text', text: capForContext(body) }], details: {} }
@@ -169,21 +179,23 @@ function readMemory(dir: string, name: string): { content: Array<{ type: 'text';
   }
 }
 
-/** The delete action: remove a memory file and its index line. The index is read
- * before anything is removed: refusing on a failed read must leave both the memory
- * file and the index as they were. */
-function deleteMemory(dir: string, indexPath: string, name: string): { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> } {
-  let index: string
+/** The delete action: remove a memory file and its index line, queued on the index
+ * like save (single key, no deadlock). The index is read before anything is removed,
+ * and any failure (a bad index read, or an unreadable store the queue key cannot
+ * realpath) leaves both the memory file and the index as they were. */
+async function deleteMemory(dir: string, indexPath: string, name: string): Promise<MemoryToolResult> {
   try {
-    index = readIndex(dir)
+    return await withFileMutationQueue(indexPath, async (): Promise<MemoryToolResult> => {
+      const index = readIndex(dir)
+      fs.rmSync(path.join(dir, `${name}.md`), { force: true })
+      const remaining = removeIndexLine(index, name)
+      if (remaining) writeIndex(indexPath, remaining)
+      else fs.rmSync(indexPath, { force: true })
+      return { content: [{ type: 'text', text: `Deleted memory ${name}.` }], details: {} }
+    })
   } catch (error) {
     return { content: [{ type: 'text', text: `Memory delete failed: ${error instanceof Error ? error.message : String(error)}. Nothing was deleted.` }], details: {} }
   }
-  fs.rmSync(path.join(dir, `${name}.md`), { force: true })
-  const remaining = removeIndexLine(index, name)
-  if (remaining) writeIndex(indexPath, remaining)
-  else fs.rmSync(indexPath, { force: true })
-  return { content: [{ type: 'text', text: `Deleted memory ${name}.` }], details: {} }
 }
 
 /** The index as injected into the prompt, bounded like Claude's startup load. */
@@ -298,6 +310,27 @@ export default function memoryExtension(pi: ExtensionAPI) {
   let dir = memoryDir(process.cwd())
   let enabled = true
 
+  // The index is injected every turn but changes only through the tool or an external
+  // edit, so a turn costs one stat instead of a full read. The stat token (mtime plus
+  // size) catches external edits; save and delete drop the cache outright, since a
+  // rename landing within one mtime tick at the same size would slip past the token.
+  let indexCache: { token: string; index: string } | null = null
+
+  const indexStatToken = (): string => {
+    try {
+      const stat = fs.statSync(path.join(dir, INDEX_FILE))
+      return `${stat.mtimeMs}:${stat.size}`
+    } catch {
+      return 'missing'
+    }
+  }
+
+  const readIndexCached = (): string => {
+    const token = indexStatToken()
+    if (indexCache?.token !== token) indexCache = { token, index: readIndexQuietly(dir) }
+    return indexCache.index
+  }
+
   // These extensions also load inside spawned subagent processes, which carry the
   // PI_CODE_SUBAGENT marker. Claude does not load the main conversation's auto memory
   // into subagents (they get their own store through the agent `memory:` field), so
@@ -313,6 +346,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
     enabled = autoMemoryEnabled(settings.autoMemoryEnabled, process.env)
     const override = typeof settings.autoMemoryDirectory === 'string' ? settings.autoMemoryDirectory : undefined
     dir = enabled ? resolveMemoryDir(ctx.cwd, override) : memoryDir(ctx.cwd)
+    indexCache = null
     if (!enabled) return
     const count = readIndexQuietly(dir)
       .split('\n')
@@ -322,7 +356,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
   pi.on('before_agent_start', async (event) => {
     if (inSubagent() || !enabled) return
-    const index = readIndexQuietly(dir)
+    const index = readIndexCached()
     if (!index.trim()) return
     return {
       systemPrompt: `${event.systemPrompt}\n\n## Memory\n\nPersistent memories from earlier sessions (index):\n\n${capIndexForPrompt(index)}\nUse the memory tool with action "read" to load a memory's full content when relevant.`,
@@ -346,9 +380,12 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
       if (params.action === 'save') {
         try {
-          return saveMemory(dir, indexPath, name, params.description, params.content)
+          // Awaited here, not returned: the catch must see a queued write's rejection.
+          return await saveMemory(dir, indexPath, name, params.description, params.content)
         } catch (error) {
           return { content: [{ type: 'text' as const, text: `Memory save failed: ${error instanceof Error ? error.message : String(error)}. The index was left untouched.` }], details: {} }
+        } finally {
+          indexCache = null
         }
       }
 
@@ -359,7 +396,13 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
       if (params.action === 'delete') {
         if (!name) return { content: [{ type: 'text' as const, text: 'delete requires name.' }], details: {} }
-        return deleteMemory(dir, indexPath, name)
+        // In a finally like the save path: a delete that throws mid-write must still
+        // drop the cache, or the next turn injects a stale index.
+        try {
+          return await deleteMemory(dir, indexPath, name)
+        } finally {
+          indexCache = null
+        }
       }
 
       const index = readIndexQuietly(dir)

package/extensions/notify.ts

@@ -113,6 +113,11 @@ export default function notifyExtension(pi: ExtensionAPI) {
     lastInputAt = Date.now()
   })
 
+  // Fires on agent_end rather than agent_settled deliberately: agent_settled is only
+  // emitted after every agent_end handler returns, and a peer extension (plan mode)
+  // blocks its agent_end handler on a UI dialog, which would starve this notification
+  // exactly when the user has stepped away. agent_end can fire slightly early before a
+  // rare automatic retry or compaction, which is a better failure than never notifying.
   pi.on('agent_end', async () => {
     if (channel === 'off') return
     // Piped or headless stdout (pi -p, CI) must not receive raw escape bytes.

package/extensions/plan-mode/index.ts

@@ -209,7 +209,9 @@ export default function planModeExtension(pi: ExtensionAPI): void {
       planFromTool = false
       const refinement = await ctx.ui.editor('Refine the plan:', '')
       if (refinement?.trim()) {
-        pi.sendUserMessage(refinement.trim())
+        // A bare send throws (and is silently swallowed) while the agent is
+        // streaming, so mid-stream invocations queue as a follow-up turn.
+        pi.sendUserMessage(refinement.trim(), ctx.isIdle() ? {} : { deliverAs: 'followUp' })
       }
     }
   }

package/extensions/question.ts

@@ -238,7 +238,39 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
   // The free-text option does not compose with checkbox selection, so it is single-select only.
   const allOptions: DisplayOption[] = multiSelect ? [...params.options] : [...params.options, { label: 'Type something.', isOther: true }]
 
-  const result = await ctx.ui.custom<{ answer: string; wasCustom: boolean; index?: number } | null>((tui: Parameters<Parameters<ExtensionContext['ui']['custom']>[0]>[0], theme: Theme, _kb: unknown, done: (value: { answer: string; wasCustom: boolean; index?: number } | null) => void) => {
+  // ui.custom() is terminal-only: with a UI but no terminal (RPC mode) it resolves
+  // undefined immediately, which would read as a cancel without ever asking. Ask
+  // through the dialog primitives there instead.
+  const result = ctx.mode === 'tui' ? await askViaOverlay(params, ctx, allOptions, multiSelect) : await askViaDialogs(params, ctx, allOptions, multiSelect)
+
+  // Build simple options list for details; header/multiSelect appear only when set,
+  // so single-select details are unchanged.
+  const simpleOptions = params.options.map((o) => o.label)
+  const base = { question: params.question, options: simpleOptions, ...(params.header ? { header: shortHeader(params.header) } : {}), ...(multiSelect ? { multiSelect: true } : {}) }
+
+  if (!result) {
+    return {
+      content: [{ type: 'text', text: 'User cancelled the selection' }],
+      details: { ...base, answer: null } as QuestionDetails,
+    }
+  }
+
+  if (result.wasCustom) {
+    return {
+      content: [{ type: 'text', text: `User wrote: ${result.answer}` }],
+      details: { ...base, answer: result.answer, wasCustom: true } as QuestionDetails,
+    }
+  }
+  const selectionText = multiSelect ? `User selected: ${result.answer || '(none)'}` : `User selected: ${result.index}. ${result.answer}`
+  return {
+    content: [{ type: 'text', text: selectionText }],
+    details: { ...base, answer: result.answer, wasCustom: false } as QuestionDetails,
+  }
+}
+
+/** Terminal path: the full custom overlay (options list, checkboxes, inline editor). */
+function askViaOverlay(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean): Promise<{ answer: string; wasCustom: boolean; index?: number } | null> {
+  return ctx.ui.custom<{ answer: string; wasCustom: boolean; index?: number } | null>((tui: Parameters<Parameters<ExtensionContext['ui']['custom']>[0]>[0], theme: Theme, _kb: unknown, done: (value: { answer: string; wasCustom: boolean; index?: number } | null) => void) => {
     let optionIndex = 0
     let editMode = false
     const checked: boolean[] = allOptions.map(() => false)
@@ -339,28 +371,29 @@ async function askOne(params: QuestionSpec, ctx: ExtensionContext): Promise<{ co
       handleInput,
     }
   })
+}
 
-  // Build simple options list for details; header/multiSelect appear only when set,
-  // so single-select details are unchanged.
-  const simpleOptions = params.options.map((o) => o.label)
-  const base = { question: params.question, options: simpleOptions, ...(params.header ? { header: shortHeader(params.header) } : {}), ...(multiSelect ? { multiSelect: true } : {}) }
-
-  if (!result) {
-    return {
-      content: [{ type: 'text', text: 'User cancelled the selection' }],
-      details: { ...base, answer: null } as QuestionDetails,
-    }
-  }
-
-  if (result.wasCustom) {
-    return {
-      content: [{ type: 'text', text: `User wrote: ${result.answer}` }],
-      details: { ...base, answer: result.answer, wasCustom: true } as QuestionDetails,
-    }
-  }
-  const selectionText = multiSelect ? `User selected: ${result.answer || '(none)'}` : `User selected: ${result.index}. ${result.answer}`
-  return {
-    content: [{ type: 'text', text: selectionText }],
-    details: { ...base, answer: result.answer, wasCustom: false } as QuestionDetails,
+/** Dialog-primitive fallback for UI without a terminal (RPC mode supports
+ * select/input/notify but not custom components). Mirrors the overlay's result
+ * shape; a dismissed dialog reads as a cancel, same as Escape in the overlay. */
+async function askViaDialogs(params: QuestionSpec, ctx: ExtensionContext, allOptions: DisplayOption[], multiSelect: boolean): Promise<{ answer: string; wasCustom: boolean; index?: number } | null> {
+  const header = shortHeader(params.header)
+  const title = header ? `[${header}] ${params.question}` : params.question
+  // Number the labels: ctx.ui.select returns the chosen label string, so duplicate
+  // labels (or a model-supplied option named like the free-text entry) would be
+  // ambiguous by text alone; the number is the unambiguous way back to the option.
+  const labels = allOptions.map((option, i) => `${i + 1}. ${option.label}`)
+  const choice = await ctx.ui.select(title, labels)
+  if (choice === undefined) return null
+  const index = labels.indexOf(choice)
+  const chosen = allOptions[index]
+  if (!multiSelect && chosen?.isOther === true) {
+    const typed = await ctx.ui.input(params.question, 'Your answer')
+    // A dismissed dialog cancels; a submitted empty answer is an (empty) answer, not a
+    // cancel, so one accidental blank Enter does not abort the rest of a question batch.
+    if (typed === undefined) return null
+    return { answer: typed.trim(), wasCustom: true }
   }
+  const answer = chosen?.label ?? choice
+  return multiSelect ? { answer, wasCustom: false } : { answer, wasCustom: false, index: index + 1 }
 }

package/extensions/status-line.ts

@@ -13,8 +13,10 @@
  * the built-in segment stands in.
  *
  * Without a configured statusLine, the built-in segment shows turn state plus
- * running session cost, summed from per-message usage on the current branch so it
- * stays correct across /tree navigation and forks. The built-in segment is also
+ * running session cost: a total seeded from the branch's per-message usage at
+ * session start, accumulated per message_end, and reseeded when compaction or
+ * /tree navigation reshapes the branch, so it stays correct across navigation
+ * and forks without re-walking the branch on every render. The built-in segment is also
  * the fallback while a configured command produces no output. Multi-line output
  * is truncated to its first line: the segment is one footer row in pi.
  *
@@ -48,6 +50,8 @@ interface UsageEntry {
   message?: { usage?: { cost?: { total?: number } } }
 }
 
+/** Full branch walk: used only to (re)seed the running total, at session start
+ * and on the events that reshape the branch. Renders read the total instead. */
 function sessionCost(ctx: ExtensionContext): number {
   let total = 0
   for (const entry of ctx.sessionManager.getBranch() as UsageEntry[]) {
@@ -95,8 +99,17 @@ export default function statusLine(pi: ExtensionAPI) {
   let sessionCtx: ExtensionContext | undefined
   let commandLine: string | undefined
   let permissionMode = 'default'
-  let projectApproved = false
   let sessionStartMs = Date.now()
+  // Running session cost; seeded and reseeded by sessionCost(), see below.
+  let costTotal = 0
+  // The output-style settings chain and active style name, resolved once at
+  // session start: the chain's upward walk and per-file reads are too costly for
+  // every refresh tick. /output-style persists a choice straight to settings with
+  // no bus event, and the new style applies from the next turn anyway, so the
+  // cached name is re-read lazily at most once per turn (styleDirty, turn_start).
+  let styleFiles: string[] = []
+  let styleName: string | undefined
+  let styleDirty = false
   // Lines changed, counted from successful edit/write inputs: newText and content
   // lines add, oldText lines remove. An approximation of Claude's counters, which
   // is honest for the tools pi has; bash-side changes are invisible to both.
@@ -114,8 +127,7 @@ export default function statusLine(pi: ExtensionAPI) {
 
   function segmentText(ctx: ExtensionContext, symbol: string): string {
     const theme = ctx.ui.theme
-    const cost = sessionCost(ctx)
-    const costText = cost > 0 ? theme.fg('muted', ` ${formatCost(cost)}`) : ''
+    const costText = costTotal > 0 ? theme.fg('muted', ` ${formatCost(costTotal)}`) : ''
     const turnText = turnCount > 0 ? theme.fg('dim', ` turn ${turnCount}`) : theme.fg('dim', ' ready')
     return symbol + turnText + costText
   }
@@ -128,9 +140,11 @@ export default function statusLine(pi: ExtensionAPI) {
   function buildPayload(ctx: ExtensionContext): Record<string, unknown> {
     const usage = ctx.getContextUsage() ?? { tokens: null, contextWindow: 0, percent: null }
     const model = ctx.model as { id?: string; name?: string } | undefined
-    // Same gate as the config read above: an unapproved project's style is not applied,
-    // so reporting it here would describe a style the session is not using.
-    const styleName = readActiveStyleName(settingsFiles(ctx.cwd, os.homedir(), projectApproved))
+    // Refresh the cached style name only when a turn boundary may have changed it.
+    if (styleDirty) {
+      styleName = readActiveStyleName(styleFiles)
+      styleDirty = false
+    }
     const payload: Record<string, unknown> = {
       hook_event_name: 'Status',
       session_id: ctx.sessionManager.getSessionId(),
@@ -141,7 +155,7 @@ export default function statusLine(pi: ExtensionAPI) {
       // read .model.display_name and render the literal "null" when it is missing.
       model: { id: model?.id ?? '', display_name: model?.name ?? model?.id ?? '' },
       cost: {
-        total_cost_usd: sessionCost(ctx),
+        total_cost_usd: costTotal,
         total_duration_ms: Date.now() - sessionStartMs,
         total_api_duration_ms: apiDurationMs,
         total_lines_added: linesAdded,
@@ -250,10 +264,13 @@ export default function statusLine(pi: ExtensionAPI) {
     if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
     requestStartMs = undefined
   })
-  // The last message's token usage, for the breakdown getContextUsage() omits.
+  // The last message's token usage, for the breakdown getContextUsage() omits,
+  // and the running cost total, so renders never re-walk the branch.
   pi.on('message_end', async (event) => {
-    const usage = (event as { message?: { usage?: NonNullable<typeof lastUsage> } }).message?.usage
-    if (usage) lastUsage = usage
+    const usage = (event as { message?: { usage?: NonNullable<typeof lastUsage> & { cost?: { total?: number } } } }).message?.usage
+    if (!usage) return
+    lastUsage = usage
+    costTotal += usage.cost?.total ?? 0
   })
 
   pi.on('session_start', async (_event, ctx) => {
@@ -268,11 +285,18 @@ export default function statusLine(pi: ExtensionAPI) {
     requestStartMs = undefined
     lastUsage = undefined
     clearInterval(refreshTimer)
+    // Seed the running cost from the branch: a resumed or forked session starts
+    // with history, and message_end only accumulates from here on.
+    costTotal = sessionCost(ctx)
     // Reading config must never open a trust dialog: several extensions resolve
     // approval at session start, and a second prompt stacks over the first and eats
     // the keys meant for it. An undecided project simply skips project settings.
     const trusted = isProjectApprovedSilently(ctx)
-    projectApproved = trusted
+    // Same gate for the style chain: an unapproved project's style is not applied,
+    // so reporting it in the payload would describe a style the session is not using.
+    styleFiles = settingsFiles(ctx.cwd, os.homedir(), trusted)
+    styleName = readActiveStyleName(styleFiles)
+    styleDirty = false
     const files = hookFiles(ctx.cwd, os.homedir(), trusted)
     // Claude's disableAllHooks also turns off the custom statusLine command; the
     // built-in segment still renders as the fallback.
@@ -286,6 +310,9 @@ export default function statusLine(pi: ExtensionAPI) {
 
   pi.on('turn_start', async (_event, ctx) => {
     turnCount++
+    // A /output-style between turns lands in settings silently; its style applies
+    // from this turn, so this is the moment the cached name can go stale.
+    styleDirty = true
     const theme = ctx.ui.theme
     show(ctx, theme.fg('accent', '●') + theme.fg('dim', ` turn ${turnCount}...`))
   })
@@ -300,10 +327,17 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
-  pi.on('session_compact', async (_event, _ctx) => {
+  pi.on('session_compact', async (_event, ctx) => {
+    // Compaction replaces the branch entries; reseed the total from what remains.
+    costTotal = sessionCost(ctx)
     scheduleRefresh()
   })
 
+  pi.on('session_tree', async (_event, ctx) => {
+    // Tree navigation swaps the branch wholesale with no message_end events.
+    costTotal = sessionCost(ctx)
+  })
+
   pi.on('session_shutdown', async () => {
     clearInterval(refreshTimer)
     clearTimeout(debounceTimer)

package/extensions/subagent/index.ts

@@ -1352,7 +1352,16 @@ export default function subagentExtension(pi: ExtensionAPI) {
   // available model list are captured per session so a hook run lands in the right repo.
   let hookCwd = process.cwd()
   let hookModels: ReadonlyArray<{ id: string }> = []
+
+  // Discovery walks the plugin cache, the builtin dir, and every agent dir, parsing
+  // each file: dozens of fs ops per call. The roster injection below runs every turn
+  // for a list that almost never changes mid-session, so it reuses one discovery per
+  // (cwd, scope), dropped on session_start. The tool's execute() keeps rediscovering
+  // per invocation, so a just-added agent is still runnable without a restart.
+  let rosterCache: { key: string; agents: AgentConfig[] } | null = null
+
   pi.on('session_start', async (_event, ctx) => {
+    rosterCache = null
     hookCwd = ctx.cwd
     try {
       hookModels = ctx.modelRegistry?.getAvailable?.() ?? []
@@ -1378,12 +1387,15 @@ export default function subagentExtension(pi: ExtensionAPI) {
   })
 
   // Claude surfaces each agent's description so the model can pick one autonomously.
-  // Rebuilt per turn (agents are rediscovered per invocation too); project agents are
-  // included only when the project is already approved, read without prompting, since
-  // a trust dialog must not appear mid-turn and their descriptions are project text.
+  // Served from the session-level cache above (keyed on cwd and scope, so an approval
+  // granted mid-session still widens it); project agents are included only when the
+  // project is already approved, read without prompting, since a trust dialog must
+  // not appear mid-turn and their descriptions are project text.
   pi.on('before_agent_start', async (event, ctx) => {
-    const scope = isProjectApprovedSilently(ctx) ? 'both' : 'user'
-    const { agents } = discoverAgents(ctx.cwd, scope)
+    const scope: AgentScope = isProjectApprovedSilently(ctx) ? 'both' : 'user'
+    const key = `${scope}\n${ctx.cwd}`
+    if (rosterCache?.key !== key) rosterCache = { key, agents: discoverAgents(ctx.cwd, scope).agents }
+    const { agents } = rosterCache
     if (agents.length === 0) return
     const line = (text: string): string => text.replace(/\s+/g, ' ').trim().slice(0, 200)
     const roster = agents.map((agent) => `- ${agent.name} (${agent.source}): ${line(agent.description)}`).join('\n')

package/extensions/todo.ts

@@ -84,6 +84,9 @@ const listMark = (status: TodoStatus): string => {
   return '[ ]'
 }
 
+/** Plain-text list, shared by the list action and the non-terminal /todos path. */
+const plainTodoList = (todos: Todo[]): string => (todos.length ? todos.map((t) => `${listMark(t.status)} #${t.id}: ${t.text}`).join('\n') : 'No todos')
+
 const overlayLabel = (todo: Todo, theme: Theme): string => {
   if (todo.status === 'completed') return theme.fg('dim', todo.text)
   if (todo.status === 'in_progress') return theme.fg('text', todo.activeForm ?? todo.text)
@@ -433,7 +436,7 @@ export default function todoExtension(pi: ExtensionAPI) {
     return ok('clear', `Cleared ${count} todos`)
   }
 
-  const handleList = () => ok('list', todos.length ? todos.map((t) => `${listMark(t.status)} #${t.id}: ${t.text}`).join('\n') : 'No todos')
+  const handleList = () => ok('list', plainTodoList(todos))
 
   // Register the todo tool for the LLM
   pi.registerTool({
@@ -516,6 +519,13 @@ export default function todoExtension(pi: ExtensionAPI) {
         return
       }
 
+      // ui.custom() is terminal-only: with a UI but no terminal (RPC mode) it
+      // resolves undefined without showing anything, so notify the plain list.
+      if (ctx.mode !== 'tui') {
+        ctx.ui.notify(plainTodoList(todos), 'info')
+        return
+      }
+
       await ctx.ui.custom<void>((_tui, theme, _kb, done) => {
         return new TodoListComponent(todos, theme, () => done())
       })