pi-code 1.0.7 → 1.0.8

package/extensions/commands.ts

@@ -46,6 +46,7 @@ import { Type } from 'typebox'
 import { matchesBashRules } from './internal/bash-rules.js'
 import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
 import { readManagedSettings } from './internal/managed-settings.js'
+import { capForContext } from './internal/output-guard.js'
 import { matchesPathRules } from './internal/path-rules.js'
 import { type InstalledPlugin, installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
@@ -315,12 +316,17 @@ export default function commandsExtension(pi: ExtensionAPI) {
     pendingBashRules = undefined
     pendingPathRules = undefined
     if (pendingModelRestore) {
-      void pi.setModel(pendingModelRestore as Parameters<typeof pi.setModel>[0])
+      const restore = pendingModelRestore as Parameters<typeof pi.setModel>[0]
       pendingModelRestore = undefined
+      // setModel can reject (e.g. auth resolution fails), and a floated rejection would
+      // escape as unhandled; surface it instead of leaving the session silently on the
+      // command's override model.
+      void pi.setModel(restore).catch(() => {})
+    }
+    if (pendingRestore) {
+      pi.setActiveTools(pendingRestore)
+      pendingRestore = undefined
     }
-    if (!pendingRestore) return
-    pi.setActiveTools(pendingRestore)
-    pendingRestore = undefined
   })
 
   // The active-tool set has no argument dimension, so a scoped grant hands the turn
@@ -416,6 +422,16 @@ export default function commandsExtension(pi: ExtensionAPI) {
     // restored when that run ends. Restoring inline does not work: sendUserMessage is
     // fire-and-forget, so the restore would land before the agent ever read the tool
     // list, leaving the command running with everything enabled.
+    // A command invoked while the agent is streaming must not narrow the in-flight run's
+    // tools or switch its model (that would corrupt a run it does not own), and a bare
+    // sendUserMessage throws mid-stream and would be silently dropped. Queue it as a
+    // follow-up through pi's own queue, which is abort-aware and shown to the user; its
+    // frontmatter scoping is not applied in that case, since it cannot land on a run that
+    // has not started yet.
+    if (!ctx.isIdle()) {
+      pi.sendUserMessage(expanded, { deliverAs: 'followUp' })
+      return
+    }
     applyAllowedTools(parsed, vars)
     applyDisallowedTools(parsed)
     await applyModelOverride(parsed, varCtx)
@@ -500,7 +516,10 @@ export default function commandsExtension(pi: ExtensionAPI) {
         // the tool result is the channel, and frontmatter scoping stays user-path
         // territory (see the header).
         const expanded = await expandCommand(pi, current, args, execCtx, command.filePath, command.plugin, { allowShell: false })
-        return { content: [{ type: 'text' as const, text: `Contents of /${name} (expanded):\n\n${expanded}` }], details: {} }
+        // Cap the tool result: a command body can inline an arbitrarily large @file, and
+        // an uncapped tool result overflows the model's context (every other pi-code tool
+        // routes its output through capForContext). The user-invoked path stays uncapped.
+        return { content: [{ type: 'text' as const, text: capForContext(`Contents of /${name} (expanded):\n\n${expanded}`) }], details: {} }
       },
     })
   })

package/extensions/hooks.ts

@@ -565,7 +565,7 @@ export async function runPromptHook(hook: HookCommand, payload: unknown, model:
   const prompt = substituteArguments(hook.prompt, payload)
   const signal = AbortSignal.timeout(timeoutMs)
   try {
-    const answer = await completeText(model, prompt, { system: PROMPT_HOOK_SYSTEM, maxTokens: 512, signal })
+    const { text: answer } = await completeText(model, prompt, { system: PROMPT_HOOK_SYSTEM, maxTokens: 512, signal })
     return { code: 0, stdout: answer, stderr: '', timedOut: false }
   } catch (error) {
     return abortAwareFailure(signal, error)
@@ -971,6 +971,12 @@ export default function hooksExtension(pi: ExtensionAPI) {
   // turn, and stop_hook_active in the payload tells the next firing it is already
   // continuing from a stop hook, which is the hook script's documented loop guard.
   // Only exit 2 and decision:"block" continue; continue:false means "stay stopped".
+  //
+  // On agent_end rather than agent_settled: 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 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 (idle_prompt). Observational only;

package/extensions/init.ts

@@ -75,7 +75,9 @@ export default function initExtension(pi: ExtensionAPI) {
       const existing = findExistingContextFile(root)
       const cursorRules = statOf(path.join(root, '.cursor', 'rules'))?.isDirectory() === true || statOf(path.join(root, '.cursorrules'))?.isFile() === true
       const copilotRules = statOf(path.join(root, '.github', 'copilot-instructions.md'))?.isFile() === true
-      pi.sendUserMessage(buildInitPrompt({ ...(existing !== undefined ? { existingContextFile: existing } : {}), cursorRules, copilotRules }))
+      // 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(buildInitPrompt({ ...(existing !== undefined ? { existingContextFile: existing } : {}), cursorRules, copilotRules }), ctx.isIdle() ? {} : { deliverAs: 'followUp' })
     },
   })
 }

package/extensions/internal/model-complete.ts

@@ -14,7 +14,7 @@
  * throw and the caller falls back to its non-model behavior.
  */
 
-import type { Api, AssistantMessage, Context, Model, ModelsSimpleStreamOptions } from '@earendil-works/pi-ai'
+import type { Api, AssistantMessage, Context, Model, ModelsSimpleStreamOptions, Usage } from '@earendil-works/pi-ai'
 import { ModelRuntime } from '@earendil-works/pi-coding-agent'
 
 /** The completion backend: model + context -> assistant message. Overridable for tests. */
@@ -52,11 +52,13 @@ export interface CompleteOptions {
 }
 
 /**
- * Run `prompt` through `model` as a single user turn and return the reply text.
+ * Run `prompt` through `model` as a single user turn and return the reply text plus
+ * the call's usage. A tool that makes a nested LLM call must return that usage on
+ * its tool result, or the call's tokens and cost vanish from pi's session totals.
  * Throws on any failure so the caller can fall back; never returns a partial or a
  * tool call, only assistant text.
  */
-export async function completeText(model: Model<Api>, prompt: string, options: CompleteOptions = {}): Promise<string> {
+export async function completeText(model: Model<Api>, prompt: string, options: CompleteOptions = {}): Promise<{ text: string; usage: Usage }> {
   backend ??= realBackend()
   const complete = await backend
   const context: Context = {
@@ -64,5 +66,5 @@ 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 })
-  return assistantText(message)
+  return { text: assistantText(message), usage: message.usage }
 }

package/extensions/mcp.ts

@@ -933,7 +933,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')
           }

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. */
@@ -346,7 +358,8 @@ 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: {} }
         }

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/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())
       })

package/extensions/web.ts

@@ -9,6 +9,7 @@
 import type { LookupAddress } from 'node:dns'
 import { lookup } from 'node:dns/promises'
 import type { LookupFunction } from 'node:net'
+import type { Usage } from '@earendil-works/pi-ai'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
 
@@ -252,16 +253,16 @@ function rememberFetch(cache: FetchCache, url: string, body: string, now: number
 }
 
 /** Claude's WebFetch runs the prompt over the page with a fast model and returns
- * that answer, not the raw page. Best-effort: any failure (no model, provider error)
+ * that answer, not the raw page, along with the nested call's usage so the tool
+ * result can account for it. Best-effort: any failure (no model, provider error)
  * yields null so the caller falls back to the markdown. */
-async function answerFromPage(model: Parameters<typeof completeText>[0], prompt: string, url: string, body: string, signal?: AbortSignal): Promise<string | null> {
+async function answerFromPage(model: Parameters<typeof completeText>[0], prompt: string, url: string, body: string, signal?: AbortSignal): Promise<{ text: string; usage: Usage } | null> {
   try {
-    const answer = await completeText(model, `${prompt}\n\nAnswer using only the page content below, fetched from ${url}:\n\n${body}`, {
+    return await completeText(model, `${prompt}\n\nAnswer using only the page content below, fetched from ${url}:\n\n${body}`, {
       system: 'You extract and answer questions from a web page. Answer only from the provided content, concisely. If the content does not contain the answer, say so.',
       maxTokens: 1024,
       signal,
     })
-    return answer || null
   } catch {
     return null
   }
@@ -318,14 +319,18 @@ export default function webExtension(pi: ExtensionAPI) {
       }
 
       // Best-effort prompt-over-page: a failure returns null, so web_fetch always
-      // falls back to the raw markdown and returns something.
+      // falls back to the raw markdown and returns something. The nested call's
+      // usage rides on the result either way, so pi counts it in session totals.
+      let usage: Usage | undefined
       if (params.prompt && ctx?.model) {
         const answer = await answerFromPage(ctx.model, params.prompt, params.url, body, signal)
-        if (answer) return { content: [{ type: 'text' as const, text: answer }], details: {} }
+        if (answer?.text) return { content: [{ type: 'text' as const, text: answer.text }], details: {}, usage: answer.usage }
+        // An empty answer still cost the completion; the fallback carries its usage.
+        usage = answer?.usage
       }
       // The char cap alone admits thousands of short lines; pi's tool-output budget
       // bounds lines too, which the shared guard enforces.
-      return { content: [{ type: 'text' as const, text: capForContext(body) || '(empty response)' }], details: {} }
+      return { content: [{ type: 'text' as const, text: capForContext(body) || '(empty response)' }], details: {}, usage }
     },
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "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, and subagents",
   "keywords": [
     "pi",