npm - @brainpilot/web - Versions diffs - 0.0.5 → 0.0.6 - Mend

@brainpilot/web 0.0.5 → 0.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/assets/index-Br55rkHb.css +1 -0
package/dist/assets/index-CeUzk-ej.js +445 -0
package/dist/index.html +2 -2
package/package.json +5 -2
package/src/__tests__/agentsReducer.test.ts +67 -0
package/src/__tests__/api.test.ts +118 -0
package/src/__tests__/chatScrollMemory.test.ts +49 -0
package/src/__tests__/demoConversation.test.ts +73 -0
package/src/__tests__/demoReset.test.ts +24 -0
package/src/__tests__/runningToast.test.ts +29 -0
package/src/__tests__/tokenUsage.test.ts +48 -0
package/src/__tests__/toolDisplay.test.ts +55 -0
package/src/__tests__/traceReducer.test.ts +62 -0
package/src/components/chat/MessageStream.tsx +97 -56
package/src/components/chat/PromptComposer.tsx +120 -29
package/src/components/chat/chatScrollMemory.ts +49 -0
package/src/components/demo/DemoView.tsx +91 -29
package/src/components/demo/TraceNodeModal.tsx +6 -2
package/src/components/demo/demoBundle.ts +7 -2
package/src/components/demo/demoReset.ts +16 -0
package/src/components/session/AgentNetwork.tsx +68 -75
package/src/components/session/AgentTraceViews.tsx +35 -70
package/src/components/session/AnalyticsTab.tsx +58 -224
package/src/components/session/TraceGraphView.tsx +36 -30
package/src/components/session/TraceNodeDetail.tsx +61 -24
package/src/components/session/agentNetworkShared.ts +10 -0
package/src/components/session/traceLayout.ts +32 -0
package/src/components/settings/SettingsDialog.tsx +19 -1
package/src/components/shell/DesktopShell.tsx +39 -14
package/src/components/sidebar/Sidebar.tsx +6 -2
package/src/contexts/SSEContext.tsx +90 -1
package/src/contexts/SessionContext.tsx +354 -43
package/src/contexts/agentsReducer.ts +49 -0
package/src/contexts/runningToast.ts +33 -0
package/src/contexts/traceReducer.ts +62 -0
package/src/contexts/turnTimer.test.ts +97 -0
package/src/contexts/turnTimer.ts +108 -0
package/src/contexts/useTurnTimer.ts +104 -0
package/src/contracts/backend.ts +53 -2
package/src/i18n/messages/analytics.ts +16 -6
package/src/i18n/messages/chat.ts +26 -4
package/src/i18n/messages/contexts.ts +2 -0
package/src/i18n/messages/network.ts +13 -9
package/src/i18n/messages/profile.ts +4 -0
package/src/i18n/messages/settings.ts +4 -0
package/src/i18n/messages/trace.ts +69 -17
package/src/mocks/backend.ts +7 -0
package/src/styles/global.css +204 -55
package/src/utils/api.ts +105 -8
package/src/utils/toolDisplay.ts +74 -0
package/dist/assets/index-C-8G4D4j.js +0 -448
package/dist/assets/index-C501m5OS.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="color-scheme" content="light dark" />
     <title>BrainPilot</title>
-    <script type="module" crossorigin src="/assets/index-C-8G4D4j.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C501m5OS.css">
+    <script type="module" crossorigin src="/assets/index-CeUzk-ej.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Br55rkHb.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,9 @@
 {
   "name": "@brainpilot/web",
-  "version": "0.0.5",
+  "version": "0.0.6",
+  "engines": {
+    "node": ">=22"
+  },
   "license": "Apache-2.0",
   "type": "module",
   "files": [
@@ -28,7 +31,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@brainpilot/protocol": "^0.0.5",
+    "@brainpilot/protocol": "^0.0.6",
     "@fontsource-variable/geist": "^5.2.9",
     "@fontsource-variable/geist-mono": "^5.2.8",
     "@types/react": "^18.3.12",

package/src/__tests__/agentsReducer.test.ts ADDED Viewed

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { reduceAgentsForEvent } from "../contexts/agentsReducer";
+import type { AgentStatus, WebSocketEvent } from "../contracts/backend";
+// #70: events arrive post-normalizeAgUiEvent (camelCase). agent_status_update's
+// authoritative agent key is the top-level `name` field; status is one of
+// idle|running|error|stopped (retrying normalized to running).
+const ev = (name: string, status: string): WebSocketEvent =>
+  ({ type: "agent_status_update", name, status } as WebSocketEvent);
+describe("reduceAgentsForEvent (#70)", () => {
+  it("appends an unknown agent with empty task", () => {
+    const out = reduceAgentsForEvent([], ev("librarian", "running"));
+    expect(out).toHaveLength(1);
+    expect(out[0]).toMatchObject({ name: "librarian", status: "running", task: "", alive: true });
+  });
+  it("updates a known agent's status but preserves its task", () => {
+    const prev: AgentStatus[] = [
+      { name: "librarian", status: "idle", task: "读文档", updatedAt: "t0", alive: true },
+    ];
+    const out = reduceAgentsForEvent(prev, ev("librarian", "running"));
+    expect(out[0]!.status).toBe("running");
+    expect(out[0]!.task).toBe("读文档"); // task preserved
+    expect(out).not.toBe(prev); // new reference on change
+  });
+  it("returns the same reference on a no-op status", () => {
+    const prev: AgentStatus[] = [
+      { name: "principal", status: "running", task: "", updatedAt: "t0", alive: true },
+    ];
+    expect(reduceAgentsForEvent(prev, ev("principal", "running"))).toBe(prev);
+  });
+  it("ignores non agent_status_update events (same reference)", () => {
+    const prev: AgentStatus[] = [
+      { name: "principal", status: "idle", task: "", updatedAt: "t0", alive: true },
+    ];
+    expect(reduceAgentsForEvent(prev, { type: "RUN_STARTED" } as WebSocketEvent)).toBe(prev);
+  });
+  it("ignores events with an empty name", () => {
+    const prev: AgentStatus[] = [];
+    expect(reduceAgentsForEvent(prev, ev("", "running"))).toBe(prev);
+  });
+  it("marks a stopped agent as not alive", () => {
+    const out = reduceAgentsForEvent([], ev("librarian", "stopped"));
+    expect(out[0]).toMatchObject({ status: "stopped", alive: false });
+  });
+  it("normalizes retrying to running for the panel", () => {
+    const out = reduceAgentsForEvent([], ev("principal", "retrying"));
+    expect(out[0]!.status).toBe("running");
+  });
+  it("merges multiple agents independently", () => {
+    let agents: AgentStatus[] = [];
+    agents = reduceAgentsForEvent(agents, ev("principal", "running"));
+    agents = reduceAgentsForEvent(agents, ev("librarian", "running"));
+    agents = reduceAgentsForEvent(agents, ev("principal", "idle"));
+    expect(agents).toHaveLength(2);
+    expect(agents.find((a) => a.name === "principal")!.status).toBe("idle");
+    expect(agents.find((a) => a.name === "librarian")!.status).toBe("running");
+  });
+});

package/src/__tests__/api.test.ts CHANGED Viewed

@@ -78,6 +78,64 @@ describe("api.sessions.list — unwraps { sessions } and tolerates shape", () =>
   });
 });
+describe("api.sessions.create — unwraps the { id, session } envelope (#96)", () => {
+  it("reads the real title from the runtime's { id, session } envelope", async () => {
+    // The runtime's POST /sessions returns `{ id, session }` (server.ts), unlike
+    // the GET routes which return the bare session. Before the fix the whole
+    // envelope was handed to normalizeSession, so `raw.title` was undefined and
+    // the sidebar/header fell back to `Session <id8>` until a reload.
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({
+        contentType: "application/json",
+        json: { id: "f8f35032", session: { id: "f8f35032", title: "请用两句话介绍 BrainPilot" } },
+      }),
+    );
+    const out = await api.sessions.create("请用两句话介绍 BrainPilot");
+    expect(out.id).toBe("f8f35032");
+    expect(out.title).toBe("请用两句话介绍 BrainPilot");
+  });
+  it("tolerates a bare session object (no envelope)", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({
+        contentType: "application/json",
+        json: { id: "abc", title: "bare title" },
+      }),
+    );
+    const out = await api.sessions.create("bare title");
+    expect(out.id).toBe("abc");
+    expect(out.title).toBe("bare title");
+  });
+});
+describe("composer-driving requests carry an abort timeout (#106)", () => {
+  it("create passes an AbortSignal so a hung POST can't wedge the composer", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({ contentType: "application/json", json: { id: "x", session: { id: "x", title: "t" } } }),
+    );
+    await api.sessions.create("t");
+    const init = fetchMock.mock.calls[0][1] as RequestInit;
+    expect(init.signal).toBeInstanceOf(AbortSignal);
+  });
+  it("postMessage passes an AbortSignal", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({ contentType: "application/json", json: { status: "ok" } }),
+    );
+    await api.sessions.postMessage("s1", { content: "hi", uuid: "u", timestamp: "2026-06-18T00:00:00Z" });
+    const init = fetchMock.mock.calls[0][1] as RequestInit;
+    expect(init.signal).toBeInstanceOf(AbortSignal);
+  });
+  it("propagates the timeout rejection to the caller (releases isSending upstream)", async () => {
+    // Simulate AbortSignal.timeout firing: fetch rejects with a TimeoutError.
+    fetchMock.mockRejectedValueOnce(new DOMException("timed out", "TimeoutError"));
+    await expect(
+      api.sessions.postMessage("s1", { content: "hi", uuid: "u", timestamp: "2026-06-18T00:00:00Z" }),
+    ).rejects.toBeInstanceOf(DOMException);
+  });
+});
 describe("api.sessions.getEvents — tolerates SSE / non-JSON responses", () => {
   it("returns the events array for a JSON { events } body", async () => {
     fetchMock.mockResolvedValueOnce(
@@ -101,3 +159,63 @@ describe("api.sessions.getEvents — tolerates SSE / non-JSON responses", () =>
     await expect(api.sessions.getEvents("s1")).resolves.toEqual([]);
   });
 });
+describe("api.sessions.getHistory — persisted events.jsonl rehydration", () => {
+  it("returns the envelope shape from a JSON response", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({
+        contentType: "application/json",
+        json: { events: [{ type: "TEXT_MESSAGE_CHUNK", delta: "hi" }], total: 1, truncated: false },
+      }),
+    );
+    const out = await api.sessions.getHistory("s1");
+    expect(out.events).toHaveLength(1);
+    expect(out.total).toBe(1);
+    expect(out.truncated).toBe(false);
+  });
+  it("forwards the limit query string", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({ contentType: "application/json", json: { events: [], total: 0, truncated: false } }),
+    );
+    await api.sessions.getHistory("s1", { limit: 42 });
+    const url = String(fetchMock.mock.calls[0]![0]);
+    expect(url).toContain("/sessions/s1/history?limit=42");
+  });
+  it("returns the empty envelope on a non-ok response", async () => {
+    fetchMock.mockResolvedValueOnce(makeResponse({ ok: false, status: 404 }));
+    const out = await api.sessions.getHistory("s1");
+    expect(out).toEqual({ events: [], total: 0, truncated: false });
+  });
+  it("returns the empty envelope when the body is null", async () => {
+    fetchMock.mockResolvedValueOnce(makeResponse({ contentType: "application/json", json: null }));
+    const out = await api.sessions.getHistory("s1");
+    expect(out).toEqual({ events: [], total: 0, truncated: false });
+  });
+});
+describe("api.sessions.interrupt — hits the interrupt route, not /messages (#90)", () => {
+  it("POSTs to /sessions/:id/interrupt and returns { interrupted }", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({ contentType: "application/json", json: { interrupted: true } }),
+    );
+    const out = await api.sessions.interrupt("s1");
+    const [url, init] = fetchMock.mock.calls[0]!;
+    expect(String(url)).toMatch(/\/sessions\/s1\/interrupt$/);
+    expect(String(url)).not.toMatch(/\/messages$/);
+    expect((init as RequestInit).method).toBe("POST");
+    expect(out.interrupted).toBe(true);
+  });
+  it("never routes the Stop action through the messages endpoint", async () => {
+    fetchMock.mockResolvedValueOnce(
+      makeResponse({ contentType: "application/json", json: { interrupted: true } }),
+    );
+    await api.sessions.interrupt("abc");
+    const url = String(fetchMock.mock.calls[0]![0]);
+    expect(url.endsWith("/messages")).toBe(false);
+  });
+});

package/src/__tests__/chatScrollMemory.test.ts ADDED Viewed

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  getChatScroll,
+  setChatScroll,
+  resolveScrollTop,
+} from "../components/chat/chatScrollMemory";
+describe("chatScrollMemory (#89)", () => {
+  beforeEach(() => {
+    // Each test uses unique keys, but clear shared rows defensively.
+    setChatScroll("s1", { scrollTop: 0, pinned: true });
+    setChatScroll("s2", { scrollTop: 0, pinned: true });
+  });
+  it("stores and reads per-session state", () => {
+    setChatScroll("s1", { scrollTop: 120, pinned: false });
+    expect(getChatScroll("s1")).toEqual({ scrollTop: 120, pinned: false });
+  });
+  it("isolates sessions", () => {
+    setChatScroll("s1", { scrollTop: 50, pinned: false });
+    setChatScroll("s2", { scrollTop: 999, pinned: true });
+    expect(getChatScroll("s1")?.scrollTop).toBe(50);
+    expect(getChatScroll("s2")?.scrollTop).toBe(999);
+  });
+  it("ignores undefined keys", () => {
+    setChatScroll(undefined, { scrollTop: 5, pinned: false });
+    expect(getChatScroll(undefined)).toBeUndefined();
+  });
+  describe("resolveScrollTop", () => {
+    it("returns bottom when there is no memory (fresh conversation)", () => {
+      expect(resolveScrollTop(undefined, 4000)).toBe(4000);
+    });
+    it("returns bottom when the user was pinned (following live output)", () => {
+      expect(resolveScrollTop({ scrollTop: 100, pinned: true }, 4000)).toBe(4000);
+    });
+    it("restores the saved position when the user was reading history", () => {
+      expect(resolveScrollTop({ scrollTop: 800, pinned: false }, 4000)).toBe(800);
+    });
+    it("clamps a stale position to the current scrollHeight", () => {
+      expect(resolveScrollTop({ scrollTop: 9000, pinned: false }, 4000)).toBe(4000);
+    });
+  });
+});

package/src/__tests__/demoConversation.test.ts ADDED Viewed

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import type { ChatMessage } from "../contracts/backend";
+import { isDemoConversational } from "../components/demo/DemoView";
+function msg(overrides: Partial<ChatMessage>): ChatMessage {
+  return {
+    id: overrides.id ?? "m1",
+    role: overrides.role ?? "assistant",
+    content: overrides.content ?? "",
+    createdAt: "2026-06-18T00:00:00.000Z",
+    ...overrides,
+  };
+}
+describe("isDemoConversational (#98 multi-agent transcript)", () => {
+  it("keeps non-empty user prompts", () => {
+    expect(isDemoConversational(msg({ role: "user", content: "hello" }))).toBe(true);
+    expect(isDemoConversational(msg({ role: "user", content: "  " }))).toBe(false);
+  });
+  it("keeps the principal's substantive text replies", () => {
+    expect(
+      isDemoConversational(msg({ role: "assistant", agent: "principal", kind: "text", content: "done" })),
+    ).toBe(true);
+  });
+  it("keeps EXPERT agent text replies (the core #98 regression)", () => {
+    // librarian / engineer / experimentalist replies must survive — the live
+    // Chat shows them, so the demo must too.
+    expect(
+      isDemoConversational(msg({ role: "assistant", agent: "librarian", kind: "text", content: "searching…" })),
+    ).toBe(true);
+    expect(
+      isDemoConversational(msg({ role: "assistant", agent: "engineer", kind: undefined, content: "built it" })),
+    ).toBe(true);
+  });
+  it("treats a missing agent as conversational (older bundles)", () => {
+    expect(isDemoConversational(msg({ role: "assistant", kind: "text", content: "hi" }))).toBe(true);
+  });
+  it("keeps error bubbles with content", () => {
+    expect(isDemoConversational(msg({ role: "system", kind: "error", content: "librarian failed" }))).toBe(true);
+    expect(isDemoConversational(msg({ role: "system", kind: "error", content: "" }))).toBe(false);
+  });
+  it("keeps system_message bubbles that carry a payload", () => {
+    expect(
+      isDemoConversational(
+        msg({
+          role: "system",
+          kind: "system_message",
+          content: "",
+          systemMessage: { level: "error", message: "librarian error", recoverable: true },
+        }),
+      ),
+    ).toBe(true);
+    // No payload → nothing to render.
+    expect(isDemoConversational(msg({ role: "system", kind: "system_message", content: "" }))).toBe(false);
+  });
+  it("drops reasoning, tool calls/results, hooks and interactive cards", () => {
+    expect(isDemoConversational(msg({ kind: "thinking", content: "let me think" }))).toBe(false);
+    expect(isDemoConversational(msg({ kind: "tool", content: "Tool: read" }))).toBe(false);
+    expect(isDemoConversational(msg({ role: "system", kind: "hook", content: "reset" }))).toBe(false);
+    expect(isDemoConversational(msg({ kind: "ask_user", content: "pick one" }))).toBe(false);
+    expect(isDemoConversational(msg({ kind: "auto_retry", content: "retrying" }))).toBe(false);
+  });
+  it("drops empty text placeholders", () => {
+    expect(isDemoConversational(msg({ role: "assistant", kind: "text", content: "   " }))).toBe(false);
+  });
+});

package/src/__tests__/demoReset.test.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { shouldResetDemo } from "../components/demo/demoReset";
+describe("shouldResetDemo (#111 sidebar re-click returns to landing)", () => {
+  it("does not reset on the initial mount (same value)", () => {
+    // prev === next on first render — packing/importing a bundle must survive.
+    expect(shouldResetDemo(0, 0)).toBe(false);
+    expect(shouldResetDemo(3, 3)).toBe(false);
+  });
+  it("resets when the signal advances (sidebar clicked again)", () => {
+    expect(shouldResetDemo(0, 1)).toBe(true);
+    expect(shouldResetDemo(1, 2)).toBe(true);
+  });
+  it("treats an undefined signal (standalone mount) as no reset", () => {
+    // DemoView mounted without the prop: prev and next are both undefined.
+    expect(shouldResetDemo(undefined, undefined)).toBe(false);
+  });
+  it("resets when transitioning from undefined to a number", () => {
+    expect(shouldResetDemo(undefined, 1)).toBe(true);
+  });
+});

package/src/__tests__/runningToast.test.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { runningToastLabel } from "../contexts/runningToast";
+describe("runningToastLabel (#76)", () => {
+  it("names a single working agent", () => {
+    expect(runningToastLabel(["librarian"])).toEqual({
+      key: "chat.agentWorking",
+      vars: { name: "librarian" },
+    });
+  });
+  it("joins multiple working agents", () => {
+    expect(runningToastLabel(["principal", "librarian"])).toEqual({
+      key: "chat.agentsWorking",
+      vars: { names: "principal、librarian" },
+    });
+  });
+  it("uses a custom separator when provided", () => {
+    expect(runningToastLabel(["a", "b"], ", ")).toEqual({
+      key: "chat.agentsWorking",
+      vars: { names: "a, b" },
+    });
+  });
+  it("falls back to the generic label when no named agent is running", () => {
+    expect(runningToastLabel([])).toEqual({ key: "chat.agentThinking" });
+  });
+});

package/src/__tests__/tokenUsage.test.ts ADDED Viewed

@@ -0,0 +1,48 @@
+/**
+ * normalizeSessionState parses the optional `tokenUsage` carried on
+ * session_state frames into the camelCase SessionTokenUsage shape, and tolerates
+ * its absence (older runtime / pre-first-turn).
+ */
+import { describe, it, expect } from "vitest";
+import { normalizeSessionState } from "../contracts/backend";
+describe("normalizeSessionState tokenUsage", () => {
+  it("parses total + per-agent breakdown", () => {
+    const snap = normalizeSessionState({
+      run_state: { active: false, run_id: null },
+      agents: [],
+      last_activity_ts: "2026-06-20T00:00:00.000Z",
+      token_usage: {
+        total: { input: 30, output: 12, cache_read: 4, cache_write: 1, total: 47 },
+        by_agent: {
+          principal: { input: 20, output: 8, cache_read: 4, cache_write: 1, total: 33 },
+          librarian: { input: 10, output: 4, cache_read: 0, cache_write: 0, total: 14 },
+        },
+      },
+    });
+    expect(snap.tokenUsage).toBeDefined();
+    expect(snap.tokenUsage!.total.total).toBe(47);
+    expect(snap.tokenUsage!.total.cacheRead).toBe(4);
+    expect(snap.tokenUsage!.byAgent.principal.input).toBe(20);
+    expect(snap.tokenUsage!.byAgent.librarian.total).toBe(14);
+  });
+  it("omits tokenUsage when absent and coerces missing numbers to 0", () => {
+    const snap = normalizeSessionState({
+      run_state: { active: true, run_id: "run_1" },
+      agents: [],
+      last_activity_ts: "2026-06-20T00:00:00.000Z",
+    });
+    expect(snap.tokenUsage).toBeUndefined();
+    const partial = normalizeSessionState({
+      run_state: { active: true, run_id: "run_1" },
+      agents: [],
+      last_activity_ts: "2026-06-20T00:00:00.000Z",
+      token_usage: { total: { input: 5 }, by_agent: {} },
+    });
+    expect(partial.tokenUsage!.total.input).toBe(5);
+    expect(partial.tokenUsage!.total.output).toBe(0);
+    expect(partial.tokenUsage!.total.total).toBe(0);
+  });
+});

package/src/__tests__/toolDisplay.test.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { formatToolName, formatPayload } from "../utils/toolDisplay";
+describe("formatToolName (#84)", () => {
+  it("maps mcp__server__tool to 'server · tool'", () => {
+    expect(formatToolName("mcp__bp_skills__skills_tool")).toBe("bp_skills · skills_tool");
+  });
+  it("keeps server/tool segments that contain underscores", () => {
+    expect(formatToolName("mcp__my_server__do_a_thing")).toBe("my_server · do_a_thing");
+  });
+  it("returns non-MCP names unchanged", () => {
+    expect(formatToolName("read")).toBe("read");
+    expect(formatToolName("send_message")).toBe("send_message");
+  });
+  it("falls back gracefully for missing/empty names", () => {
+    expect(formatToolName(undefined)).toBe("tool");
+    expect(formatToolName(null)).toBe("tool");
+    expect(formatToolName("")).toBe("tool");
+  });
+  it("does not crash on a malformed mcp__ prefix with no tool segment", () => {
+    // No second `__` — show the remainder rather than the raw identifier.
+    expect(formatToolName("mcp__justserver")).toBe("justserver");
+  });
+});
+describe("formatPayload (#84)", () => {
+  it("parses a JSON string so it is not double-escaped", () => {
+    const raw = JSON.stringify({ path: "a/b.txt", count: 2 });
+    const out = formatPayload(raw);
+    expect(out).toBe('{\n  "path": "a/b.txt",\n  "count": 2\n}');
+    expect(out).not.toContain('\\"');
+  });
+  it("pretty-prints a plain object", () => {
+    expect(formatPayload({ a: 1 })).toBe('{\n  "a": 1\n}');
+  });
+  it("returns non-JSON strings verbatim", () => {
+    expect(formatPayload("just some text")).toBe("just some text");
+  });
+  it("returns a partial/invalid JSON string verbatim", () => {
+    expect(formatPayload('{"path": "a/b')).toBe('{"path": "a/b');
+  });
+  it("returns empty string for null/undefined/blank", () => {
+    expect(formatPayload(undefined)).toBe("");
+    expect(formatPayload(null)).toBe("");
+    expect(formatPayload("   ")).toBe("");
+  });
+});

package/src/__tests__/traceReducer.test.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+import { reduceTraceForEvent } from "../contexts/traceReducer";
+import type { TraceGraph, WebSocketEvent } from "../contracts/backend";
+// #79: trace nodes arrive live as CUSTOM { name:"trace_node", value:{ op, node } }.
+const node = (id: string, extra: Record<string, unknown> = {}) => ({
+  id,
+  title: `node ${id}`,
+  type: "task",
+  status: "completed",
+  parents: [],
+  parentIds: [],
+  childIds: [],
+  artifacts: [],
+  toolCalls: [],
+  ...extra,
+});
+const traceEv = (op: string, n: Record<string, unknown>): WebSocketEvent =>
+  ({ type: "CUSTOM", name: "trace_node", value: { op, node: n } } as unknown as WebSocketEvent);
+describe("reduceTraceForEvent (#79)", () => {
+  it("seeds a graph from null on the first node", () => {
+    const out = reduceTraceForEvent(null, traceEv("created", node("a")), "s");
+    expect(out).not.toBeNull();
+    expect(out!.nodes.map((n) => n.id)).toEqual(["a"]);
+    expect(out!.meta.sessionId).toBe("s");
+  });
+  it("appends a new node id", () => {
+    const start: TraceGraph = { meta: { sessionId: "s" }, nodes: [node("a")] };
+    const out = reduceTraceForEvent(start, traceEv("created", node("b")), "s");
+    expect(out!.nodes.map((n) => n.id)).toEqual(["a", "b"]);
+  });
+  it("replaces an existing node in place on update", () => {
+    const start: TraceGraph = { meta: { sessionId: "s" }, nodes: [node("a", { status: "running" })] };
+    const out = reduceTraceForEvent(start, traceEv("updated", node("a", { status: "completed" })), "s");
+    expect(out!.nodes).toHaveLength(1);
+    expect(out!.nodes[0]!.status).toBe("completed");
+  });
+  it("recomputes childIds from parent links", () => {
+    const start: TraceGraph = { meta: { sessionId: "s" }, nodes: [node("a")] };
+    const child = node("b", { parents: [{ id: "a", relation: "follows" }], parentIds: ["a"] });
+    const out = reduceTraceForEvent(start, traceEv("created", child), "s");
+    const parent = out!.nodes.find((n) => n.id === "a")!;
+    expect(parent.childIds).toEqual(["b"]);
+  });
+  it("ignores non trace_node events (same reference)", () => {
+    const start: TraceGraph = { meta: { sessionId: "s" }, nodes: [node("a")] };
+    expect(reduceTraceForEvent(start, { type: "RUN_STARTED" } as WebSocketEvent, "s")).toBe(start);
+  });
+  it("ignores a payload with no node id (same reference)", () => {
+    const start: TraceGraph = { meta: { sessionId: "s" }, nodes: [node("a")] };
+    const bad = { type: "CUSTOM", name: "trace_node", value: { op: "created", node: {} } } as unknown as WebSocketEvent;
+    expect(reduceTraceForEvent(start, bad, "s")).toBe(start);
+  });
+});