@pify/swarm 0.12.0 → 0.12.1

package/README.md

@@ -99,6 +99,7 @@ The catalog is the same `.pi/agents/*.md` one [`@pify/subagent`](https://github.
 ## Behaviour
 
 - **Independence by design.** Items share nothing, children cannot spawn children, and each child is capped at its agent's `max_turns` — and at 60 minutes of wall-clock, so a tool that never returns cannot hold a concurrency slot (or a blocking `swarm_run`) forever; such an item is reported as aborted with the reason.
+- **What the children cost is shown.** Every child message's cost and tokens go to a process-wide tally; with [`@pify/usage`](https://github.com/pifydev/usage) installed the footer shows it as ` · agents $…` beside the session's own cost, which child sessions otherwise never reach.
 - **A report is the children's words, and is framed as such.** The aggregated report carries a one-line note that it is model output with no user authority, and no item's text can close the `<swarm_result>` wrapper early or contain a literal control tag such as `<system-reminder>` — the same neutralization memory and btw apply to their blocks.
 - **Stopping stops the children.** Pressing Esc stops a foreground run, `/swarm stop [runId]` stops a background one (its tool call returned long ago, so Esc has nothing to reach), and switching away from the session stops both — in every case every live child is aborted rather than left talking to the provider on your money. A cancelled run keeps that verdict — it is never reported as done — and `swarm_status` shows what the items that did finish produced, with each stopped item saying who stopped it.
 - **Isolated runs clean up after themselves.** With `isolation: "worktree"`, a worktree whose child changed nothing is removed along with its branch; otherwise a read-only step left one of each behind on every run. Anything uncommitted, and any commit the child made, is kept and reported.

package/extensions/swarm.ts

@@ -38,6 +38,7 @@ import {
 } from "../src/consent.ts";
 import { LiveChildren, cancelNote, type CancelReason } from "../src/cancel.ts";
 import { outlasts, settleWithin } from "../src/deadline.ts";
+import { addChildSpend } from "../src/child-cost.ts";
 import { DELIVERY_TYPE, deliveryMessage, pendingResult } from "../src/pending.ts";
 import { createIsolationWorktree, isolationNote, removeIfUnchanged } from "../src/isolate.ts";
 import {
@@ -292,7 +293,7 @@ export default function swarm(pi: ExtensionAPI) {
           event as {
             message?: {
               role?: string;
-              usage?: { totalTokens?: number };
+              usage?: { totalTokens?: number; cost?: { total?: number } };
               content?: Array<{ type?: string; text?: string }>;
             };
           }
@@ -301,6 +302,9 @@ export default function swarm(pi: ExtensionAPI) {
           item.turns++;
           const usage = message.usage;
           if (usage && typeof usage.totalTokens === "number") item.tokens += usage.totalTokens;
+          // A child's spend never reaches the parent's branch; tell the
+          // suite-wide tally so @pify/usage can show it beside the session cost.
+          if (usage) addChildSpend("swarm", { cost: usage.cost?.total, tokens: usage.totalTokens });
 
           // Stop an item that is spinning — restating itself without acting —
           // rather than letting it run to the turn cap. See loop-guard.ts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/swarm",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Coordinate multiple pi agents in parallel: swarm_run fan-out with per-item auto-routing, concurrency queue, aggregated reports",
   "keywords": [
     "pi-package",

package/src/child-cost.ts

@@ -0,0 +1,78 @@
+/**
+ * What the children cost, across every @pify extension in the process.
+ *
+ * subagent, swarm and workflow run their children as separate in-memory pi
+ * sessions, so a child's spend never reaches the parent session's branch —
+ * and the usage footer, which folds the branch, under-reports every session
+ * that delegates. This is the one place they all add to and the footer reads.
+ *
+ * The state lives on `globalThis` under a cross-realm `Symbol.for` key, not
+ * in a module variable: pi's loader gives each extension its own module realm
+ * (jiti, `moduleCache: false`), so a module singleton would be a different
+ * object in every package that vendors this file. Same reasoning as
+ * ui-lock.ts. Vendored per package, byte-identical, zero dependencies; every
+ * function is safe to call whether or not any other package is installed.
+ */
+
+const KEY = Symbol.for("pify.child-cost");
+
+export interface ChildSpend {
+  /** USD, as pi priced each child message (usage.cost.total). */
+  cost: number;
+  /** usage.totalTokens summed over child messages. */
+  tokens: number;
+}
+
+interface Store {
+  bySource: Map<string, ChildSpend>;
+  listeners: Set<() => void>;
+}
+
+function store(): Store {
+  const g = globalThis as unknown as { [KEY]?: Store };
+  return (g[KEY] ??= { bySource: new Map(), listeners: new Set() });
+}
+
+/** Record one child message's spend under its package ("subagent", "swarm", "workflow"). Non-finite or negative parts are ignored. */
+export function addChildSpend(source: string, spend: { cost?: number; tokens?: number }): void {
+  const cost = typeof spend.cost === "number" && Number.isFinite(spend.cost) && spend.cost > 0 ? spend.cost : 0;
+  const tokens =
+    typeof spend.tokens === "number" && Number.isFinite(spend.tokens) && spend.tokens > 0 ? Math.round(spend.tokens) : 0;
+  if (cost === 0 && tokens === 0) return;
+  const s = store();
+  const prev = s.bySource.get(source) ?? { cost: 0, tokens: 0 };
+  s.bySource.set(source, { cost: prev.cost + cost, tokens: prev.tokens + tokens });
+  for (const listener of s.listeners) {
+    try {
+      listener();
+    } catch {
+      // A footer that cannot redraw is not the child's problem.
+    }
+  }
+}
+
+/** Everything the children have spent this session, and which packages spent it. */
+export function childSpendTotal(): ChildSpend & { sources: string[] } {
+  const s = store();
+  let cost = 0;
+  let tokens = 0;
+  for (const spend of s.bySource.values()) {
+    cost += spend.cost;
+    tokens += spend.tokens;
+  }
+  return { cost, tokens, sources: [...s.bySource.keys()].sort() };
+}
+
+/** Start a new tally — a new session's children, not the last one's. */
+export function resetChildSpend(): void {
+  store().bySource.clear();
+}
+
+/** Be told after every addition; returns the unsubscribe. */
+export function onChildSpend(listener: () => void): () => void {
+  const s = store();
+  s.listeners.add(listener);
+  return () => {
+    s.listeners.delete(listener);
+  };
+}