@vellumai/assistant 0.4.35 → 0.4.37

package/src/__tests__/llm-usage-store.test.ts

@@ -26,6 +26,9 @@ mock.module("../util/logger.js", () => ({
 
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import {
+  getUsageDayBuckets,
+  getUsageGroupBreakdown,
+  getUsageTotals,
   listUsageEvents,
   recordUsageEvent,
 } from "../memory/llm-usage-store.js";
@@ -69,6 +72,19 @@ const unpricedResult: PricingResult = {
   pricingStatus: "unpriced",
 };
 
+/** Insert an event at a specific epoch-millis timestamp. */
+function insertEventAt(
+  timestamp: number,
+  inputOverrides?: Partial<UsageEventInput>,
+  pricing: PricingResult = pricedResult,
+): void {
+  const event = recordUsageEvent(makeInput(inputOverrides), pricing);
+  const db = getDb();
+  db.run(
+    `UPDATE llm_usage_events SET created_at = ${timestamp} WHERE id = '${event.id}'`,
+  );
+}
+
 describe("recordUsageEvent", () => {
   beforeEach(() => {
     const db = getDb();
@@ -245,3 +261,331 @@ describe("listUsageEvents", () => {
     expect(typeof event.pricingStatus).toBe("string");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Aggregation query tests
+// ---------------------------------------------------------------------------
+
+describe("getUsageTotals", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+  });
+
+  test("returns zeros when no events exist in range", () => {
+    const totals = getUsageTotals({ from: 0, to: 99999 });
+    expect(totals.totalInputTokens).toBe(0);
+    expect(totals.totalOutputTokens).toBe(0);
+    expect(totals.totalCacheCreationTokens).toBe(0);
+    expect(totals.totalCacheReadTokens).toBe(0);
+    expect(totals.totalEstimatedCostUsd).toBe(0);
+    expect(totals.eventCount).toBe(0);
+    expect(totals.pricedEventCount).toBe(0);
+    expect(totals.unpricedEventCount).toBe(0);
+  });
+
+  test("sums tokens and cost across priced events", () => {
+    insertEventAt(
+      1000,
+      { inputTokens: 100, outputTokens: 50 },
+      {
+        estimatedCostUsd: 0.01,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      2000,
+      { inputTokens: 200, outputTokens: 100 },
+      {
+        estimatedCostUsd: 0.02,
+        pricingStatus: "priced",
+      },
+    );
+
+    const totals = getUsageTotals({ from: 0, to: 5000 });
+    expect(totals.totalInputTokens).toBe(300);
+    expect(totals.totalOutputTokens).toBe(150);
+    expect(totals.totalEstimatedCostUsd).toBeCloseTo(0.03);
+    expect(totals.eventCount).toBe(2);
+    expect(totals.pricedEventCount).toBe(2);
+    expect(totals.unpricedEventCount).toBe(0);
+  });
+
+  test("counts priced and unpriced events separately", () => {
+    insertEventAt(1000, {}, pricedResult);
+    insertEventAt(
+      2000,
+      { provider: "ollama", model: "llama3" },
+      unpricedResult,
+    );
+
+    const totals = getUsageTotals({ from: 0, to: 5000 });
+    expect(totals.eventCount).toBe(2);
+    expect(totals.pricedEventCount).toBe(1);
+    expect(totals.unpricedEventCount).toBe(1);
+  });
+
+  test("respects time range boundaries (inclusive)", () => {
+    insertEventAt(1000);
+    insertEventAt(2000);
+    insertEventAt(3000);
+
+    // Only the middle event
+    const totals = getUsageTotals({ from: 2000, to: 2000 });
+    expect(totals.eventCount).toBe(1);
+  });
+
+  test("excludes events outside the time range", () => {
+    insertEventAt(500);
+    insertEventAt(5000);
+
+    const totals = getUsageTotals({ from: 1000, to: 4000 });
+    expect(totals.eventCount).toBe(0);
+  });
+
+  test("sums cache tokens including nulls", () => {
+    insertEventAt(1000, {
+      cacheCreationInputTokens: 50,
+      cacheReadInputTokens: 100,
+    });
+    insertEventAt(2000, {
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null,
+    });
+
+    const totals = getUsageTotals({ from: 0, to: 5000 });
+    expect(totals.totalCacheCreationTokens).toBe(50);
+    expect(totals.totalCacheReadTokens).toBe(100);
+  });
+});
+
+describe("getUsageDayBuckets", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+  });
+
+  // Helper: epoch millis for a UTC date
+  function utcMs(year: number, month: number, day: number, hour = 0): number {
+    return Date.UTC(year, month - 1, day, hour);
+  }
+
+  test("returns empty array when no events exist", () => {
+    const buckets = getUsageDayBuckets({ from: 0, to: 99999999999 });
+    expect(buckets).toHaveLength(0);
+  });
+
+  test("groups events into correct day buckets", () => {
+    const day1Start = utcMs(2025, 3, 1, 0);
+    const day1Mid = utcMs(2025, 3, 1, 12);
+    const day2Start = utcMs(2025, 3, 2, 6);
+
+    insertEventAt(day1Start, { inputTokens: 100, outputTokens: 10 });
+    insertEventAt(day1Mid, { inputTokens: 200, outputTokens: 20 });
+    insertEventAt(day2Start, { inputTokens: 300, outputTokens: 30 });
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 3),
+    });
+
+    expect(buckets).toHaveLength(2);
+    expect(buckets[0].date).toBe("2025-03-01");
+    expect(buckets[0].totalInputTokens).toBe(300);
+    expect(buckets[0].totalOutputTokens).toBe(30);
+    expect(buckets[0].eventCount).toBe(2);
+
+    expect(buckets[1].date).toBe("2025-03-02");
+    expect(buckets[1].totalInputTokens).toBe(300);
+    expect(buckets[1].totalOutputTokens).toBe(30);
+    expect(buckets[1].eventCount).toBe(1);
+  });
+
+  test("buckets are ordered by date ascending", () => {
+    insertEventAt(utcMs(2025, 3, 3));
+    insertEventAt(utcMs(2025, 3, 1));
+    insertEventAt(utcMs(2025, 3, 2));
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 4),
+    });
+    expect(buckets.map((b) => b.date)).toEqual([
+      "2025-03-01",
+      "2025-03-02",
+      "2025-03-03",
+    ]);
+  });
+
+  test("handles day boundary correctly (midnight UTC)", () => {
+    // Last millisecond of March 1 and first millisecond of March 2
+    const endOfDay1 = utcMs(2025, 3, 1, 23) + 59 * 60 * 1000 + 59 * 1000;
+    const startOfDay2 = utcMs(2025, 3, 2, 0);
+
+    insertEventAt(endOfDay1, { inputTokens: 111 });
+    insertEventAt(startOfDay2, { inputTokens: 222 });
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 3),
+    });
+
+    expect(buckets).toHaveLength(2);
+    expect(buckets[0].date).toBe("2025-03-01");
+    expect(buckets[0].totalInputTokens).toBe(111);
+    expect(buckets[1].date).toBe("2025-03-02");
+    expect(buckets[1].totalInputTokens).toBe(222);
+  });
+
+  test("sums cost correctly with mixed priced/unpriced events", () => {
+    const day = utcMs(2025, 3, 1);
+    insertEventAt(day, {}, { estimatedCostUsd: 0.05, pricingStatus: "priced" });
+    insertEventAt(day + 1000, { provider: "ollama" }, unpricedResult);
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 2),
+    });
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
+    expect(buckets[0].eventCount).toBe(2);
+  });
+});
+
+describe("getUsageGroupBreakdown", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+  });
+
+  test("returns empty array when no events exist", () => {
+    const groups = getUsageGroupBreakdown({ from: 0, to: 99999 }, "actor");
+    expect(groups).toHaveLength(0);
+  });
+
+  test("groups by actor", () => {
+    insertEventAt(
+      1000,
+      { actor: "main_agent", inputTokens: 100 },
+      {
+        estimatedCostUsd: 0.01,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      2000,
+      { actor: "main_agent", inputTokens: 200 },
+      {
+        estimatedCostUsd: 0.02,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      3000,
+      { actor: "title_generator", inputTokens: 50 },
+      {
+        estimatedCostUsd: 0.005,
+        pricingStatus: "priced",
+      },
+    );
+
+    const groups = getUsageGroupBreakdown({ from: 0, to: 5000 }, "actor");
+    expect(groups).toHaveLength(2);
+
+    // Ordered by cost descending
+    expect(groups[0].group).toBe("main_agent");
+    expect(groups[0].totalInputTokens).toBe(300);
+    expect(groups[0].totalEstimatedCostUsd).toBeCloseTo(0.03);
+    expect(groups[0].eventCount).toBe(2);
+
+    expect(groups[1].group).toBe("title_generator");
+    expect(groups[1].totalInputTokens).toBe(50);
+    expect(groups[1].eventCount).toBe(1);
+  });
+
+  test("groups by provider", () => {
+    insertEventAt(
+      1000,
+      { provider: "anthropic" },
+      {
+        estimatedCostUsd: 0.05,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(2000, { provider: "ollama" }, unpricedResult);
+
+    const groups = getUsageGroupBreakdown({ from: 0, to: 5000 }, "provider");
+    expect(groups).toHaveLength(2);
+    expect(groups[0].group).toBe("anthropic");
+    expect(groups[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
+    expect(groups[1].group).toBe("ollama");
+    expect(groups[1].totalEstimatedCostUsd).toBe(0);
+  });
+
+  test("groups by model", () => {
+    insertEventAt(
+      1000,
+      { model: "claude-sonnet-4-20250514" },
+      {
+        estimatedCostUsd: 0.03,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      2000,
+      { model: "claude-sonnet-4-20250514" },
+      {
+        estimatedCostUsd: 0.02,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(3000, { model: "llama3" }, unpricedResult);
+
+    const groups = getUsageGroupBreakdown({ from: 0, to: 5000 }, "model");
+    expect(groups).toHaveLength(2);
+    expect(groups[0].group).toBe("claude-sonnet-4-20250514");
+    expect(groups[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
+    expect(groups[0].eventCount).toBe(2);
+    expect(groups[1].group).toBe("llama3");
+  });
+
+  test("respects time range", () => {
+    insertEventAt(1000, { actor: "main_agent" });
+    insertEventAt(5000, { actor: "title_generator" });
+
+    const groups = getUsageGroupBreakdown({ from: 2000, to: 4000 }, "actor");
+    expect(groups).toHaveLength(0);
+  });
+
+  test("orders groups by estimated cost descending", () => {
+    insertEventAt(
+      1000,
+      { actor: "main_agent" },
+      {
+        estimatedCostUsd: 0.01,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      2000,
+      { actor: "title_generator" },
+      {
+        estimatedCostUsd: 0.05,
+        pricingStatus: "priced",
+      },
+    );
+    insertEventAt(
+      3000,
+      { actor: "context_compactor" },
+      {
+        estimatedCostUsd: 0.03,
+        pricingStatus: "priced",
+      },
+    );
+
+    const groups = getUsageGroupBreakdown({ from: 0, to: 5000 }, "actor");
+    expect(groups[0].group).toBe("title_generator");
+    expect(groups[1].group).toBe("context_compactor");
+    expect(groups[2].group).toBe("main_agent");
+  });
+});

package/src/__tests__/mcp-client-auth.test.ts

@@ -3,8 +3,8 @@ import { describe, expect, jest, mock, test } from "bun:test";
 // Mock secure-keys so McpOAuthProvider doesn't try to access the keychain
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: jest.fn().mockResolvedValue(null),
-  setSecureKeyAsync: jest.fn().mockResolvedValue(undefined),
-  deleteSecureKeyAsync: jest.fn().mockResolvedValue(undefined),
+  setSecureKeyAsync: jest.fn().mockResolvedValue(true),
+  deleteSecureKeyAsync: jest.fn().mockResolvedValue("deleted"),
 }));
 
 const { McpClient } = await import("../mcp/client.js");

package/src/__tests__/media-reuse-story.e2e.test.ts

@@ -81,7 +81,7 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 mock.module("../security/secure-keys.js", () => ({
   getSecureKey: (account: string) => secureKeyValues.get(account),
   setSecureKey: () => true,
-  deleteSecureKey: () => true,
+  deleteSecureKey: () => "deleted",
   listSecureKeys: () => [],
   getBackendType: () => "encrypted",
   _resetBackend: () => {},

package/src/__tests__/migration-transport.test.ts

@@ -191,6 +191,55 @@ describe("Auth headers", () => {
     expect(headers["Authorization"]).toBeUndefined();
   });
 
+  test("managed request includes Vellum-Organization-Id from defaultHeaders", async () => {
+    const { fetchFn, captured } = capturingFetch(200, {
+      is_valid: true,
+      errors: [],
+      manifest: {},
+    });
+    await validateBundle(
+      managedConfig({
+        fetchFn,
+        defaultHeaders: { "Vellum-Organization-Id": "org-123" },
+      }),
+      sampleFileData,
+    );
+    const headers = captured[0].init.headers as Record<string, string>;
+    expect(headers["Vellum-Organization-Id"]).toBe("org-123");
+    // Managed auth header should still be present
+    expect(headers["X-Session-Token"]).toBe("test-session-token");
+  });
+
+  test("runtime request is unchanged when no defaultHeaders provided", async () => {
+    const { fetchFn, captured } = capturingFetch(200, {
+      is_valid: true,
+      errors: [],
+      manifest: {},
+    });
+    await validateBundle(runtimeConfig({ fetchFn }), sampleFileData);
+    const headers = captured[0].init.headers as Record<string, string>;
+    expect(headers["Authorization"]).toBe("Bearer test-jwt");
+    expect(headers["Vellum-Organization-Id"]).toBeUndefined();
+  });
+
+  test("auth header wins over same-named entry in defaultHeaders", async () => {
+    const { fetchFn, captured } = capturingFetch(200, {
+      is_valid: true,
+      errors: [],
+      manifest: {},
+    });
+    // defaultHeaders sets X-Session-Token, but authHeader should override it
+    await validateBundle(
+      managedConfig({
+        fetchFn,
+        defaultHeaders: { "X-Session-Token": "should-be-overridden" },
+      }),
+      sampleFileData,
+    );
+    const headers = captured[0].init.headers as Record<string, string>;
+    expect(headers["X-Session-Token"]).toBe("test-session-token");
+  });
+
   test("no auth header when authHeader is not provided", async () => {
     const { fetchFn, captured } = capturingFetch(200, {
       is_valid: true,

package/src/__tests__/notification-broadcaster.test.ts

@@ -8,9 +8,12 @@
  * - Reports delivery results per channel
  * - Emits notification_thread_created only when a new conversation is created
  * - Does NOT emit notification_thread_created when reusing an existing thread
+ * - Threads destination binding context into conversation pairing for external channels
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { PairingOptions } from "../notifications/conversation-pairing.js";
 
 // -- Mocks (must be declared before importing modules that depend on them) ----
 
@@ -21,12 +24,26 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Mock destination-resolver to return a destination for every requested channel
+// Mock destination-resolver to return a destination for every requested channel.
+// External channels (sms, telegram, slack) include bindingContext.
 mock.module("../notifications/destination-resolver.js", () => ({
   resolveDestinations: (channels: string[]) => {
     const m = new Map();
     for (const ch of channels) {
-      m.set(ch, { channel: ch, endpoint: `mock-${ch}` });
+      const isExternal = ch === "sms" || ch === "telegram" || ch === "slack";
+      m.set(ch, {
+        channel: ch,
+        endpoint: `mock-${ch}`,
+        ...(isExternal
+          ? {
+              bindingContext: {
+                sourceChannel: ch,
+                externalChatId: `ext-chat-${ch}`,
+                externalUserId: `ext-user-${ch}`,
+              },
+            }
+          : {}),
+      });
     }
     return m;
   },
@@ -39,15 +56,27 @@ mock.module("../notifications/deliveries-store.js", () => ({
 }));
 
 // Configurable mock for conversation-pairing.
-// By default returns a "new conversation" result with a stable UUID.
+// Captures call arguments so tests can inspect what was passed in.
 // Set `nextPairingResult` to override the return value for a single call.
 let nextPairingResult:
   | import("../notifications/conversation-pairing.js").PairingResult
   | null = null;
 let pairingCallCount = 0;
 
+interface PairingCall {
+  channel: string;
+  options?: PairingOptions;
+}
+const pairingCalls: PairingCall[] = [];
+
 mock.module("../notifications/conversation-pairing.js", () => ({
-  pairDeliveryWithConversation: async () => {
+  pairDeliveryWithConversation: async (
+    _signal: unknown,
+    channel: string,
+    _copy: unknown,
+    options?: PairingOptions,
+  ) => {
+    pairingCalls.push({ channel, options });
     if (nextPairingResult) {
       const result = nextPairingResult;
       nextPairingResult = null;
@@ -138,6 +167,10 @@ class MockAdapter implements ChannelAdapter {
 // -- Tests -------------------------------------------------------------------
 
 describe("notification broadcaster", () => {
+  beforeEach(() => {
+    pairingCalls.length = 0;
+    nextPairingResult = null;
+  });
   test("dispatches to the vellum adapter when selected", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
@@ -381,4 +414,171 @@ describe("notification broadcaster", () => {
     expect(dispatchCalls).toHaveLength(1);
     expect(dispatchCalls[0].conversationId).toBe("conv-reused-456");
   });
+
+  // ── Destination binding context ────────────────────────────────────
+
+  test("SMS delivery carries destination binding context into pairing", async () => {
+    const smsAdapter = new MockAdapter("sms");
+    const broadcaster = new NotificationBroadcaster([smsAdapter]);
+
+    const signal = makeSignal();
+    const decision = makeDecision({
+      selectedChannels: ["sms"],
+      renderedCopy: {
+        sms: { title: "SMS Alert", body: "Something happened" },
+      },
+    });
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    const smsCall = pairingCalls.find((c) => c.channel === "sms");
+    expect(smsCall).toBeDefined();
+    expect(smsCall!.options?.bindingContext).toEqual({
+      sourceChannel: "sms",
+      externalChatId: "ext-chat-sms",
+      externalUserId: "ext-user-sms",
+    });
+  });
+
+  test("Telegram delivery carries destination binding context into pairing", async () => {
+    const telegramAdapter = new MockAdapter("telegram");
+    const broadcaster = new NotificationBroadcaster([telegramAdapter]);
+
+    const signal = makeSignal();
+    const decision = makeDecision({
+      selectedChannels: ["telegram"],
+      renderedCopy: {
+        telegram: { title: "Telegram Alert", body: "Something happened" },
+      },
+    });
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    const telegramCall = pairingCalls.find((c) => c.channel === "telegram");
+    expect(telegramCall).toBeDefined();
+    expect(telegramCall!.options?.bindingContext).toEqual({
+      sourceChannel: "telegram",
+      externalChatId: "ext-chat-telegram",
+      externalUserId: "ext-user-telegram",
+    });
+  });
+
+  test("Slack delivery carries destination binding context into pairing", async () => {
+    const slackAdapter = new MockAdapter("slack");
+    const broadcaster = new NotificationBroadcaster([slackAdapter]);
+
+    const signal = makeSignal();
+    const decision = makeDecision({
+      selectedChannels: ["slack"],
+      renderedCopy: {
+        slack: { title: "Slack Alert", body: "Something happened" },
+      },
+    });
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    const slackCall = pairingCalls.find((c) => c.channel === "slack");
+    expect(slackCall).toBeDefined();
+    expect(slackCall!.options?.bindingContext).toEqual({
+      sourceChannel: "slack",
+      externalChatId: "ext-chat-slack",
+      externalUserId: "ext-user-slack",
+    });
+  });
+
+  test("reused thread via binding-key continuation does NOT emit class-level onThreadCreated", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const ipcCalls: ThreadCreatedInfo[] = [];
+    broadcaster.setOnThreadCreated((info) => ipcCalls.push(info));
+
+    // Simulate binding-key continuation: pairing reuses an existing bound
+    // conversation (createdNewConversation=false, strategy=continue_existing_conversation)
+    nextPairingResult = {
+      conversationId: "conv-bound-sms-001",
+      messageId: "msg-bound-sms-001",
+      strategy: "continue_existing_conversation" as const,
+      createdNewConversation: false,
+      threadDecisionFallbackUsed: false,
+    };
+
+    const signal = makeSignal();
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    // The class-level IPC callback should NOT fire because
+    // createdNewConversation is false — the thread already exists
+    // in the external channel and the client already knows about it.
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("fresh conversation for continue_existing_conversation does NOT emit class-level onThreadCreated", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const ipcCalls: ThreadCreatedInfo[] = [];
+    broadcaster.setOnThreadCreated((info) => ipcCalls.push(info));
+
+    // First delivery to a new destination: creates a fresh conversation but
+    // the strategy is continue_existing_conversation (not start_new_conversation),
+    // so the IPC event should NOT fire — these are background threads not
+    // meant to appear in the sidebar.
+    nextPairingResult = {
+      conversationId: "conv-new-telegram-dest",
+      messageId: "msg-new-telegram-dest",
+      strategy: "continue_existing_conversation" as const,
+      createdNewConversation: true,
+      threadDecisionFallbackUsed: false,
+    };
+
+    const signal = makeSignal();
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    // Even though createdNewConversation is true, the strategy is
+    // continue_existing_conversation, so the IPC gate rejects it.
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("per-dispatch onThreadCreated fires for reused binding-key conversation", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const dispatchCalls: ThreadCreatedInfo[] = [];
+
+    // Binding-key reuse: conversation already exists
+    nextPairingResult = {
+      conversationId: "conv-bound-telegram-456",
+      messageId: "msg-bound-telegram-789",
+      strategy: "continue_existing_conversation" as const,
+      createdNewConversation: false,
+      threadDecisionFallbackUsed: false,
+    };
+
+    const signal = makeSignal();
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision, {
+      onThreadCreated: (info) => dispatchCalls.push(info),
+    });
+
+    // The per-dispatch callback SHOULD fire regardless of reuse
+    // (callers like dispatchGuardianQuestion need it for bookkeeping)
+    expect(dispatchCalls).toHaveLength(1);
+    expect(dispatchCalls[0].conversationId).toBe("conv-bound-telegram-456");
+  });
+
+  test("vellum delivery does NOT carry binding context into pairing", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+    const signal = makeSignal();
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    const vellumCall = pairingCalls.find((c) => c.channel === "vellum");
+    expect(vellumCall).toBeDefined();
+    expect(vellumCall!.options?.bindingContext).toBeUndefined();
+  });
 });