@pi-archimedes/subagent 2.10.4 → 2.11.0

package/src/compact.test.ts

@@ -1,29 +1,43 @@
 import { describe, it, expect, vi } from "vitest";
 import * as fc from "fast-check";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { buildActivityLine, renderCompactSingle, renderCompactParallel } from "./compact.js";
+import { RowBlock, type RowSegment, type RowSink } from "./row-block.js";
 import type { SubagentResult, SubagentProgress, SubagentDetails, SubagentToolCall } from "./types.js";
 
-// ── Mocks ───────────────────────────────────────────────────────────────────
-
-vi.mock("@earendil-works/pi-tui", () => {
-  class MockTextInner {
-    private _content = "";
+// ── The row sink the builders draw into ───────────────────────────────────────────────────────────────────
+
+/**
+ * A recording `RowSink`, standing in for the `RowBlock` `render.ts` hands these
+ * builders. Deliberately not a `RowBlock`, and deliberately no mock of pi-tui's
+ * `Text`: `row-block.ts` takes `sliceByColumn` / `wrapTextWithAnsi` /
+ * `visibleWidth` from that module, so mocking it to fake a sink would quietly
+ * break the row code the tests are about. What the segments draw is asserted
+ * with a real `RowBlock` below.
+ */
+class RecordingSink implements RowSink {
+  private content = "";
+  private segments: RowSegment[] | undefined = undefined;
+
+  setText(content: string): void {
+    this.content = content;
+    this.segments = undefined;
+  }
 
-    setText(content: string): void {
-      this._content = content;
-    }
+  /** Mirrors `RowBlock.setSegments`: the joined text is what a row draws. */
+  setSegments(segments: RowSegment[]): void {
+    this.segments = segments;
+    this.content = segments.map((s) => s.text).join("\n");
+  }
 
-    getContent(): string {
-      return this._content;
-    }
+  getContent(): string {
+    return this.content;
   }
-  return {
-    Text: MockTextInner,
-  };
-});
 
-// Re-import MockText for use in tests (same class as the mock)
-import { Text as MockText } from "@earendil-works/pi-tui";
+  getSegments(): RowSegment[] | undefined {
+    return this.segments;
+  }
+}
 
 // Type-safe helper: ActivityData with all optional fields for test convenience
 // ActivityData is defined in compact.ts — reconstruct the shape here
@@ -236,23 +250,23 @@ describe("renderCompactSingle", () => {
     };
   }
 
-  it("calls setText with expected output structure for completed agent", () => {
+  it("hands the block to the row sink with the expected structure for a completed agent", () => {
     const { theme } = makeMockTheme();
-    const text = new MockText();
+    const text = new RecordingSink();
     const result = makeResult({ exitCode: 0 });
     const context = { state: {}, invalidate: vi.fn() };
 
     renderCompactSingle(text, result, undefined, theme, context);
 
-    const output = (text as unknown as { getContent(): string }).getContent();
+    const output = text.getContent();
     expect(output).toContain("test-agent");
     expect(output).toContain("do something");
     expect(output).toContain("✓ Done");
   });
 
-  it("calls setText with expected output structure for running agent", () => {
+  it("hands the block to the row sink with the expected structure for a running agent", () => {
     const { theme } = makeMockTheme();
-    const text = new MockText();
+    const text = new RecordingSink();
     const result = makeResult({ exitCode: 1 });
     const progress: SubagentProgress = {
       agent: "test-agent",
@@ -277,20 +291,57 @@ describe("renderCompactSingle", () => {
 
     renderCompactSingle(text, result, progress, theme, context);
 
-    const output = (text as unknown as { getContent(): string }).getContent();
+    const output = text.getContent();
     expect(output).toContain("test-agent");
     expect(output).toContain("read");
   });
 
   it("returns the text instance", () => {
     const { theme } = makeMockTheme();
-    const text = new MockText();
+    const text = new RecordingSink();
     const result = makeResult();
     const context = { state: {}, invalidate: vi.fn() };
 
     const returned = renderCompactSingle(text, result, undefined, theme, context);
     expect(returned).toBe(text);
   });
+
+  // A task is free text and an error is usually stderr, so both arrive with
+  // newlines in them. The collapsed view is three rows per agent, so each field
+  // has to reach the row layer as its own `row` segment carrying the whole text:
+  // the row then cuts itself at the first newline, at the width it is drawn at.
+  // Handed over as one joined string, every newline would become a row and a
+  // failed child's stderr would open the collapsed block.
+  it("hands over three row segments carrying whole fields, so newlines reach the row cut", () => {
+    const { theme } = makeMockTheme();
+    const text = new RecordingSink();
+    const result = makeResult({
+      task: "Review the change\nRun the full suite",
+      exitCode: 1,
+      error: "spawn failed\ncommand not found: pnpm",
+    });
+
+    renderCompactSingle(text, result, undefined, theme, { state: {}, invalidate: vi.fn() });
+
+    const segments = text.getSegments();
+    expect(segments?.map((s) => s.kind)).toEqual(["row", "row", "row"]);
+    // Fields arrive uncapped — the row decides how much of each one fits.
+    expect(segments?.[0]?.text).toContain("Run the full suite");
+    expect(segments?.[2]?.text).toContain("command not found: pnpm");
+
+    // And drawn by the real row component, that is three rows: the newline is a
+    // boundary inside the row, not a new row.
+    const rows = new RowBlock();
+    rows.setSegments(segments!);
+    const drawn = rows.render(80).map((l) => stripTerminalSequences(l).replace(/\s+$/, ""));
+    // Three rows, and the two fields that carry newlines end in the cut marker
+    // rather than spilling into rows of their own. (The mock theme marks its
+    // spans with markers of its own, so match the tail of each row.)
+    expect(drawn).toHaveLength(3);
+    expect(drawn[0]).toMatch(/: Review the change\.\.\.$/);
+    expect(drawn[1]).toContain("gpt-4");
+    expect(drawn[2]).toMatch(/✗ spawn failed\.\.\.$/);
+  });
 });
 
 // ── renderCompactParallel ──────────────────────────────────────────────────
@@ -330,13 +381,13 @@ describe("renderCompactParallel", () => {
 
   it("renders a full 3-line block per agent (parity with single view)", () => {
     const { theme } = makeMockTheme();
-    const text = new MockText();
+    const text = new RecordingSink();
     const details = makeDetails();
     const context = { state: {}, invalidate: vi.fn() };
 
     renderCompactParallel(text, details, theme, context);
 
-    const output = (text as unknown as { getContent(): string }).getContent();
+    const output = text.getContent();
     expect(output).toContain("agent-a");
     expect(output).toContain("agent-b");
     // Each agent is a 3-line block (label / model+stats / activity); with two
@@ -355,7 +406,7 @@ describe("renderCompactParallel", () => {
 
   it("returns the text instance", () => {
     const { theme } = makeMockTheme();
-    const text = new MockText();
+    const text = new RecordingSink();
     const details = makeDetails();
     const context = { state: {}, invalidate: vi.fn() };
 
@@ -366,83 +417,111 @@ describe("renderCompactParallel", () => {
 
 // ── Property tests (fast-check) ────────────────────────────────────────────
 
-describe("buildActivityLine property tests", () => {
-  it("truncated error never exceeds truncLine limit of 80 chars", () => {
+// The cap property tests that used to live here pinned "≤ 60 / ≤ 80 characters".
+// That rule is gone: rows are cut at the width pi renders them at, which is
+// audited against the real renderers in `tool-row.width-audit.test.ts`, and the
+// cutting itself (cells, colour, newlines) in `row-block.test.ts`. What these
+// builders owe that audit is the *whole* content, so the row — not the builder —
+// decides where the line ends.
+describe("buildActivityLine hands its row whole content (no character cap)", () => {
+  /** Remove the mock theme's `[token]`/`[/token]` markers (fixtures exclude `[`). */
+  const stripMarkers = (s: string) => s.replace(/\[\/?(?:muted|running|success|error|dim|accent)\]/g, "");
+
+  it("carries an error far longer than the old 80-character limit", () => {
     fc.assert(
       fc.property(
-        fc.string({ minLength: 1, maxLength: 500 }),
+        fc.string({ minLength: 81, maxLength: 500 }).filter((s) => !s.includes("[")),
         (error) => {
           const { theme } = makeMockTheme();
           const result = buildActivityLine(
             activityData({ error, status: "running" }),
             theme,
           );
-          // Strip the "✗ " prefix and ANSI tags to get the actual truncated text
-          const withoutPrefix = result.replace(/^\[error\]✗ /, "");
-          // The visible text (without closing ANSI tag) should be <= 80
-          const visibleText = withoutPrefix.replace(/\[\/error\]$/, "");
-          expect(visibleText.length).toBeLessThanOrEqual(80);
+          expect(stripMarkers(result)).toBe("✗ " + error);
         },
       ),
     );
   });
 
-  it("truncated argsPreview never exceeds truncLine limit of 60 chars", () => {
+  it("carries args far longer than the old 60-character limit", () => {
     fc.assert(
       fc.property(
-        fc.string({ minLength: 1, maxLength: 20 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|")),
-        fc.string({ minLength: 1, maxLength: 500 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|")),
+        fc.string({ minLength: 1, maxLength: 20 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|") && !s.includes("[")),
+        fc.string({ minLength: 61, maxLength: 500 }).filter((s) => !s.includes(": ") && !s.includes("\n") && !s.includes("|") && !s.includes("[")),
         (currentTool, currentToolArgs) => {
           const { theme } = makeMockTheme();
           const result = buildActivityLine(
             activityData({ status: "running", currentTool, currentToolArgs }),
             theme,
           );
-          // Extract the args portion after ": "
-          const argsMatch = result.match(/: (.+?)(?:\s\|.*|\[\/dim\].*)?$/);
-          expect(argsMatch).not.toBeNull();
-          const argsText = argsMatch![1]!.replace(/\[\/dim\]$/, "").replace(/\[dim\]/, "");
-          expect(argsText.length).toBeLessThanOrEqual(60);
+          const visible = stripMarkers(result);
+          expect(visible.includes(currentToolArgs)).toBe(true);
         },
       ),
     );
   });
 
-  it("truncated finalOutput first line never exceeds truncLine limit of 80 chars", () => {
+  it("carries the first line of output whole, and never a second line", () => {
     fc.assert(
       fc.property(
-        fc.string({ minLength: 1, maxLength: 500 }),
-        (finalOutput) => {
+        fc.string({ minLength: 81, maxLength: 500 }).filter((s) => !s.includes("\n") && !s.includes("[")),
+        (firstLine) => {
           const { theme } = makeMockTheme();
           const result = buildActivityLine(
-            activityData({ status: "running", finalOutput }),
+            activityData({ status: "running", finalOutput: `${firstLine}\nsecond line\nthird` }),
             theme,
           );
-          // Strip ANSI tags to get visible text
-          const visible = result.replace(/\[muted\]/g, "").replace(/\[\/muted\]/g, "");
-          // The visible text after the running glyph "▸ " should be <= 80
-          const afterArrow = visible.replace(/^▸ /, "");
-          expect(afterArrow.length).toBeLessThanOrEqual(80);
+          const visible = stripMarkers(result);
+          expect(visible).toBe("▸ " + firstLine);
         },
       ),
     );
   });
 
-  it("truncated string toolCall never exceeds truncLine limit of 60 chars", () => {
+  it("carries a string tool call far longer than the old 60-character limit", () => {
     fc.assert(
       fc.property(
-        fc.string({ minLength: 1, maxLength: 500 }),
+        fc.string({ minLength: 61, maxLength: 500 }).filter((s) => !s.includes("\n") && !s.includes("[")),
         (toolCallStr) => {
           const { theme } = makeMockTheme();
           const result = buildActivityLine(
             activityData({ status: "running", toolCalls: [toolCallStr] }),
             theme,
           );
-          const visible = result.replace(/\[dim\]/g, "").replace(/\[\/dim\]/g, "");
-          const afterArrow = visible.replace(/^▸ /, "");
-          expect(afterArrow.length).toBeLessThanOrEqual(60);
+          const visible = stripMarkers(result);
+          expect(visible.includes(toolCallStr)).toBe(true);
         },
       ),
     );
   });
 });
+
+describe("compact activity line: run outcomes", () => {
+  it("shows Truncated for a cut-off answer, in warning colour", () => {
+    const { theme } = makeMockTheme();
+    const line = buildActivityLine(
+      activityData({ status: "completed", outcome: "truncated" } as never),
+      theme,
+    );
+    expect(line).toMatch(/truncated/i);
+    expect(line).not.toMatch(/Done/);
+  });
+
+  it("shows Aborted for a cancelled run", () => {
+    const { theme } = makeMockTheme();
+    const line = buildActivityLine(
+      activityData({ status: "completed", outcome: "aborted" } as never),
+      theme,
+    );
+    expect(line).toMatch(/aborted/i);
+  });
+
+  it("shows Done for a completed run, unchanged", () => {
+    const { theme } = makeMockTheme();
+    const line = buildActivityLine(
+      activityData({ status: "completed", outcome: "completed" } as never),
+      theme,
+    );
+    expect(line).toContain("✓ Done");
+  });
+});

package/src/compact.ts

@@ -1,19 +1,28 @@
-import { Text } from "@earendil-works/pi-tui";
-import type { SubagentDetails, SubagentProgress, SubagentResult, SubagentToolCall, SubagentToolResult } from "./types.js";
-import { formatDuration, truncLine, buildStatsLine, buildAgentLabel } from "./format.js";
+import type { RunOutcome, SubagentDetails, SubagentProgress, SubagentResult, SubagentToolCall, SubagentToolResult } from "./types.js";
+import { formatDuration, buildStatsLine, buildAgentLabel, buildOutcomeLine } from "./format.js";
+import { row, type RowSegment, type RowSink } from "./row-block.js";
 import { renderToolCallLine } from "@pi-archimedes/core/tool-render";
 
 type Theme = { fg: (token: string, text: string) => string; bold: (text: string) => string };
 type RenderContext = { state: Record<string, unknown>; invalidate: () => void };
 
+// Re-exported so callers and tests describe the sink the same way the builders do.
+export type { RowSink };
+
 // ── Activity line builder ───────────────────────────────────────────────────
 
+// The builders below hand back whole content, never a fixed-length preview: the
+// row each line lands on is cut at the width pi renders at (`RowBlock`,
+// `row-block.ts`), so a long task or error fills the frame instead of stopping at
+// 60 or 80 characters.
 interface ActivityData {
   currentTool: string | undefined;
   currentToolArgs: string | undefined;
   currentToolStartedAt: number | undefined;
   finalOutput: string | undefined;
   status: "running" | "completed" | "failed" | undefined;
+  /** The *Run outcome*, when the run reached one — shown instead of Done/Failed. */
+  outcome?: RunOutcome | undefined;
   error: string | undefined;
   toolCalls?: (SubagentToolCall | string)[] | undefined;
 }
@@ -23,7 +32,15 @@ export function buildActivityLine(
   theme: Theme,
 ): string {
   if (data.error) {
-    return theme.fg("error", "✗ " + truncLine(data.error, 80));
+    return theme.fg("error", "✗ " + data.error);
+  }
+
+  // A finished run reports its outcome: Done / Truncated / Aborted. Truncated and
+  // Aborted are not the old "Failed" — the answer may be perfectly good, just
+  // partial, and a cancelled run was cancelled on purpose.
+  if (data.outcome) {
+    const line = buildOutcomeLine({ outcome: data.outcome, error: undefined }, theme);
+    if (line) return line;
   }
 
   // Finished subagents always show their final status — never a stale
@@ -38,9 +55,7 @@ export function buildActivityLine(
 
   // Running: show the current tool with the running glyph ▸ + live duration.
   if (data.currentTool) {
-    const argsPreview = data.currentToolArgs
-      ? truncLine(data.currentToolArgs, 60)
-      : "";
+    const argsPreview = data.currentToolArgs ?? "";
     const durationPart = data.currentToolStartedAt
       ? " | " + formatDuration(Date.now() - data.currentToolStartedAt)
       : "";
@@ -54,12 +69,10 @@ export function buildActivityLine(
     const lastCall = data.toolCalls[data.toolCalls.length - 1];
     if (lastCall) {
       if (typeof lastCall === "string") {
-        return renderToolCallLine("success", truncLine(lastCall, 60), "", theme);
+        return renderToolCallLine("success", lastCall, "", theme);
       }
       const status = lastCall.error ? "error" : "success";
-      const suffix = lastCall.argsPreview
-        ? ": " + truncLine(lastCall.argsPreview, 60)
-        : "";
+      const suffix = lastCall.argsPreview ? ": " + lastCall.argsPreview : "";
       return renderToolCallLine(status, lastCall.name, suffix, theme);
     }
   }
@@ -67,7 +80,7 @@ export function buildActivityLine(
   // Running, no tool history: show first line of streamed output (▸, muted).
   if (data.finalOutput) {
     const firstLine = data.finalOutput.split("\n")[0] ?? "";
-    return renderToolCallLine("running", truncLine(firstLine, 80), "", theme);
+    return renderToolCallLine("running", firstLine, "", theme);
   }
 
   // Running, no info yet
@@ -96,34 +109,38 @@ type AgentBlockData = {
 //   <agent>: <task>
 //   <model> · <stats>
 //   <activity>          (status lives here — "✓ Done" / "✗ Failed" / ▸ tool)
-function buildAgentBlock(data: AgentBlockData, theme: Theme): string {
+// Each field is handed over as its own `row` segment, so it stays one row of the
+// rendered frame however wide the frame is. Handing the three over as one string
+// would not do that: a task is free text and an error is usually stderr, so both
+// carry newlines, and `setText` reads every newline as the start of a new row —
+// which would push a failed child's stack trace open across the collapsed block.
+// `truncateRow` cuts the row at the first newline and marks it with the ellipsis,
+// which is the boundary the old character-based `truncLine` enforced.
+function buildAgentBlock(data: AgentBlockData, theme: Theme): RowSegment[] {
   const statsLine = buildStatsLine(data.statsData, theme);
   const modelLabel = data.model ? theme.fg("accent", data.model) : "";
   const activityLine = buildActivityLine(data.activity, theme);
   const label = buildAgentLabel(data.agentName, data.task, theme);
 
-  return (
-    label +
-    "\n" +
-    [modelLabel, statsLine].filter(Boolean).join(" ") +
-    "\n" +
-    activityLine
-  );
+  return [
+    row(label),
+    row([modelLabel, statsLine].filter(Boolean).join(" ")),
+    row(activityLine),
+  ];
 }
 
 export function renderCompactSingle(
-  text: Text,
+  text: RowSink,
   result: SubagentResult,
   progress: SubagentProgress | undefined,
   theme: Theme,
   context: RenderContext,
-): Text {
+): RowSink {
   // agentName sourced from result; defaults to "subagent"
   const agentName = result.agent ?? "subagent";
   const summary = result.progressSummary ?? { toolCount: 0, tokens: 0, durationMs: 0 };
   const isRunning = progress?.status === "running";
   const status = isRunning ? "running" : (result.exitCode === 0 ? "completed" : "failed");
-
   // Track start time for live duration
   const timeKey = "_subagentStartTime_" + agentName;
   if (isRunning && context.state[timeKey] === undefined) {
@@ -135,7 +152,7 @@ export function renderCompactSingle(
     ? Date.now() - (context.state[timeKey] as number)
     : summary.durationMs;
 
-  const output = buildAgentBlock(
+  const block = buildAgentBlock(
     {
       agentName,
       task: result.task,
@@ -153,6 +170,7 @@ export function renderCompactSingle(
         currentToolStartedAt: progress?.currentToolStartedAt,
         finalOutput: result.finalOutput,
         status: isRunning ? "running" : status,
+        outcome: isRunning ? undefined : result.outcome,
         error: result.error,
         toolCalls: progress?.toolCalls,
       },
@@ -160,19 +178,19 @@ export function renderCompactSingle(
     theme,
   );
 
-  text.setText(output);
+  text.setSegments(block);
   return text;
 }
 
 // ── Compact parallel agents ─────────────────────────────────────────────────
 
 export function renderCompactParallel(
-  text: Text,
+  text: RowSink,
   details: SubagentDetails,
   theme: Theme,
   context: RenderContext,
-): Text {
-  const lines = details.results.map((result, i) => {
+): RowSink {
+  const blocks = details.results.map((result, i) => {
     const progress = details.progress?.[i];
     const agentName = result.agent ?? "subagent";
     const summary = result.progressSummary ?? { toolCount: 0, tokens: 0, durationMs: 0 };
@@ -203,6 +221,7 @@ export function renderCompactParallel(
           currentToolStartedAt: progress?.currentToolStartedAt,
           finalOutput: result.finalOutput,
           status,
+          outcome: result.outcome,
           error: result.error,
           toolCalls: progress?.toolCalls,
         },
@@ -211,18 +230,18 @@ export function renderCompactParallel(
     );
   });
 
-  text.setText(lines.join("\n"));
+  text.setSegments(blocks.flat());
   return text;
 }
 
 // ── Compact streaming progress ──────────────────────────────────────────────
 
 export function renderCompactProgress(
-  text: Text,
+  text: RowSink,
   progress: SubagentProgress,
   theme: Theme,
   context: RenderContext,
-): Text {
+): RowSink {
   // agentName sourced from progress; defaults to "subagent"
   const agentName = progress.agent ?? "subagent";
   const status = progress.status;
@@ -237,7 +256,7 @@ export function renderCompactProgress(
     ? Date.now() - (context.state[timeKey] as number)
     : progress.durationMs;
 
-  const output = buildAgentBlock(
+  const block = buildAgentBlock(
     {
       agentName,
       task: progress.task,
@@ -255,6 +274,7 @@ export function renderCompactProgress(
         currentToolStartedAt: progress.currentToolStartedAt,
         finalOutput: undefined,
         status,
+        outcome: status === "running" ? undefined : progress.outcome,
         error: progress.error,
         toolCalls: progress.toolCalls,
       },
@@ -262,19 +282,19 @@ export function renderCompactProgress(
     theme,
   );
 
-  text.setText(output);
+  text.setSegments(block);
   return text;
 }
 
 // ── Compact parallel streaming progress ─────────────────────────────────────
 
 export function renderCompactParallelProgress(
-  text: Text,
+  text: RowSink,
   details: SubagentDetails,
   theme: Theme,
   context: RenderContext,
-): Text {
-  const lines = (details.progress ?? []).map((progress) => {
+): RowSink {
+  const blocks = (details.progress ?? []).map((progress) => {
     const agentName = progress.agent ?? "subagent";
     const status = progress.status;
 
@@ -304,6 +324,6 @@ export function renderCompactParallelProgress(
     );
   });
 
-  text.setText(lines.join("\n"));
+  text.setSegments(blocks.flat());
   return text;
 }

package/src/dispatch.test.ts

@@ -42,7 +42,9 @@ function activateBridge(socketPath: string): void {
   process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID = "12345";
   // registerBridge evaluates isBridgeMode at session_start — fire the handler.
   const onSpy = vi.fn();
-  registerBridge({ on: onSpy } as unknown as ExtensionAPI);
+  // The handle the relay subscribes on. Inert here: these tests are about the
+  // socket frames the dispatch sends, not about the relay.
+  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();
@@ -73,6 +75,9 @@ function makeOptions(overrides: Partial<ExecuteOptions> = {}): ExecuteOptions {
     activeModel: "active-model",
     cwd: undefined,
     signal: undefined,
+    // Inert handle: a bridge-dispatched run never touches the event bus here, but
+    // ExecuteOptions carries one because the fork path needs it.
+    events: { emit: () => {}, on: () => () => {} },
     onUpdate: undefined,
     toolCallId: "tc-1",
     ...overrides,
@@ -290,3 +295,70 @@ describe("resolveModel", () => {
     expect(resolveModel({ model: undefined, activeModel: undefined, agent: undefined })).toBeUndefined();
   });
 });
+
+// ── Every bridge-settled result belongs to the desktop's session for cost ──
+
+describe("dispatchViaBridge: cost ownership", () => {
+  // The desktop runs the task as a session of its own and books its usage
+  // there. `usage` still rides along for display, but the result has to say it
+  // was accounted for elsewhere, or the parent folds the same money into its own
+  // session totals through the tool result (ADR 0028 counts cost exactly once).
+  // Only the `{ fallback: true }` corner is different — there the fork path
+  // re-runs the task and the tool result IS the cost report.
+  it("marks a successful bridge run", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startFakeDesktop(sockPath, (msg) => ({
+      v: 1,
+      type: "response",
+      id: msg.id,
+      result: { output: "done", metrics: { inputTokens: 1, outputTokens: 2, cost: 0.01, durationMs: 5 } },
+    }));
+    activateBridge(sockPath);
+
+    const result = (await dispatchViaBridge(makeOptions(), undefined, "tc-1")) as SubagentResult;
+    expect(result.usageAccountedElsewhere).toBe(true);
+    // The metrics are still there for the details view.
+    expect(result.usage.cost).toBe(0.01);
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("marks a bridge run the desktop reported as failed", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startFakeDesktop(sockPath, (msg) => ({
+      v: 1,
+      type: "response",
+      id: msg.id,
+      error: "worker runtime unavailable",
+    }));
+    activateBridge(sockPath);
+
+    const result = (await dispatchViaBridge(makeOptions(), undefined, "tc-1")) as SubagentResult;
+    expect(result.error).toBe("worker runtime unavailable");
+    expect(result.usageAccountedElsewhere).toBe(true);
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+
+  it("marks a run cancelled locally, and never claims the fork path's ownership", async () => {
+    const sockPath = tempSocketPath();
+    const server = await startFakeDesktop(sockPath, () => {
+      /* accept but never respond */
+    });
+    activateBridge(sockPath);
+
+    const controller = new AbortController();
+    const pending = dispatchViaBridge(makeOptions(), controller.signal, "tc-1");
+    await new Promise((r) => setTimeout(r, 50));
+    controller.abort();
+
+    const result = (await pending) as SubagentResult;
+    expect(result.error).toBe("cancelled");
+    expect(result.usageAccountedElsewhere).toBe(true);
+
+    server.close();
+    try { fs.unlinkSync(sockPath); } catch { /* already gone */ }
+  });
+});