@herbertgao/pi-subagents 0.15.4 → 0.16.0

package/src/usage.ts

@@ -6,23 +6,151 @@
  * stats-derived sum). cacheRead is excluded because each turn's cacheRead is
  * the cumulative cached prefix re-read on that one call — summing across
  * turns counts the prefix N times. See issue #38.
+ *
+ * That exclusion is about this *display* total, not about what was billed: the
+ * prefix really is re-read and re-charged on every call. So `cacheRead` is
+ * accumulated here anyway, kept out of `getLifetimeTotal` and used only where
+ * billing is the question — reporting to the parent session, whose own messages
+ * pi counts the same way (`addUsageToTotals`). Reporting 0 there would make a
+ * subagent's rows count differently from every other row in one total.
+ *
+ * `cost` is a plain sum for the same reason: it is what pi charged for that one
+ * message (`usage.cost.total`, priced from the model's rates), not a cumulative
+ * figure. Both are optional because a model with no pricing data reports no
+ * cost, and because every accumulator predates them; absent reads as 0.
  */
 export type LifetimeUsage = {
   input: number
   output: number
   cacheWrite: number
+  cacheRead?: number
+  cost?: number
 }
 
-/** Sum of lifetime usage components, or 0 if undefined. */
+/**
+ * Sum of lifetime *token* components for DISPLAY, or 0 if undefined.
+ * Deliberately excludes `cacheRead` (see above) and `cost` — that is money, not
+ * tokens, and lives on the same object only because it accumulates on the same
+ * events.
+ */
 export function getLifetimeTotal(u?: LifetimeUsage): number {
   return u ? u.input + u.output + u.cacheWrite : 0
 }
 
+/** Accumulated cost in USD, or 0 when unpriced/undefined. */
+export function getLifetimeCost(u?: LifetimeUsage): number {
+  return u?.cost ?? 0
+}
+
 /** Add a usage delta into a target accumulator (mutates target). */
 export function addUsage(into: LifetimeUsage, delta: LifetimeUsage): void {
   into.input += delta.input
   into.output += delta.output
   into.cacheWrite += delta.cacheWrite
+  if (delta.cacheRead) into.cacheRead = (into.cacheRead ?? 0) + delta.cacheRead
+  if (delta.cost) into.cost = (into.cost ?? 0) + delta.cost
+}
+
+/**
+ * A pi `Usage`. Rebuilt here rather than imported so this module stays
+ * dependency-free for tests; the fields are pi's, and every one of them must be
+ * present: pi's `addUsageToTotals` dereferences `usage.cost.total` with no
+ * guard, so a partial object throws inside pi rather than at the call site.
+ *
+ * This is pi's convention for spend in anything handed to a consumer — every
+ * extension-facing payload that carries it takes the whole object
+ * (`ToolResultEvent`, `ToolResultEventResult`, `AssistantMessage`, …), never a
+ * flattened cost. Pi flattens only in computed read APIs it expects you to
+ * render, like `SessionStats`. So both places we hand usage to someone else —
+ * `AgentToolResult.usage` and the `subagents:completed` / `subagents:failed`
+ * events — carry this, and gain whatever pi adds to `Usage` for free.
+ */
+export type ReportedUsage = {
+  input: number
+  output: number
+  cacheRead: number
+  cacheWrite: number
+  totalTokens: number
+  cost: {
+    input: number
+    output: number
+    cacheRead: number
+    cacheWrite: number
+    total: number
+  }
+}
+
+/**
+ * Render an accumulator as a pi `Usage`, or undefined when nothing was spent —
+ * callers attach nothing rather than a zero, so a consumer can tell "spent
+ * nothing" from "never ran".
+ *
+ * `cacheRead` IS included, unlike in `getLifetimeTotal`: pi sums it across a
+ * session's own assistant messages, and the prefix genuinely is re-read and
+ * re-billed on every call. Only `total` is populated on the cost breakdown; pi
+ * reads nothing else from it, and the per-kind split is not tracked.
+ */
+export function toReportedUsage(u: LifetimeUsage): ReportedUsage | undefined {
+  const { input, output, cacheWrite, cacheRead = 0, cost = 0 } = u
+  if (
+    input === 0 &&
+    output === 0 &&
+    cacheWrite === 0 &&
+    cacheRead === 0 &&
+    cost === 0
+  )
+    return undefined
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens: input + output + cacheRead + cacheWrite,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: cost },
+  }
+}
+
+/**
+ * Subagent spend that the parent session has not been told about yet.
+ *
+ * Subagents run in their own pi sessions, so none of what they spend appears in
+ * the parent's `getSessionStats()`. Pi does aggregate `toolResult.usage` into
+ * those stats, though — so the way back into the parent's footer and `/cost` is
+ * to hang the spend on a tool result. Background and scheduled agents finish
+ * between tool calls with nothing to hang it on, hence a pool: every assistant
+ * message lands here as it happens, and the next tool result we return carries
+ * whatever has accumulated.
+ *
+ * Drain empties it, so each message is reported exactly once no matter how many
+ * results are returned or how many agents were running.
+ */
+export class PendingUsagePool {
+  private pending: LifetimeUsage = {
+    input: 0,
+    output: 0,
+    cacheWrite: 0,
+    cacheRead: 0,
+    cost: 0,
+  }
+  private dirty = false
+
+  add(delta: LifetimeUsage): void {
+    addUsage(this.pending, delta)
+    this.dirty = true
+  }
+
+  /**
+   * Take everything accumulated so far as a pi `Usage`, resetting the pool.
+   * Returns undefined when nothing is pending, so callers can leave the tool
+   * result untouched rather than attaching a zero.
+   */
+  drain(): ReportedUsage | undefined {
+    if (!this.dirty) return undefined
+    const drained = toReportedUsage(this.pending)
+    this.pending = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, cost: 0 }
+    this.dirty = false
+    return drained
+  }
 }
 
 /** Minimal shape we read from upstream `getSessionStats()`. */

package/src/worktree.ts

@@ -28,6 +28,26 @@ export interface WorktreeInfo {
   workPath: string
 }
 
+/**
+ * Project-wide switch for worktree isolation (`worktreeIsolation` in
+ * subagents.json). Default `true` — unchanged behaviour.
+ *
+ * The `"off"` isolation value gives a model a legal way to decline a worktree,
+ * but it still depends on the model choosing it. This is the deterministic half
+ * of the same fix: on a large repo where every worktree costs real time and
+ * disk (#184), turning it off means no caller can create one, whatever it
+ * passes.
+ */
+let worktreeIsolationEnabled = true
+
+export function setWorktreeIsolationEnabled(enabled: boolean): void {
+  worktreeIsolationEnabled = enabled
+}
+
+export function isWorktreeIsolationEnabled(): boolean {
+  return worktreeIsolationEnabled
+}
+
 export interface WorktreeCleanupResult {
   /** Whether changes were found in the worktree. */
   hasChanges: boolean
@@ -134,11 +154,15 @@ export function cleanupWorktree(
       // Truncate description for commit message (no shell sanitization needed — execFileSync uses argv)
       const safeDesc = agentDescription.slice(0, 200)
       const commitMsg = `pi-agent: ${safeDesc}`
-      execFileSync("git", ["commit", "--no-verify", "-m", commitMsg], {
-        cwd: worktree.path,
-        stdio: "pipe",
-        timeout: 10000,
-      })
+      execFileSync(
+        "git",
+        ["commit", "--no-verify", "--no-gpg-sign", "-m", commitMsg],
+        {
+          cwd: worktree.path,
+          stdio: "pipe",
+          timeout: 10000,
+        },
+      )
     } else {
       const currentSha = execFileSync("git", ["rev-parse", "HEAD"], {
         cwd: worktree.path,