@syengup/friday-channel-next 0.1.36 → 0.1.37

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");

package/src/friday-session.ts

@@ -49,7 +49,7 @@ export function deviceIdFromSessionKey(sessionKey: string): string | null {
   const m1 = sessionKey.match(/^friday-next-(.+)$/i);
   if (m1) return m1[1] ?? null;
   const m2 = sessionKey.match(/^agent:main:friday-next-(.+)$/i);
-  return m2 ? m2[1] ?? null : null;
+  return m2 ? (m2[1] ?? null) : null;
 }
 
 /**
@@ -66,7 +66,8 @@ const deviceIdToLatestHistorySessionKey = new Map<string, string>();
 let lastRegisteredFridayDeviceId: string | undefined;
 
 function normalizeFridaySessionKeyCase(sk: string): string {
-  return /^friday-next-|^agent:main:friday-next-/i.test(sk) || /^agent:main:friday-next:direct:/i.test(sk)
+  return /^friday-next-|^agent:main:friday-next-/i.test(sk) ||
+    /^agent:main:friday-next:direct:/i.test(sk)
     ? sk.toLowerCase()
     : sk;
 }
@@ -157,7 +158,11 @@ function mergeRunMetadataIntoLifecycleEnd(
   if (typeof meta.modelName === "string" && meta.modelName.trim()) {
     extra.modelName = meta.modelName.trim();
   }
-  if (typeof meta.totalTokens === "number" && Number.isFinite(meta.totalTokens) && meta.totalTokens > 0) {
+  if (
+    typeof meta.totalTokens === "number" &&
+    Number.isFinite(meta.totalTokens) &&
+    meta.totalTokens > 0
+  ) {
     extra.totalTokens = Math.floor(meta.totalTokens);
   }
   if (
@@ -260,7 +265,10 @@ function completeAgentEventForward(params: {
 /**
  * Resolve the real device UUID for Friday outbound (`sendText` / `sendMedia`).
  */
-export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?: Record<string, unknown>): string {
+export function resolveFridayDeviceIdForOutbound(
+  to: string | undefined,
+  rawCtx?: Record<string, unknown>,
+): string {
   const trimmed = (to ?? "").trim();
   if (trimmed && trimmed.toLowerCase() !== "friday-next") {
     return trimmed;
@@ -279,6 +287,23 @@ export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?
   return trimmed || "friday-next";
 }
 
+/**
+ * Stringify a subagent error payload for the wire. `evt.data.error` comes from an
+ * in-process SDK callback, so it can be a real Error, a plain object, or a value
+ * that JSON.stringify would throw on (circular/BigInt) — keep this total and
+ * never-throwing, since it runs on the error path that emits `subagent ended`.
+ */
+function stringifySubagentError(raw: unknown): string {
+  if (raw == null) return "unknown";
+  if (typeof raw === "string") return raw;
+  if (raw instanceof Error) return raw.message || raw.name || "error";
+  try {
+    return JSON.stringify(raw) ?? "unknown";
+  } catch {
+    return "unstringifiable error";
+  }
+}
+
 /**
  * Forward global OpenClaw agent events to the Friday SSE connection (transparent).
  *
@@ -308,8 +333,7 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   if (!deviceIdRaw) return;
 
   if (!sk) {
-    sk =
-      latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
+    sk = latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
   }
 
   openClawRunIdToDeviceId.set(evt.runId, deviceIdRaw.toUpperCase());
@@ -325,11 +349,9 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   // Phase 1: spawning — tool.start with taskName in args
   if (isSpawnTool && evt.data.phase === "start") {
-    const toolCallId =
-      typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+    const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
     const args = evt.data.args as Record<string, unknown> | undefined;
-    const label =
-      typeof args?.taskName === "string" ? args.taskName : undefined;
+    const label = typeof args?.taskName === "string" ? args.taskName : undefined;
     if (toolCallId) {
       const intent = registerSpawnIntent({
         toolCallId,
@@ -362,15 +384,12 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
       | { childSessionKey?: string; runId?: string; taskName?: string }
       | undefined;
     if (details?.childSessionKey) {
-      const toolCallId =
-        typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+      const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
       const intent = toolCallId ? consumeSpawnIntent(toolCallId) : undefined;
       const label =
         details.taskName ||
         intent?.label ||
-        (typeof (evt.data as Record<string, unknown>).meta === "string"
-          ? ((evt.data as Record<string, unknown>).meta as string)
-          : undefined);
+        (typeof evt.data.meta === "string" ? evt.data.meta : undefined);
       const entry = ensureSubagentFromSpawnTool({
         childSessionKey: details.childSessionKey,
         bareRunId: details.runId,
@@ -404,10 +423,13 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   // Only annotate events that originate from the subagent itself
   // (sessionKey matches childSessionKey). Main-agent delivery events
   // share the announce runId but have a different sessionKey.
-  const isSubagentOwnEvent =
-    subagentEntry && sk && subagentEntry.childSessionKey === sk;
+  const isSubagentOwnEvent = subagentEntry && sk && subagentEntry.childSessionKey === sk;
   const subagentMeta = isSubagentOwnEvent
-    ? { label: subagentEntry.label, parentRunId: subagentEntry.parentRunId, depth: subagentEntry.depth }
+    ? {
+        label: subagentEntry.label,
+        parentRunId: subagentEntry.parentRunId,
+        depth: subagentEntry.depth,
+      }
     : undefined;
 
   let outgoingData: Record<string, unknown> = { ...evt.data };
@@ -436,12 +458,14 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   const lifecyclePhase =
     evt.stream === "lifecycle" && typeof evt.data.phase === "string" ? evt.data.phase : "";
-  const isTerminalLifecycle = evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
+  const isTerminalLifecycle =
+    evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
 
   // Emit subagent ended SSE when a subagent run terminates
   if (isTerminalLifecycle && isSubagentOwnEvent && subagentEntry.status !== "ended") {
     const outcome = lifecyclePhase === "error" ? "error" : "ok";
-    const errorStr = lifecyclePhase === "error" ? String(evt.data.error ?? "unknown") : undefined;
+    const errorStr =
+      lifecyclePhase === "error" ? stringifySubagentError(evt.data.error) : undefined;
     const ended = registerSubagentEnded({ runId: evt.runId, outcome, error: errorStr });
     if (ended) {
       sseEmitter.broadcast(