@syengup/friday-channel-next 0.1.30 → 0.1.37

package/src/e2e/subagent-smoke.e2e.test.ts

@@ -12,10 +12,7 @@ import {
   ensureSubagentFromSpawnTool,
   resetForTest as resetSubagentRegistry,
 } from "../agent/subagent-registry.js";
-import {
-  forwardAgentEventRaw,
-  registerFridaySessionDeviceMapping,
-} from "../friday-session.js";
+import { forwardAgentEventRaw, registerFridaySessionDeviceMapping } from "../friday-session.js";
 import { sseEmitter } from "../sse/emitter.js";
 
 const deviceId = "IOS-DEVICE-AAAA-BBBB-CCCC-DDDD";
@@ -37,17 +34,22 @@ function describeFrame(frame: { event?: string; data?: Record<string, unknown> }
     case "connected":
       return `connected  deviceId=${data.deviceId} lastSeq=${data.lastSeq}`;
     case "subagent": {
-      const extra = data.phase === "ended" ? ` outcome=${data.outcome} error=${data.error ?? "-"}` : "";
+      const extra =
+        data.phase === "ended" ? ` outcome=${data.outcome} error=${data.error ?? "-"}` : "";
       return `subagent   phase=${data.phase} runId=${data.runId ?? "(pending)"} label=${data.label ?? "-"} parentRunId=${data.parentRunId ?? "-"} depth=${data.depth}${extra}`;
     }
     case "agent": {
       const sub = data.subagent as Record<string, unknown> | undefined;
-      const subTag = sub ? ` SUB="agent:${sub.label ?? "?"}" depth=${sub.depth} parent=${sub.parentRunId ?? "-"}` : " (main)";
+      const subTag = sub
+        ? ` SUB="agent:${sub.label ?? "?"}" depth=${sub.depth} parent=${sub.parentRunId ?? "-"}`
+        : " (main)";
       const inner = (data.data ?? {}) as Record<string, unknown>;
       let detail = "";
-      if (data.stream === "thinking") detail = ` thinking: "${String(inner.text ?? "").slice(0, 50)}"`;
+      if (data.stream === "thinking")
+        detail = ` thinking: "${String(inner.text ?? "").slice(0, 50)}"`;
       else if (data.stream === "tool") detail = ` tool=${inner.name ?? "?"} phase=${inner.phase}`;
-      else if (data.stream === "assistant") detail = ` text="${String(inner.text ?? inner.phase ?? "")}"`;
+      else if (data.stream === "assistant")
+        detail = ` text="${String(inner.text ?? inner.phase ?? "")}"`;
       else if (data.stream === "lifecycle") detail = ` phase=${inner.phase}`;
       return `agent      stream=${data.stream} runId=${String(data.runId).slice(0, 30)}…${subTag}${detail}`;
     }
@@ -72,8 +74,11 @@ describe("subagent smoke", () => {
 
     // ── Main run lifecycle start ──────────────────────────
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 1, stream: "lifecycle",
-      sessionKey: mainSessionKey, data: { phase: "start" },
+      runId: mainRunId,
+      seq: 1,
+      stream: "lifecycle",
+      sessionKey: mainSessionKey,
+      data: { phase: "start" },
     });
 
     // ── Subagent A: tool.start (spawning) ─────────────────
@@ -82,10 +87,13 @@ describe("subagent smoke", () => {
     const compoundA = `announce:v1:${childKeyA}:${bareA}`;
 
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 2, stream: "tool",
+      runId: mainRunId,
+      seq: 2,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "start", name: "sessions_spawn",
+        phase: "start",
+        name: "sessions_spawn",
         toolCallId: "call_a",
         args: { taskName: "code-reviewer" },
       },
@@ -93,10 +101,14 @@ describe("subagent smoke", () => {
 
     // ── Subagent A: tool.result (spawned) ─────────────────
     forwardAgentEventRaw({
-      runId: mainRunId, seq: 3, stream: "tool",
+      runId: mainRunId,
+      seq: 3,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "result", name: "sessions_spawn", toolCallId: "call_1",
+        phase: "result",
+        name: "sessions_spawn",
+        toolCallId: "call_1",
         meta: "code-reviewer",
         result: { details: spawnResult(childKeyA, bareA, "code-reviewer") },
       },
@@ -105,26 +117,41 @@ describe("subagent smoke", () => {
 
     // ── Subagent A: agent events (subagent's own sessionKey) ─
     forwardAgentEventRaw({
-      runId: compoundA, seq: 1, stream: "lifecycle",
-      data: { phase: "start" }, sessionKey: childKeyA,
+      runId: compoundA,
+      seq: 1,
+      stream: "lifecycle",
+      data: { phase: "start" },
+      sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 2, stream: "thinking",
-      data: { text: "Let me review the code for issues…", delta: "Let me review the code for issues…", reasoningPrefixChars: 0 },
+      runId: compoundA,
+      seq: 2,
+      stream: "thinking",
+      data: {
+        text: "Let me review the code for issues…",
+        delta: "Let me review the code for issues…",
+        reasoningPrefixChars: 0,
+      },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 3, stream: "tool",
+      runId: compoundA,
+      seq: 3,
+      stream: "tool",
       data: { phase: "start", name: "read", args: { path: "src/app.ts" } },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 4, stream: "tool",
+      runId: compoundA,
+      seq: 4,
+      stream: "tool",
       data: { phase: "result", name: "read", result: "file contents…" },
       sessionKey: childKeyA,
     });
     forwardAgentEventRaw({
-      runId: compoundA, seq: 5, stream: "assistant",
+      runId: compoundA,
+      seq: 5,
+      stream: "assistant",
       data: { phase: "delta", text: "Found 3 issues in the code." },
       sessionKey: childKeyA,
     });
@@ -135,20 +162,27 @@ describe("subagent smoke", () => {
     const compoundB = `announce:v1:${childKeyB}:${bareB}`;
 
     forwardAgentEventRaw({
-      runId: compoundA, seq: 7, stream: "tool",
+      runId: compoundA,
+      seq: 7,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "start", name: "sessions_spawn",
+        phase: "start",
+        name: "sessions_spawn",
         toolCallId: "call_b",
         args: { taskName: "lint" },
       },
     });
 
     forwardAgentEventRaw({
-      runId: compoundA, seq: 8, stream: "tool",
+      runId: compoundA,
+      seq: 8,
+      stream: "tool",
       sessionKey: mainSessionKey,
       data: {
-        phase: "result", name: "sessions_spawn", toolCallId: "call_2",
+        phase: "result",
+        name: "sessions_spawn",
+        toolCallId: "call_2",
         meta: "lint",
         result: { details: spawnResult(childKeyB, bareB, "lint") },
       },
@@ -157,21 +191,27 @@ describe("subagent smoke", () => {
 
     // ── Subagent B: agent event (subagent's own sessionKey) ─
     forwardAgentEventRaw({
-      runId: compoundB, seq: 1, stream: "assistant",
+      runId: compoundB,
+      seq: 1,
+      stream: "assistant",
       data: { phase: "delta", text: "No lint errors found." },
       sessionKey: childKeyB,
     });
 
     // ── Subagent B ended (subagent's own sessionKey) ──────
     forwardAgentEventRaw({
-      runId: compoundB, seq: 2, stream: "lifecycle",
+      runId: compoundB,
+      seq: 2,
+      stream: "lifecycle",
       data: { phase: "end" },
       sessionKey: childKeyB,
     });
 
     // ── Subagent A ended (subagent's own sessionKey) ──────
     forwardAgentEventRaw({
-      runId: compoundA, seq: 7, stream: "lifecycle",
+      runId: compoundA,
+      seq: 7,
+      stream: "lifecycle",
       data: { phase: "end" },
       sessionKey: childKeyA,
     });

package/src/e2e/subagent.e2e.test.ts

@@ -203,15 +203,20 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run start
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       const broadcastCalls = captureBroadcastCalls();
 
       // Simulate sessions_spawn tool result
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
           phase: "result",
@@ -243,17 +248,30 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       // Spawn subagent
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId, taskName: "cr" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKey,
+              runId: bareRunId,
+              taskName: "cr",
+            }),
+          },
         },
       });
 
@@ -264,14 +282,14 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Agent event for subagent (announce runId, subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 1, stream: "thinking",
+        runId: compoundRunId,
+        seq: 1,
+        stream: "thinking",
         data: { text: "reviewing..." },
         sessionKey: childKey,
       });
 
-      const agentCall = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "thinking",
-      );
+      const agentCall = calls.find(([, e]) => e.type === "agent" && e.data.stream === "thinking");
       expect(agentCall).toBeTruthy();
       expect(agentCall![1].data.subagent).toEqual({
         label: "cr",
@@ -282,21 +300,24 @@ describe("subagent via sessions_spawn tool", () => {
 
     it("main agent events are NOT annotated", () => {
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       const calls = captureBroadcastToRunCalls();
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "assistant",
+        runId: mainRunId,
+        seq: 2,
+        stream: "assistant",
         sessionKey: mainSessionKey,
         data: { text: "main reply" },
       });
 
-      const agentCall = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "assistant",
-      );
+      const agentCall = calls.find(([, e]) => e.type === "agent" && e.data.stream === "assistant");
       expect(agentCall![1].data.subagent).toBeUndefined();
     });
 
@@ -305,16 +326,29 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId, taskName: "cr" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKey,
+              runId: bareRunId,
+              taskName: "cr",
+            }),
+          },
         },
       });
 
@@ -325,7 +359,9 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Lifecycle end for subagent (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
@@ -342,15 +378,22 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
           result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId }) },
         },
       });
@@ -361,7 +404,9 @@ describe("subagent via sessions_spawn tool", () => {
       const broadcastCalls = captureBroadcastCalls();
 
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "error", error: "timeout" },
         sessionKey: childKey,
       });
@@ -379,15 +424,22 @@ describe("subagent via sessions_spawn tool", () => {
       const bareRunId = "bare-cr";
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
           result: { details: makeSpawnToolResult({ childSessionKey: childKey, runId: bareRunId }) },
         },
       });
@@ -398,12 +450,16 @@ describe("subagent via sessions_spawn tool", () => {
       const broadcastCalls = captureBroadcastCalls();
 
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 5, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
       forwardAgentEventRaw({
-        runId: compoundRunId, seq: 6, stream: "lifecycle",
+        runId: compoundRunId,
+        seq: 6,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKey,
       });
@@ -426,17 +482,30 @@ describe("subagent via sessions_spawn tool", () => {
 
       // Main run start
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 1, stream: "lifecycle",
-        sessionKey: mainSessionKey, data: { phase: "start" },
+        runId: mainRunId,
+        seq: 1,
+        stream: "lifecycle",
+        sessionKey: mainSessionKey,
+        data: { phase: "start" },
       });
 
       // sessions_spawn for A
       forwardAgentEventRaw({
-        runId: mainRunId, seq: 2, stream: "tool",
+        runId: mainRunId,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c1",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKeyA, runId: bareA, taskName: "reviewer" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c1",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKeyA,
+              runId: bareA,
+              taskName: "reviewer",
+            }),
+          },
         },
       });
       sseEmitter.trackDeviceForRun(deviceId, compoundA);
@@ -444,13 +513,13 @@ describe("subagent via sessions_spawn tool", () => {
       // Subagent A thinking (subagent's own sessionKey)
       const calls = captureBroadcastToRunCalls();
       forwardAgentEventRaw({
-        runId: compoundA, seq: 1, stream: "thinking",
+        runId: compoundA,
+        seq: 1,
+        stream: "thinking",
         data: { text: "reviewing code..." },
         sessionKey: childKeyA,
       });
-      const thinkingA = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "thinking",
-      );
+      const thinkingA = calls.find(([, e]) => e.type === "agent" && e.data.stream === "thinking");
       expect(thinkingA![1].data.subagent).toEqual({
         label: "reviewer",
         parentRunId: mainRunId,
@@ -461,36 +530,50 @@ describe("subagent via sessions_spawn tool", () => {
       // In reality, B is spawned from a tool call inside A's run, but here we simulate it from the main run
       // The registry handles nesting via requesterSessionKey chain
       forwardAgentEventRaw({
-        runId: compoundA, seq: 2, stream: "tool",
+        runId: compoundA,
+        seq: 2,
+        stream: "tool",
         sessionKey: mainSessionKey,
         data: {
-          phase: "result", name: "sessions_spawn", toolCallId: "c2",
-          result: { details: makeSpawnToolResult({ childSessionKey: childKeyB, runId: bareB, taskName: "lint" }) },
+          phase: "result",
+          name: "sessions_spawn",
+          toolCallId: "c2",
+          result: {
+            details: makeSpawnToolResult({
+              childSessionKey: childKeyB,
+              runId: bareB,
+              taskName: "lint",
+            }),
+          },
         },
       });
       sseEmitter.trackDeviceForRun(deviceId, compoundB);
 
       // Subagent B thinking (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundB, seq: 1, stream: "assistant",
+        runId: compoundB,
+        seq: 1,
+        stream: "assistant",
         data: { text: "no lint errors" },
         sessionKey: childKeyB,
       });
-      const assistantB = calls.find(
-        ([, e]) => e.type === "agent" && e.data.stream === "assistant",
-      );
+      const assistantB = calls.find(([, e]) => e.type === "agent" && e.data.stream === "assistant");
       expect(assistantB![1].data.subagent).toBeDefined();
 
       // B ends (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundB, seq: 5, stream: "lifecycle",
+        runId: compoundB,
+        seq: 5,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKeyB,
       });
 
       // A ends (subagent's own sessionKey)
       forwardAgentEventRaw({
-        runId: compoundA, seq: 6, stream: "lifecycle",
+        runId: compoundA,
+        seq: 6,
+        stream: "lifecycle",
         data: { phase: "end" },
         sessionKey: childKeyA,
       });

package/src/e2e/tool-lifecycle.e2e.test.ts

@@ -1,7 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { createAppSimulator } from "../test-support/app-simulator.js";
 import { mockDispatchScript, resetMockDispatch } from "../test-support/mock-dispatch.js";
-import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import {
+  createTempHistoryDir,
+  removeTempHistoryDir,
+  setMockRuntime,
+} from "../test-support/mock-runtime.js";
 
 describe("e2e tool lifecycle", () => {
   let historyDir = "";

package/src/friday-session.forward-agent.test.ts

@@ -10,7 +10,10 @@ import {
   resetThinkingStreamAccumStateForTest,
 } from "./friday-session.js";
 import { resetRunMetadataForTest } from "./run-metadata.js";
-import { accumulateRunUsage, resetRunUsageAccumulatorForTest } from "./agent/run-usage-accumulator.js";
+import {
+  accumulateRunUsage,
+  resetRunUsageAccumulatorForTest,
+} from "./agent/run-usage-accumulator.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { toSessionStoreKey } from "./session/session-manager.js";
 
@@ -56,8 +59,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const first = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data.data;
-    const second = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data.data;
+    const first = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data
+      .data;
+    const second = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data
+      .data;
 
     expect(first.text).toBe(t1);
     expect(first.delta).toBe(t1);
@@ -94,7 +99,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(3);
-    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data.data;
+    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data
+      .data;
     expect(third.delta).toBe(t1);
     expect(third.reasoningPrefixChars).toBe(0);
   });
@@ -123,7 +129,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       data: { text: t1, delta: t1 },
     });
 
-    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data.data;
+    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data
+      .data;
     expect(third.reasoningPrefixChars).toBe(0);
     expect(third.delta).toBe(t1);
   });
@@ -179,7 +186,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const endPayload = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data;
+    const endPayload = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1]
+      .data;
     expect(endPayload.stream).toBe("lifecycle");
     expect((endPayload.data as { phase?: string }).phase).toBe("end");
     expect(endPayload.sessionKey).toBe(sessionKey);
@@ -214,8 +222,18 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       },
     } as never);
 
-    accumulateRunUsage(runId, { input: 100, output: 50, cacheRead: 10, total: 150 }, "my-model", "openai");
-    accumulateRunUsage(runId, { input: 30, output: 10, cacheRead: 0, total: 40 }, "my-model", "openai");
+    accumulateRunUsage(
+      runId,
+      { input: 100, output: 50, cacheRead: 10, total: 150 },
+      "my-model",
+      "openai",
+    );
+    accumulateRunUsage(
+      runId,
+      { input: 30, output: 10, cacheRead: 0, total: 40 },
+      "my-model",
+      "openai",
+    );
 
     forwardAgentEventRaw({
       runId,
@@ -232,7 +250,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     // llm_output fallback — per-run totals.
     expect(sessionUsage.modelId).toBe("my-model");
@@ -272,7 +293,12 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     } as never);
 
     // llm_output has fresher model/provider but per-run (smaller) tokens.
-    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, total: 800 }, "llm-model", "llm-provider");
+    accumulateRunUsage(
+      runId,
+      { input: 500, output: 100, cacheRead: 200, total: 800 },
+      "llm-model",
+      "llm-provider",
+    );
 
     forwardAgentEventRaw({
       runId,
@@ -287,7 +313,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     // Store cumulative totals win.
     expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(5000);
@@ -344,7 +373,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     expect(sessionUsage.modelId).toBe("store-model");
     expect(sessionUsage.modelProvider).toBe("store-provider");