@pi-archimedes/subagent 2.10.4 → 2.11.1

package/src/dispatch.ts

@@ -32,6 +32,7 @@
 
 import { dispatch, BridgeTransportError, BridgeCancelledError } from "@pi-archimedes/core/bridge";
 import { resolveModel } from "./spawn.js";
+import { resolveThinkingLevel } from "./thinking-validation.js";
 import type { ExecuteOptions } from "./execute.js";
 import type { SubagentProgress, SubagentResult } from "./types.js";
 
@@ -101,7 +102,9 @@ export function dispatchViaBridge(
     task: options.task,
     systemPrompt: options.agentConfig?.systemPrompt?.trim() || null,
     model: model ?? null,
-    thinking: options.agentConfig?.thinking ?? null,
+    // The same rule the fork path applies: a level pi's `--thinking` would warn
+    // about and drop is not handed to the runner either (`thinking-validation.ts`).
+    thinking: resolveThinkingLevel(options.agentConfig?.thinking).level ?? null,
     tools: options.agentConfig?.tools?.length ? options.agentConfig.tools : null,
   };
 
@@ -114,6 +117,11 @@ export function dispatchViaBridge(
       const progress: SubagentProgress = {
         agent: agentName,
         status: "completed",
+        // The Client ran the session and reported it finished; that is a
+        // completed run in this vocabulary. It has no stopReason to expose and
+        // no cancellation of its own to report — a local cancel settles below
+        // with BridgeCancelledError, which is a failure by contract.
+        outcome: "completed",
         task: options.task,
         currentTool: undefined,
         currentToolArgs: undefined,
@@ -134,6 +142,7 @@ export function dispatchViaBridge(
         agent: agentName,
         task: options.task,
         exitCode: 0,
+        outcome: "completed",
         usage: {
           input: res.metrics.inputTokens,
           output: res.metrics.outputTokens,
@@ -142,6 +151,9 @@ export function dispatchViaBridge(
           cost: res.metrics.cost,
           turns: 0,
         },
+        // The Client ran this as a session of its own and books its usage there;
+        // this session must not also report it. See `SubagentResult`.
+        usageAccountedElsewhere: true,
         model,
         finalOutput: res.output,
         error: undefined,
@@ -169,7 +181,13 @@ export function dispatchViaBridge(
       const isLocalCancel = err instanceof BridgeCancelledError;
       const errorMessage = isLocalCancel ? "cancelled" : err instanceof Error ? err.message : String(err);
       const durationMs = Date.now() - startTime;
-      return buildFailedResult(agentName, options.task, errorMessage, model, durationMs);
+      // Same ownership rule as the success path above: this settled from a
+      // desktop-side session (or a cancel of one), so its usage is that
+      // session's to report even if it ended badly.
+      return {
+        ...buildFailedResult(agentName, options.task, errorMessage, model, durationMs),
+        usageAccountedElsewhere: true,
+      };
     },
   );
 }

package/src/execute.test.ts

@@ -43,7 +43,9 @@ function activateBridge(socketPath: string): void {
   process.env.PI_ARCHIMEDES_BRIDGE_SESSION = "test-desktop-session";
   process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID = "12345";
   const onSpy = vi.fn();
-  registerBridge({ on: onSpy } as unknown as ExtensionAPI);
+  // The handle the relay subscribes on — inert here (these tests are about fork
+  // vs dispatch, not about the relay), but a real session always hands one over.
+  registerBridge({ on: onSpy, events: { emit: () => {}, on: () => () => {} } } as unknown as ExtensionAPI);
   const calls = onSpy.mock.calls as Array<[string, (e: unknown, ctx: unknown) => void]>;
   const startCall = calls.find((c) => c[0] === "session_start");
   expect(startCall).toBeTruthy();
@@ -75,6 +77,9 @@ function makeOptions(overrides: Partial<ExecuteOptions> = {}): ExecuteOptions {
     cwd: undefined,
     signal: undefined,
     onUpdate: undefined,
+    // These tests never fork, so the handle is inert — present because a real
+    // ExecuteOptions always carries one.
+    events: { emit: () => {}, on: () => () => {} },
     toolCallId: "tc-1",
     ...overrides,
   };
@@ -168,6 +173,9 @@ describe("executeSubagent (bridge branch)", () => {
     expect(result.error).toBe("cancelled");
     expect(result.progress!.status).toBe("failed");
     expect(result.progress!.error).toBe("cancelled");
+    // Bridge-mode bookkeeping: whatever the desktop did with the task, its
+    // session owns the usage — the parent must not fold it into its own totals.
+    expect(result.usageAccountedElsewhere).toBe(true);
     expect(spawnSpy).not.toHaveBeenCalled();
     // Exactly ONE update: the final-failure progress (no "dispatched"
     // placeholder — a cancelled task does not claim it was dispatched).

package/src/execute.ts

@@ -1,8 +1,8 @@
 import { getBridge } from "@pi-archimedes/core/bridge";
+import type { EventBus } from "@earendil-works/pi-coding-agent";
 import { spawnSubagent, resolveModel } from "./spawn.js";
 import { dispatchViaBridge, buildFailedResult } from "./dispatch.js";
 import { streamEvents } from "./stream.js";
-import { emitCostUpdate } from "./cost.js";
 import type { AgentConfig } from "./agents.js";
 import type { SubagentProgress, SubagentResult } from "./types.js";
 
@@ -15,6 +15,10 @@ export interface ExecuteOptions {
   cwd: string | undefined;
   signal: AbortSignal | undefined;
   onUpdate: ((progress: SubagentProgress) => void) | undefined;
+  /** The parent's host handle (`pi.events`) — forwarded to the ask bridge and to
+   *  the todo announcements in `streamEvents`. Neither is an extension, so
+   *  neither can reach a handle of its own. */
+  events: EventBus;
   /** The subagent tool-call id (the tool's `_id`) — rides the dispatch frame
    *  for Client correlation; `undefined` → the frame's `toolCallId` is absent.
    *  In `executeParallel` all N tasks share the single subagent tool-call's id. */
@@ -49,7 +53,11 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
     // so executeParallel's progress slot updates from the pending placeholder
     // to "failed" instead of a stale "Starting...".
     if (options.signal?.aborted) {
-      const result = buildFailedResult(agentName, options.task, "cancelled", model, Date.now() - startTime);
+      const result = {
+        ...buildFailedResult(agentName, options.task, "cancelled", model, Date.now() - startTime),
+        // Bridge mode: any usage this run ever had belongs to a desktop session.
+        usageAccountedElsewhere: true,
+      };
       options.onUpdate?.(result.progress!);
       return result;
     }
@@ -81,23 +89,21 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
     if (!("fallback" in outcome)) {
       // Bridge used (success or a response-carrying error, incl. the terminal
       // "cancelled" frame — the desktop is alive, its outcome is authoritative):
-      // return it — NO fork fallback, and NO emitCostUpdate here — the PARENT
-      // never pushes the subagent's usage on the PARENT's bus (the fork-delta
-      // semantics: only the fork path reports a child's usage, source
-      // `subagent:<name>`). The subagent process self-emits its own usage to
-      // its OWN bridge (the core self-usage emitter,
-      // `subagent-metrics-cost-push` Task 1) — a different bus, a different
-      // session; no double-count.
+      // return it, with no cost report of its own. The PARENT never reports a
+      // child's usage for a run it did not perform: the subagent process emits
+      // its OWN usage to its OWN bridge (the core self-usage emitter), which is a
+      // different session's total. Every result `dispatchViaBridge` settles
+      // carries `usageAccountedElsewhere`, which is how the tool knows to leave
+      // it off the tool result — pi folds that `usage` into THIS session's
+      // totals, so copying it across would bill the parent twice. The fork path
+      // below does report, through the tool result's native `usage`.
       return outcome;
     }
     // { fallback: true } — unreachable bridge: fall through to the fork path.
   }
 
-  // Track previously emitted values to only emit deltas
-  let lastEmittedInput = 0;
-  let lastEmittedOutput = 0;
-  let lastEmittedCost = 0;
-
+  // Progress is passed straight through: cost is reported once, on the tool
+  // result's native `usage`, so there is no delta bookkeeping left to do here.
   try {
     const child = spawnSubagent({
       task: options.task,
@@ -106,26 +112,14 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
       cwd: options.cwd,
       signal: options.signal,
       agent: options.agentConfig,
+      events: options.events,
     });
 
     const result = await streamEvents(child, {
       agent: agentName,
       task: options.task,
+      events: options.events,
       onProgress: (progress: SubagentProgress) => {
-        // Emit only deltas to avoid double-counting in CostAccumulator
-        const deltaInput = progress.inputTokens - lastEmittedInput;
-        const deltaOutput = progress.outputTokens - lastEmittedOutput;
-        const deltaCost = progress.cost - lastEmittedCost;
-        if (deltaInput > 0 || deltaOutput > 0 || deltaCost > 0) {
-          emitCostUpdate(agentName, {
-            inputTokens: deltaInput,
-            outputTokens: deltaOutput,
-            cost: deltaCost,
-          });
-          lastEmittedInput = progress.inputTokens;
-          lastEmittedOutput = progress.outputTokens;
-          lastEmittedCost = progress.cost;
-        }
         options.onUpdate?.(progress);
       },
     });
@@ -142,7 +136,8 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
           // synthesize one so the parallel renderer stays aligned with results.
           {
             agent: agentName,
-            status: result.exitCode === 0 ? "completed" : "failed",
+            status: result.outcome || result.exitCode === 0 ? "completed" : "failed",
+            ...(result.outcome ? { outcome: result.outcome } : {}),
             task: options.task,
             currentTool: undefined,
             currentToolArgs: undefined,
@@ -187,6 +182,7 @@ export async function executeParallel(options: {
   tasks: Array<{ agent: string | undefined; agentConfig: AgentConfig | undefined; task: string; model: string | undefined; activeModel: string | undefined; cwd: string | undefined; toolCallId?: string }>;
   signal: AbortSignal | undefined;
   onUpdate: ((progress: SubagentProgress[]) => void) | undefined;
+  events: EventBus;
 }): Promise<SubagentResult[]> {
   // Pre-fill one pending slot per task, keyed by task index (NOT agent name).
   // This keeps all N lines stacked from t=0 in stable task order, with no
@@ -218,6 +214,7 @@ export async function executeParallel(options: {
       executeSubagent({
         ...taskDef,
         signal: options.signal,
+        events: options.events,
         onUpdate: (progress: SubagentProgress) => {
           // Store latest progress in this task's stable slot (by index).
           latestProgress[index] = progress;