@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-agent-dashboard",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Web dashboard for monitoring and interacting with pi agent sessions",
   "repository": {
     "type": "git",
@@ -51,6 +51,8 @@
     "build": "npm run build --workspace=@blackbelt-technology/pi-dashboard-web",
     "test": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest run",
     "test:watch": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest",
+    "test:bootstrap": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest run packages/shared/src/__tests__/bootstrap",
+    "test:bootstrap:watch": "HOME=$(mktemp -d -t pi-test-XXXXXX) vitest packages/shared/src/__tests__/bootstrap",
     "lint": "tsc --noEmit",
     "reload": "./scripts/reload-all.sh",
     "reload:check": "./scripts/reload-all.sh --check",
@@ -64,9 +66,9 @@
     "screenshots": "npm --prefix site run screenshots"
   },
   "dependencies": {
-    "@blackbelt-technology/pi-dashboard-extension": "*",
-    "@blackbelt-technology/pi-dashboard-server": "*",
-    "@blackbelt-technology/pi-dashboard-web": "*"
+    "@blackbelt-technology/pi-dashboard-extension": "^0.4.1",
+    "@blackbelt-technology/pi-dashboard-server": "^0.4.1",
+    "@blackbelt-technology/pi-dashboard-web": "^0.4.1"
   },
   "devDependencies": {
     "jsdom": "^29.0.2",
@@ -81,7 +83,7 @@
     "@oh-my-pi/pi-ai": "*",
     "@oh-my-pi/pi-coding-agent": "*",
     "@oh-my-pi/pi-tui": "*",
-    "@sinclair/typebox": "*"
+    "typebox": "*"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
@@ -101,6 +103,9 @@
     },
     "@oh-my-pi/pi-tui": {
       "optional": true
+    },
+    "typebox": {
+      "optional": true
     }
   }
 }

package/packages/extension/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-extension",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Pi bridge extension for pi-dashboard",
   "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "pi": {
     "extensions": [
       "src/bridge.ts"
@@ -16,18 +19,25 @@
     ".pi/skills/pi-dashboard/"
   ],
   "dependencies": {
-    "@blackbelt-technology/pi-dashboard-shared": "*",
+    "@blackbelt-technology/pi-dashboard-shared": "^0.4.1",
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "typebox": "*"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
       "optional": true
+    },
+    "@mariozechner/pi-tui": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1"
+    "@mariozechner/pi-tui": "*",
+    "@types/ws": "^8.18.1",
+    "typebox": "^1.1.33"
   }
 }

package/packages/extension/src/__tests__/ask-user-tool.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi } from "vitest";
 
 // Mock modules before importing
-vi.mock("@sinclair/typebox", () => ({
+vi.mock("typebox", () => ({
   Type: {
     Object: vi.fn(() => ({})),
     String: vi.fn(() => ({})),
@@ -44,20 +44,37 @@ describe("registerAskUserTool", () => {
     expect(tool.promptGuidelines.length).toBeGreaterThan(0);
   });
 
+  it("description instructs agents not to add a Select all option", () => {
+    const pi = createMockPi();
+    registerAskUserTool(pi as any);
+    const tool = pi.registerTool.mock.calls[0][0];
+    expect(tool.description).toMatch(/UI provides a Select all/i);
+  });
+
   describe("message passthrough", () => {
     function getToolAndMockCtx() {
       const pi = createMockPi();
       registerAskUserTool(pi as any);
       const tool = pi.registerTool.mock.calls[0][0];
+      // `custom` stands in for the multiselect polyfill: it invokes the factory
+      // with a `done` callback; the factory-returned component exposes
+      // onConfirm/onCancel. We auto-confirm with ["A"] to preserve the legacy
+      // mock return value that the multiselect assertions expected.
+      const custom = vi.fn().mockImplementation(async (factory: any) => {
+        return await new Promise<unknown>((resolve) => {
+          const component: any = factory({}, {}, {}, (r: unknown) => resolve(r));
+          component?.onConfirm?.(["A"]);
+        });
+      });
       const ctx = {
         ui: {
           confirm: vi.fn().mockResolvedValue(true),
           select: vi.fn().mockResolvedValue("A"),
           input: vi.fn().mockResolvedValue("hello"),
-          multiselect: vi.fn().mockResolvedValue(["A"]),
+          custom,
         },
       };
-      return { tool, ctx };
+      return { tool, ctx, custom };
     }
 
     it("passes message through opts for input", async () => {
@@ -72,10 +89,19 @@ describe("registerAskUserTool", () => {
       expect(ctx.ui.select).toHaveBeenCalledWith("Pick", ["A", "B"], { message: "Context" });
     });
 
-    it("passes message through opts for multiselect", async () => {
+    it("dispatches multiselect through the polyfill via ctx.ui.custom", async () => {
       const { tool, ctx } = getToolAndMockCtx();
-      await tool.execute("id", { method: "multiselect", title: "Multi", message: "Info", options: ["A"] }, undefined, undefined, ctx);
-      expect(ctx.ui.multiselect).toHaveBeenCalledWith("Multi", ["A"], { message: "Info" });
+      const result = await tool.execute(
+        "id",
+        { method: "multiselect", title: "Multi", message: "Info", options: ["A"] },
+        undefined,
+        undefined,
+        ctx,
+      );
+      // Polyfill routes via custom(factory); multiselect is not called directly.
+      expect(ctx.ui.custom).toHaveBeenCalledTimes(1);
+      expect(result.details.method).toBe("multiselect");
+      expect(result.details.result).toEqual(["A"]);
     });
 
     it("does not pass opts when message is undefined", async () => {
@@ -123,7 +149,7 @@ describe("registerAskUserTool", () => {
       await expect(
         tool.execute("id", { method: "multiselect", title: "Pick" }, undefined, undefined, ctx),
       ).rejects.toThrow(/options/i);
-      expect(ctx.ui.multiselect).not.toHaveBeenCalled();
+      expect(ctx.ui.custom).not.toHaveBeenCalled();
     });
   });
 
@@ -311,12 +337,18 @@ describe("registerAskUserTool", () => {
       const pi = createMockPi();
       registerAskUserTool(pi as any);
       const tool = pi.registerTool.mock.calls[0][0];
+      const custom = vi.fn().mockImplementation(async (factory: any) => {
+        return await new Promise<unknown>((resolve) => {
+          const component: any = factory({}, {}, {}, (r: unknown) => resolve(r));
+          component?.onConfirm?.(["A"]);
+        });
+      });
       const ctx = {
         ui: {
           confirm: vi.fn().mockResolvedValue(true),
           select: vi.fn().mockResolvedValue("A"),
           input: vi.fn().mockResolvedValue("hello"),
-          multiselect: vi.fn().mockResolvedValue(["A"]),
+          custom,
         },
       };
       return { tool, ctx };

package/packages/extension/src/__tests__/bridge-entry-id-pi-070.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Tests for the bridge entryId stamping under pi 0.70.x's emit-then-await-then-append
+ * ordering. Pi 0.70.x's _processAgentEvent does (paraphrased):
+ *
+ *   await this._emitExtensionEvent(event);       // <-- bridge runs here, awaited
+ *   this._emit(event);                           // sync legacy listeners
+ *   if (event.type === "message_end") {
+ *     sessionManager.appendMessage(event.message); // <-- entry id GENERATED HERE
+ *   }
+ *
+ * The bridge's old `queueMicrotask` deferral resolves INSIDE the awaited dispatcher,
+ * before appendMessage runs — so getLeafId() still returns the previous leaf. The fix
+ * is `setTimeout(0)` (macrotask) so the entire await chain unwinds and appendMessage
+ * runs first; OR reading `event.message.id` after pi mutates it in-place.
+ *
+ * This test simulates that ordering and asserts the correct mechanisms.
+ */
+import { describe, it, expect } from "vitest";
+
+interface SimMessage {
+  role: string;
+  content: string;
+  id?: string;
+}
+
+/**
+ * Simulate pi 0.70.x's _processAgentEvent ordering. Returns a promise that
+ * resolves when the entire event has been processed (including appendMessage).
+ *
+ * The `bridgeHandler` is registered as an "extension handler" — runs awaited
+ * inside _emitExtensionEvent. It receives the event and a pseudo-ctx with
+ * sessionManager.getLeafId().
+ */
+async function simulatePi070Emit(opts: {
+  event: { type: string; message: SimMessage };
+  state: { leafId: string; nextId: string };
+  appendMessage: (msg: SimMessage) => string; // returns the new id
+  bridgeHandler: (event: any, ctx: any) => Promise<void> | void;
+}): Promise<void> {
+  const ctx = {
+    sessionManager: { getLeafId: () => opts.state.leafId },
+  };
+
+  // Step 1: await _emitExtensionEvent — runs the bridge handler awaited.
+  await opts.bridgeHandler(opts.event, ctx);
+
+  // Step 2: _emit (sync legacy listeners) — no-op in this simulation.
+
+  // Step 3: persistence on message_end.
+  if (opts.event.type === "message_end") {
+    const id = opts.appendMessage(opts.event.message);
+    opts.state.leafId = id;
+  }
+}
+
+describe("pi 0.70 emit/append ordering", () => {
+  it("queueMicrotask deferral DOES NOT capture the post-persist id (the bug)", async () => {
+    const state = { leafId: "prev", nextId: "new-id-42" };
+    let captured: string | undefined;
+
+    const buggyBridge = async (event: any, ctx: any) => {
+      // What the OLD bridge does today:
+      await new Promise<void>((resolve) => queueMicrotask(resolve));
+      captured = ctx.sessionManager.getLeafId();
+    };
+
+    await simulatePi070Emit({
+      event: { type: "message_end", message: { role: "assistant", content: "hi" } },
+      state,
+      appendMessage: (m) => {
+        m.id = state.nextId;
+        return state.nextId;
+      },
+      bridgeHandler: buggyBridge,
+    });
+
+    // Bug: captured is the previous leaf, NOT the just-appended id.
+    expect(captured).toBe("prev");
+    expect(captured).not.toBe("new-id-42");
+  });
+
+  it("setTimeout(0) deferral DOES capture the post-persist id (the fix)", async () => {
+    const state = { leafId: "prev", nextId: "new-id-42" };
+    let capturedFromGetLeafId: string | undefined;
+    let capturedFromMessageId: string | undefined;
+    let sendDone!: () => void;
+    const sendCompleted = new Promise<void>((r) => { sendDone = r; });
+
+    // The bridge schedules and returns synchronously — the only way the
+    // awaited dispatcher can unwind so appendMessage runs before the timeout.
+    const fixedBridge = (event: any, ctx: any) => {
+      setTimeout(() => {
+        capturedFromMessageId = (event.message as any).id;
+        capturedFromGetLeafId = ctx.sessionManager.getLeafId();
+        sendDone();
+      }, 0);
+    };
+
+    await simulatePi070Emit({
+      event: { type: "message_end", message: { role: "assistant", content: "hi" } },
+      state,
+      appendMessage: (m) => {
+        m.id = state.nextId;
+        return state.nextId;
+      },
+      bridgeHandler: fixedBridge,
+    });
+    await sendCompleted;
+
+    // Both signals should now point at the just-persisted entry.
+    expect(capturedFromMessageId).toBe("new-id-42");
+    expect(capturedFromGetLeafId).toBe("new-id-42");
+  });
+
+  it("WeakMap-on-appendMessage captures the id even before the macrotask", async () => {
+    const state = { leafId: "prev", nextId: "new-id-77" };
+    const idByMessage = new WeakMap<object, string>();
+    const wrappedAppend = (m: SimMessage): string => {
+      m.id = state.nextId;
+      idByMessage.set(m as object, m.id);
+      return m.id;
+    };
+
+    let viaWeakMap: string | undefined;
+    let viaMutation: string | undefined;
+    let sendDone!: () => void;
+    const sentP = new Promise<void>((r) => { sendDone = r; });
+
+    // CRITICAL: bridge SCHEDULES the send and RETURNS IMMEDIATELY.
+    // It does NOT await its own setTimeout — that would keep the
+    // outer dispatcher awaiting and we'd be back to the queueMicrotask
+    // bug (timeout fires before appendMessage).
+    const fixedBridge = (event: any) => {
+      setTimeout(() => {
+        viaMutation = (event.message as any).id;
+        viaWeakMap = idByMessage.get(event.message as object);
+        sendDone();
+      }, 0);
+      // Return synchronously — let the awaited dispatcher unwind.
+    };
+
+    await simulatePi070Emit({
+      event: { type: "message_end", message: { role: "assistant", content: "hi" } },
+      state,
+      appendMessage: wrappedAppend,
+      bridgeHandler: fixedBridge,
+    });
+    await sentP;
+
+    expect(viaMutation).toBe("new-id-77");
+    expect(viaWeakMap).toBe("new-id-77");
+  });
+
+  it("user message_start has NO id (pi defers user persistence to message_end)", async () => {
+    const state = { leafId: "prev-assistant", nextId: "new-user-id" };
+    let captured: string | undefined;
+
+    const fixedBridge = async (event: any) => {
+      await new Promise<void>((resolve) => setTimeout(resolve, 0));
+      captured = (event.message as any).id; // still undefined for message_start
+    };
+
+    await simulatePi070Emit({
+      event: { type: "message_start", message: { role: "user", content: "hello" } },
+      state,
+      appendMessage: () => state.nextId, // not called for message_start
+      bridgeHandler: fixedBridge,
+    });
+
+    // No id available at message_start time — must rely on entry_persisted
+    // back-fill (delivered when the message_end of the SAME message fires later).
+    expect(captured).toBeUndefined();
+  });
+});

package/packages/extension/src/__tests__/enrich-model-metadata.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for enrichModelMetadata — the pure helper that resolves a discovered
+ * custom-provider model id against a catalog probe (typically backed by pi's
+ * `modelRegistry.find(provider, id)`) and falls back to api-appropriate
+ * defaults when the probe has no match.
+ *
+ * The helper takes an optional `probe` parameter so unit tests can supply a
+ * fake catalog without needing `@mariozechner/pi-ai` installed — in
+ * production, registerEntry() injects `modelRegistry.find` as the probe.
+ *
+ * Spec: openspec/changes/enrich-custom-provider-model-metadata/specs/provider-auth-bridge/spec.md
+ */
+
+import { describe, it, expect } from "vitest";
+import { enrichModelMetadata, type CatalogProbe } from "../provider-register.js";
+
+// Minimal fake catalog mirroring a subset of pi-ai's real MODELS export.
+// Keys are `${provider}|${id}` so our probe is a single Map lookup.
+const FAKE_CATALOG = new Map<string, any>([
+  [
+    "anthropic|claude-opus-4-7",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-sonnet-4-6",
+    {
+      contextWindow: 1_000_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "anthropic|claude-haiku-4-5",
+    {
+      contextWindow: 200_000,
+      maxTokens: 64_000,
+      reasoning: true,
+      cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "openai|gpt-5",
+    {
+      contextWindow: 400_000,
+      maxTokens: 128_000,
+      reasoning: true,
+      cost: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+      input: ["text", "image"],
+    },
+  ],
+  [
+    "opencode|claude-opus-4-7",
+    {
+      // Deliberately different values so tests can prove the candidate-
+      // provider probe order is deterministic (anthropic checked first).
+      contextWindow: 999,
+      maxTokens: 1,
+      reasoning: true,
+      cost: { input: 9, output: 9, cacheRead: 9, cacheWrite: 9 },
+      input: ["text"],
+    },
+  ],
+]);
+
+const fakeProbe: CatalogProbe = (provider, id) =>
+  FAKE_CATALOG.get(`${provider}|${id}`) ?? null;
+
+describe("enrichModelMetadata — catalog matches via probe", () => {
+  it("resolves `cc/claude-opus-4-7` + anthropic-messages to Opus 4.7 catalog entry (1M ctx)", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost).toEqual({
+      input: 5,
+      output: 25,
+      cacheRead: 0.5,
+      cacheWrite: 6.25,
+    });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("resolves bare `claude-sonnet-4-6` + anthropic-messages to Sonnet 4.6 (1M ctx)", () => {
+    const result = enrichModelMetadata("claude-sonnet-4-6", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.reasoning).toBe(true);
+  });
+
+  it("resolves `anthropic/claude-opus-4-7` prefix to Opus 4.7 (1M ctx)", () => {
+    const result = enrichModelMetadata("anthropic/claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("resolves `claude-haiku-4-5` + anthropic-messages to Haiku 4.5 (200k ctx — verifies we don't over-claim)", () => {
+    const result = enrichModelMetadata("claude-haiku-4-5", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.reasoning).toBe(true);
+    expect(result.cost.input).toBe(1);
+    expect(result.cost.output).toBe(5);
+  });
+
+  it("resolves `openrouter/openai/gpt-5` prefix to gpt-5 via openai-completions candidates", () => {
+    const result = enrichModelMetadata("openrouter/openai/gpt-5", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(400_000);
+    expect(result.maxTokens).toBe(128_000);
+    expect(result.reasoning).toBe(true);
+  });
+});
+
+describe("enrichModelMetadata — fallback defaults (no probe or no match)", () => {
+  it("no probe supplied → falls back to api-appropriate default", () => {
+    const result = enrichModelMetadata("cc/claude-opus-4-7", "anthropic-messages");
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+  });
+
+  it("unknown id + anthropic-messages returns 200k / 64k / no reasoning / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-anthropic-model", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(200_000);
+    expect(result.maxTokens).toBe(64_000);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + openai-completions returns 128k / 16k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-openai-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown id + google-generative-ai returns 1M / 65k / zero cost / text+image", () => {
+    const result = enrichModelMetadata("some-unknown-gemini-model", "google-generative-ai", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(65_536);
+    expect(result.reasoning).toBe(false);
+    expect(result.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("prefixed unknown + openai-completions falls back (both prefixed and bare miss)", () => {
+    const result = enrichModelMetadata("minimax/custom-private-model", "openai-completions", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.cost.input).toBe(0);
+  });
+
+  it("no api argument + no probe defaults to openai-completions fallback", () => {
+    const result = enrichModelMetadata("some-unknown-model");
+    expect(result.contextWindow).toBe(128_000);
+    expect(result.maxTokens).toBe(16_384);
+    expect(result.input).toEqual(["text", "image"]);
+  });
+
+  it("unknown api string + probe still probes openai-completions candidates", () => {
+    const result = enrichModelMetadata("some-unknown-model", "some-weird-api", fakeProbe);
+    expect(result.contextWindow).toBe(128_000);
+  });
+
+  it("probe that throws is tolerated (falls through to fallback)", () => {
+    const throwingProbe: CatalogProbe = () => {
+      throw new Error("registry not ready");
+    };
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", throwingProbe);
+    expect(result.contextWindow).toBe(200_000); // anthropic-messages fallback
+  });
+});
+
+describe("enrichModelMetadata — probe order determinism", () => {
+  it("prefers `anthropic` over `opencode` for anthropic-messages (first in candidate list wins)", () => {
+    // The fake catalog has `claude-opus-4-7` under BOTH `anthropic` (1M) and
+    // `opencode` (999). With api=anthropic-messages, candidates = ["anthropic", "opencode"]
+    // so the anthropic entry must win.
+    const result = enrichModelMetadata("claude-opus-4-7", "anthropic-messages", fakeProbe);
+    expect(result.contextWindow).toBe(1_000_000);
+    expect(result.maxTokens).toBe(128_000);
+  });
+
+  it("multi-segment prefix `openrouter/anthropic/claude-opus-4-7` resolves via bare-id lookup", () => {
+    // After stripping the last segment, `claude-opus-4-7` matches `anthropic` (1M).
+    const result = enrichModelMetadata(
+      "openrouter/anthropic/claude-opus-4-7",
+      "anthropic-messages",
+      fakeProbe,
+    );
+    expect(result.contextWindow).toBe(1_000_000);
+  });
+});

package/packages/extension/src/__tests__/event-forwarder.test.ts

@@ -74,6 +74,36 @@ describe("mapEventToProtocol", () => {
     expect(result.event.data).toEqual(piEvent);
   });
 
+  it("should map an entry_persisted event (per fix-per-message-fork)", () => {
+    const piEvent = {
+      type: "entry_persisted",
+      entryId: "abc-123",
+      nonce: "n-7",
+    };
+    const result = mapEventToProtocol(sessionId, piEvent);
+    expect(result.type).toBe("event_forward");
+    expect(result.sessionId).toBe(sessionId);
+    expect(result.event.eventType).toBe("entry_persisted");
+    expect(result.event.data).toMatchObject({
+      type: "entry_persisted",
+      entryId: "abc-123",
+      nonce: "n-7",
+    });
+  });
+
+  it("should map a message_end event with nonce (per fix-per-message-fork)", () => {
+    const piEvent = {
+      type: "message_end",
+      message: { role: "assistant", content: "hi", id: "asst-9" },
+      entryId: "asst-9",
+      nonce: "n-7",
+    };
+    const result = mapEventToProtocol(sessionId, piEvent);
+    expect(result.event.eventType).toBe("message_end");
+    expect((result.event.data as any).nonce).toBe("n-7");
+    expect((result.event.data as any).entryId).toBe("asst-9");
+  });
+
   it("should strip non-serializable fields", () => {
     const piEvent = {
       type: "test_event",