@vellumai/assistant 0.4.35 → 0.4.37

package/src/__tests__/notification-deep-link.test.ts

@@ -7,7 +7,9 @@
  * the conversation was newly created or reused.
  */
 
-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) ----
 
@@ -18,12 +20,129 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// Mock destination-resolver for broadcaster tests
+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}` });
+    }
+    return m;
+  },
+}));
+
+// Mock deliveries-store to avoid DB access
+mock.module("../notifications/deliveries-store.js", () => ({
+  createDelivery: () => {},
+  updateDeliveryStatus: () => {},
+  findDeliveryByDecisionAndChannel: () => undefined,
+}));
+
+// Configurable mock for conversation-pairing
+let nextPairingResult:
+  | import("../notifications/conversation-pairing.js").PairingResult
+  | null = null;
+let pairingCallCount = 0;
+
+mock.module("../notifications/conversation-pairing.js", () => ({
+  pairDeliveryWithConversation: async (
+    _signal: unknown,
+    _channel: string,
+    _copy: unknown,
+    _options?: PairingOptions,
+  ) => {
+    if (nextPairingResult) {
+      const result = nextPairingResult;
+      nextPairingResult = null;
+      return result;
+    }
+    const id = `mock-conv-${++pairingCallCount}`;
+    return {
+      conversationId: id,
+      messageId: `mock-msg-${pairingCallCount}`,
+      strategy: "start_new_conversation" as const,
+      createdNewConversation: true,
+      threadDecisionFallbackUsed: false,
+    };
+  },
+}));
+
 import type { ServerMessage } from "../daemon/ipc-contract.js";
 import { VellumAdapter } from "../notifications/adapters/macos.js";
+import { NotificationBroadcaster } from "../notifications/broadcaster.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type {
+  ChannelAdapter,
+  ChannelDeliveryPayload,
+  ChannelDestination,
+  DeliveryResult,
+  NotificationChannel,
+  NotificationDecision,
+} from "../notifications/types.js";
+
+// -- Helpers -----------------------------------------------------------------
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-deeplink-001",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceSessionId: "sess-001",
+    sourceEventName: "test.event",
+    contextPayload: {},
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+function makeDecision(
+  overrides?: Partial<NotificationDecision>,
+): NotificationDecision {
+  return {
+    shouldNotify: true,
+    selectedChannels: ["vellum"],
+    reasoningSummary: "Deep-link test decision",
+    renderedCopy: {
+      vellum: { title: "Test Alert", body: "Something happened" },
+    },
+    dedupeKey: "deeplink-test-001",
+    confidence: 0.9,
+    fallbackUsed: false,
+    ...overrides,
+  };
+}
+
+class MockAdapter implements ChannelAdapter {
+  readonly channel: NotificationChannel;
+  sent: ChannelDeliveryPayload[] = [];
+
+  constructor(channel: NotificationChannel) {
+    this.channel = channel;
+  }
+
+  async send(
+    payload: ChannelDeliveryPayload,
+    _dest: ChannelDestination,
+  ): Promise<DeliveryResult> {
+    this.sent.push(payload);
+    return { success: true };
+  }
+}
 
 // -- Tests -------------------------------------------------------------------
 
 describe("notification deep-link metadata", () => {
+  beforeEach(() => {
+    nextPairingResult = null;
+  });
+
   describe("VellumAdapter", () => {
     test("broadcasts notification_intent with deepLinkMetadata from payload", async () => {
       const messages: ServerMessage[] = [];
@@ -221,5 +340,250 @@ describe("notification deep-link metadata", () => {
       const metadata = msg.deepLinkMetadata as Record<string, unknown>;
       expect(metadata.conversationId).toBe("conv-reused-thread-042");
     });
+
+    // ── Reused thread deep-link stability regressions ─────────────────
+
+    test("reused thread preserves the same conversationId across follow-up notifications", async () => {
+      const messages: ServerMessage[] = [];
+      const adapter = new VellumAdapter((msg) => messages.push(msg));
+
+      const stableConversationId = "conv-bound-telegram-dest-001";
+
+      // First notification to a bound destination
+      await adapter.send(
+        {
+          sourceEventName: "guardian.question",
+          copy: { title: "Question 1", body: "Allow file read?" },
+          deepLinkTarget: {
+            conversationId: stableConversationId,
+            messageId: "msg-seed-1",
+          },
+        },
+        { channel: "vellum" },
+      );
+
+      // Follow-up notification reuses the same bound conversation
+      await adapter.send(
+        {
+          sourceEventName: "guardian.question",
+          copy: { title: "Question 2", body: "Allow network access?" },
+          deepLinkTarget: {
+            conversationId: stableConversationId,
+            messageId: "msg-seed-2",
+          },
+        },
+        { channel: "vellum" },
+      );
+
+      expect(messages).toHaveLength(2);
+
+      const meta1 = (messages[0] as unknown as Record<string, unknown>)
+        .deepLinkMetadata as Record<string, unknown>;
+      const meta2 = (messages[1] as unknown as Record<string, unknown>)
+        .deepLinkMetadata as Record<string, unknown>;
+
+      // Both deep links point to the same conversation
+      expect(meta1.conversationId).toBe(stableConversationId);
+      expect(meta2.conversationId).toBe(stableConversationId);
+
+      // But each has a distinct messageId for scroll-to-message targeting
+      expect(meta1.messageId).toBe("msg-seed-1");
+      expect(meta2.messageId).toBe("msg-seed-2");
+    });
+
+    test("reused thread deep-link messageId changes per delivery for scroll targeting", async () => {
+      const messages: ServerMessage[] = [];
+      const adapter = new VellumAdapter((msg) => messages.push(msg));
+
+      const conversationId = "conv-reused-scroll-test";
+
+      await adapter.send(
+        {
+          sourceEventName: "reminder.fired",
+          copy: { title: "Reminder", body: "First" },
+          deepLinkTarget: { conversationId, messageId: "msg-a" },
+        },
+        { channel: "vellum" },
+      );
+
+      await adapter.send(
+        {
+          sourceEventName: "reminder.fired",
+          copy: { title: "Reminder", body: "Second" },
+          deepLinkTarget: { conversationId, messageId: "msg-b" },
+        },
+        { channel: "vellum" },
+      );
+
+      const meta1 = (messages[0] as unknown as Record<string, unknown>)
+        .deepLinkMetadata as Record<string, unknown>;
+      const meta2 = (messages[1] as unknown as Record<string, unknown>)
+        .deepLinkMetadata as Record<string, unknown>;
+
+      // Same conversation but different message targets
+      expect(meta1.conversationId).toBe(conversationId);
+      expect(meta2.conversationId).toBe(conversationId);
+      expect(meta1.messageId).not.toBe(meta2.messageId);
+    });
+
+    test("deep-link metadata is stable when conversation is reused via binding-key continuation", async () => {
+      const messages: ServerMessage[] = [];
+      const adapter = new VellumAdapter((msg) => messages.push(msg));
+
+      // Simulates the binding-key continuation path: multiple notifications
+      // to the same SMS destination reuse the same bound conversation, and
+      // the deep-link metadata should reflect the bound conversation ID
+      // rather than creating a new one each time.
+      const boundConvId = "conv-sms-bound-+15551234567";
+
+      for (const body of ["Alert 1", "Alert 2", "Alert 3"]) {
+        await adapter.send(
+          {
+            sourceEventName: "activity.complete",
+            copy: { title: "Activity", body },
+            deepLinkTarget: { conversationId: boundConvId },
+          },
+          { channel: "vellum" },
+        );
+      }
+
+      expect(messages).toHaveLength(3);
+
+      // All three notifications deep-link to the same bound conversation
+      for (const msg of messages) {
+        const metadata = (msg as unknown as Record<string, unknown>)
+          .deepLinkMetadata as Record<string, unknown>;
+        expect(metadata.conversationId).toBe(boundConvId);
+      }
+    });
+  });
+
+  // ── NotificationBroadcaster deep-link injection ──────────────────────
+  //
+  // These tests exercise the production code path where the broadcaster
+  // calls pairDeliveryWithConversation() and merges the pairing result's
+  // conversationId/messageId into deepLinkTarget before passing to the
+  // adapter. This catches regressions that the adapter-only tests above
+  // would miss (e.g. broadcaster stops merging pairing results).
+
+  describe("NotificationBroadcaster deep-link injection", () => {
+    test("broadcaster merges pairing conversationId into deepLinkTarget for vellum", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      nextPairingResult = {
+        conversationId: "conv-paired-abc",
+        messageId: "msg-paired-abc",
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: true,
+        threadDecisionFallbackUsed: false,
+      };
+
+      const signal = makeSignal();
+      const decision = makeDecision();
+
+      await broadcaster.broadcastDecision(signal, decision);
+
+      expect(vellumAdapter.sent).toHaveLength(1);
+      const deepLink = vellumAdapter.sent[0].deepLinkTarget;
+      expect(deepLink).toBeDefined();
+      expect(deepLink!.conversationId).toBe("conv-paired-abc");
+    });
+
+    test("broadcaster merges pairing messageId into deepLinkTarget for vellum", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      nextPairingResult = {
+        conversationId: "conv-paired-def",
+        messageId: "msg-paired-def",
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: true,
+        threadDecisionFallbackUsed: false,
+      };
+
+      const signal = makeSignal();
+      const decision = makeDecision();
+
+      await broadcaster.broadcastDecision(signal, decision);
+
+      expect(vellumAdapter.sent).toHaveLength(1);
+      const deepLink = vellumAdapter.sent[0].deepLinkTarget;
+      expect(deepLink).toBeDefined();
+      expect(deepLink!.messageId).toBe("msg-paired-def");
+    });
+
+    test("reused conversation deep-link points to the reused conversationId", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      nextPairingResult = {
+        conversationId: "conv-reused-xyz",
+        messageId: "msg-reused-xyz",
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: false,
+        threadDecisionFallbackUsed: false,
+      };
+
+      const signal = makeSignal();
+      const decision = makeDecision({
+        threadActions: {
+          vellum: {
+            action: "reuse_existing",
+            conversationId: "conv-original-placeholder",
+          },
+        },
+      });
+
+      await broadcaster.broadcastDecision(signal, decision);
+
+      expect(vellumAdapter.sent).toHaveLength(1);
+      const deepLink = vellumAdapter.sent[0].deepLinkTarget;
+      expect(deepLink).toBeDefined();
+      // The deep-link should use the pairing result, not the original placeholder
+      expect(deepLink!.conversationId).toBe("conv-reused-xyz");
+    });
+
+    test("deep-link conversationId is stable across multiple deliveries to the same reused conversation", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      const stableConvId = "conv-stable-reuse-001";
+
+      // First delivery
+      nextPairingResult = {
+        conversationId: stableConvId,
+        messageId: "msg-delivery-1",
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: false,
+        threadDecisionFallbackUsed: false,
+      };
+
+      await broadcaster.broadcastDecision(makeSignal(), makeDecision());
+
+      // Second delivery — same conversation reused via binding-key
+      nextPairingResult = {
+        conversationId: stableConvId,
+        messageId: "msg-delivery-2",
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: false,
+        threadDecisionFallbackUsed: false,
+      };
+
+      await broadcaster.broadcastDecision(makeSignal(), makeDecision());
+
+      expect(vellumAdapter.sent).toHaveLength(2);
+
+      const deepLink1 = vellumAdapter.sent[0].deepLinkTarget;
+      const deepLink2 = vellumAdapter.sent[1].deepLinkTarget;
+
+      // Both deliveries point to the same stable conversation
+      expect(deepLink1!.conversationId).toBe(stableConvId);
+      expect(deepLink2!.conversationId).toBe(stableConvId);
+
+      // But each has a distinct messageId for scroll targeting
+      expect(deepLink1!.messageId).toBe("msg-delivery-1");
+      expect(deepLink2!.messageId).toBe("msg-delivery-2");
+    });
   });
 });

package/src/__tests__/oauth-connect-handler.test.ts

@@ -67,9 +67,9 @@ mock.module("../security/secure-keys.js", () => ({
   deleteSecureKey: (account: string) => {
     if (account in secureKeyStore) {
       delete secureKeyStore[account];
-      return true;
+      return "deleted";
     }
-    return false;
+    return "not-found";
   },
   listSecureKeys: () => Object.keys(secureKeyStore),
   getBackendType: () => "encrypted",

package/src/__tests__/onboarding-starter-tasks.test.ts

@@ -10,7 +10,10 @@ const TEST_DIR = join(
 
 import { mock } from "bun:test";
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getRootDir: () => TEST_DIR,
   getDataDir: () => TEST_DIR,
   getWorkspaceDir: () => TEST_DIR,
@@ -34,19 +37,29 @@ mock.module("../util/platform.js", () => ({
   isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
+  readSessionToken: () => null,
   removeSocketFile: () => {},
   migratePath: () => {},
   migrateToWorkspaceLayout: () => {},
   migrateToDataLayout: () => {},
+  readLockfile: () => null,
+  writeLockfile: () => {},
 }));
 
+const noopLogger = new Proxy({} as Record<string, unknown>, {
+  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+});
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
   isDebug: () => false,
   truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
 }));
 
 const { buildStarterTaskPlaybookSection, buildSystemPrompt } =

package/src/__tests__/proxy-approval-callback.test.ts

@@ -26,7 +26,7 @@ mock.module("../config/loader.js", () => ({
 
     provider: "mock-provider",
     timeouts: { permissionTimeoutSec: 5 },
-    permissions: { mode: "legacy" },
+    permissions: { mode: "workspace" },
     skills: { load: { extraDirs: [] } },
   }),
 }));

package/src/__tests__/recording-handler.test.ts

@@ -24,7 +24,7 @@ mock.module("../config/loader.js", () => ({
 
     daemon: { standaloneRecording: true },
     provider: "mock-provider",
-    permissions: { mode: "legacy" },
+    permissions: { mode: "workspace" },
     apiKeys: {},
     sandbox: { enabled: false },
     timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },

package/src/__tests__/recording-intent-handler.test.ts

@@ -21,7 +21,10 @@ const noopLogger = {
   child: () => noopLogger,
 };
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () => noopLogger,
   isDebug: () => false,
   truncateForLog: (v: string) => v,
@@ -34,7 +37,7 @@ mock.module("../config/loader.js", () => ({
     daemon: { standaloneRecording: true },
     provider: "mock-provider",
     model: "mock-model",
-    permissions: { mode: "legacy" },
+    permissions: { mode: "workspace" },
     apiKeys: {},
     sandbox: { enabled: false },
     timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
@@ -342,8 +345,10 @@ mock.module("../providers/provider-send-message.js", () => ({
 // ── Mock external conversation store ───────────────────────────────────────
 
 mock.module("../memory/external-conversation-store.js", () => ({
+  getBindingByChannelChat: () => null,
   getBindingsForConversations: () => new Map(),
   upsertBinding: () => {},
+  upsertOutboundBinding: () => {},
 }));
 
 // ── Mock subagent manager ──────────────────────────────────────────────────

package/src/__tests__/recording-state-machine.test.ts

@@ -24,7 +24,7 @@ mock.module("../config/loader.js", () => ({
 
     daemon: { standaloneRecording: true },
     provider: "mock-provider",
-    permissions: { mode: "legacy" },
+    permissions: { mode: "workspace" },
     apiKeys: {},
     sandbox: { enabled: false },
     timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },

package/src/__tests__/relay-server.test.ts

@@ -32,7 +32,10 @@ const testDir = mkdtempSync(join(tmpdir(), "relay-server-test-"));
 
 // ── Platform + logger mocks (must come before any source imports) ────
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPlatform = require("../util/platform.js");
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getDataDir: () => testDir,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -44,7 +47,10 @@ mock.module("../util/platform.js", () => ({
   ensureDataDir: () => {},
 }));
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
@@ -61,10 +67,12 @@ mock.module("../daemon/identity-helpers.js", () => ({
 // ── User-reference mock (isolate from real USER.md) ──────────────────
 
 let mockUserReference = "my human";
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realUserReference = require("../config/user-reference.js");
 mock.module("../config/user-reference.js", () => ({
+  ...realUserReference,
   resolveUserReference: () => mockUserReference,
   resolveUserPronouns: () => null,
-  DEFAULT_USER_REFERENCE: "my human",
   resolveGuardianName: (guardianDisplayName?: string | null) => {
     if (mockUserReference !== "my human") {
       return mockUserReference;