@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/list-messages-page-latest.test.ts

@@ -37,14 +37,20 @@ mock.module("../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockAssistantName,
 }));
 
-import { createConversation } from "../memory/conversation-crud.js";
+import {
+  createConversation,
+  recordConversationPersistedSeq,
+  setConversationProcessingStartedAt,
+} from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema.js";
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
-  recordPersistedSeq,
+  getCurrentSeq,
+  stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
@@ -103,6 +109,13 @@ interface MessagePayload {
     sender?: { displayName?: string; externalUserId?: string };
     messageLink?: { appUrl?: string; webUrl?: string };
     threadLink?: { appUrl?: string; webUrl?: string };
+    eventKind?: "message" | "reaction";
+    reaction?: {
+      emoji: string;
+      op: "added" | "removed";
+      actorDisplayName?: string;
+      targetChannelTs: string;
+    };
   };
 }
 
@@ -112,6 +125,28 @@ interface ListResponse {
   oldestTimestamp?: number | null;
   oldestMessageId?: string | null;
   seq?: number | null;
+  processing?: boolean;
+}
+
+/**
+ * Stamp `count` conversation-scoped events to advance the global `seq`
+ * counter, mirroring `mkEvent` in assistant-stream-state.test.ts. The
+ * conversationId is irrelevant — `getCurrentSeq()` is process-global — so
+ * any value works for nudging the high-water mark before a creation.
+ */
+function advanceGlobalSeq(count: number): void {
+  for (let i = 0; i < count; i++) {
+    stampAndBuffer({
+      id: `seq-bump-${i}`,
+      conversationId: "seq-bump-conv",
+      emittedAt: new Date().toISOString(),
+      message: {
+        type: "assistant_text_delta",
+        conversationId: "seq-bump-conv",
+        text: "x",
+      },
+    } as AssistantEvent);
+  }
 }
 
 function callList(query: Record<string, string>): ListResponse {
@@ -138,7 +173,7 @@ describe("handleListMessages page=latest", () => {
       const conv = createConversation();
       seedMessages(conv.id, 3);
       // AND the daemon has recorded a persisted seq for it
-      recordPersistedSeq(conv.id, 42);
+      recordConversationPersistedSeq(conv.id, 42);
 
       // WHEN the snapshot is fetched
       const body = callList({ conversationId: conv.id, page: "latest" });
@@ -171,7 +206,7 @@ describe("handleListMessages page=latest", () => {
       // GIVEN a conversation with a recorded persisted seq
       const conv = createConversation();
       seedMessages(conv.id, 2);
-      recordPersistedSeq(conv.id, 7);
+      recordConversationPersistedSeq(conv.id, 7);
 
       // WHEN fetched with no pagination params
       const body = callList({ conversationId: conv.id });
@@ -179,6 +214,138 @@ describe("handleListMessages page=latest", () => {
       // THEN the seq still rides along
       expect(body.seq).toBe(7);
     });
+
+    test("recording advances the seq monotonically and never regresses", () => {
+      /**
+       * Out-of-order async commits must not lower the high-water mark — the
+       * `WHERE seq < ?` guard on the persist UPDATE keeps it monotonic.
+       */
+
+      // GIVEN a conversation whose persisted seq has been recorded
+      const conv = createConversation();
+      recordConversationPersistedSeq(conv.id, 12);
+
+      // WHEN a lower seq is recorded (a late, out-of-order commit)
+      recordConversationPersistedSeq(conv.id, 8);
+
+      // THEN the high-water seq is unchanged
+      expect(callList({ conversationId: conv.id }).seq).toBe(12);
+
+      // AND a higher seq still advances it
+      recordConversationPersistedSeq(conv.id, 20);
+      expect(callList({ conversationId: conv.id }).seq).toBe(20);
+    });
+
+    test("recording ignores non-positive and non-finite seq values", () => {
+      // GIVEN a freshly created conversation (no stream activity → null seed)
+      const conv = createConversation();
+
+      // WHEN non-positive / non-finite seqs are recorded
+      recordConversationPersistedSeq(conv.id, 0);
+      recordConversationPersistedSeq(conv.id, -3);
+      recordConversationPersistedSeq(conv.id, Number.NaN);
+      recordConversationPersistedSeq(conv.id, Number.POSITIVE_INFINITY);
+
+      // THEN none take effect and seq stays null
+      expect(callList({ conversationId: conv.id }).seq).toBeNull();
+    });
+
+    test("a freshly created conversation is anchored to the current global seq", () => {
+      /**
+       * Conversations created after some stream activity must not report a
+       * null `seq` — that would force the client to cold-start with no
+       * alignment baseline. They inherit the current high-water global seq
+       * at creation time so the first snapshot can align with the stream.
+       */
+
+      // GIVEN the global stream has already advanced past seq 0
+      advanceGlobalSeq(5);
+      expect(getCurrentSeq()).toBe(5);
+
+      // WHEN a brand-new conversation is created and its snapshot fetched
+      const conv = createConversation();
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN the snapshot is anchored to the global seq at creation time
+      expect(body.seq).toBe(5);
+    });
+
+    test("a conversation created before any stream activity stays null", () => {
+      /**
+       * With nothing stamped this process, `getCurrentSeq()` is 0 and the
+       * creation seed stores NULL (non-positive seqs aren't recorded), so the
+       * snapshot legitimately reports null and the client cold-starts.
+       */
+
+      // GIVEN no events have been stamped (stream reset in beforeEach)
+      expect(getCurrentSeq()).toBe(0);
+
+      // WHEN a conversation is created and its snapshot fetched
+      const conv = createConversation();
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN seq remains null
+      expect(body.seq).toBeNull();
+    });
+  });
+
+  describe("processing state", () => {
+    test("reports processing=true while the conversation is mid-turn", () => {
+      /**
+       * The authoritative processing flag lets a client recover from a
+       * dropped stream: it can ask the server whether a turn is still
+       * running rather than spinning forever.
+       */
+
+      // GIVEN a conversation marked as processing
+      const conv = createConversation();
+      seedMessages(conv.id, 1);
+      setConversationProcessingStartedAt(conv.id, Date.now());
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN it reports the conversation is processing
+      expect(body.processing).toBe(true);
+    });
+
+    test("reports processing=false when the conversation is idle", () => {
+      // GIVEN an idle conversation (processing_started_at is null)
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN it reports the conversation is not processing
+      expect(body.processing).toBe(false);
+    });
+
+    test("the no-pagination path also reports processing state", () => {
+      /** `processing` is present on every resolved-conversation shape. */
+
+      // GIVEN a processing conversation
+      const conv = createConversation();
+      seedMessages(conv.id, 1);
+      setConversationProcessingStartedAt(conv.id, Date.now());
+
+      // WHEN fetched with no pagination params
+      const body = callList({ conversationId: conv.id });
+
+      // THEN processing rides along
+      expect(body.processing).toBe(true);
+    });
+
+    test("an unresolved conversationKey reports processing=false (page=latest)", () => {
+      // WHEN a never-created key is fetched with the stable contract
+      const body = callList({
+        conversationKey: "no-such-key",
+        page: "latest",
+      });
+
+      // THEN it cannot be processing
+      expect(body.processing).toBe(false);
+    });
   });
 
   test("page=latest with no limit returns all messages chronologically", () => {
@@ -322,6 +489,7 @@ describe("handleListMessages page=latest", () => {
         webUrl:
           "https://example.slack.com/archives/C123ABCDEF/p1710000000000100",
       },
+      eventKind: "message",
     });
   });
 
@@ -367,6 +535,7 @@ describe("handleListMessages page=latest", () => {
         webUrl:
           "https://example.slack.com/archives/C123ABCDEF/p1710000000000200",
       },
+      eventKind: "message",
     });
   });
 

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -8,6 +8,7 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
   initLogger: () => {},
   pruneOldLogFiles: () => 0,
+  getCurrentLogFilePath: () => "/tmp/test-assistant.log",
   truncateForLog: (value: string, maxLen = 500) => value.slice(0, maxLen),
 }));
 
@@ -110,6 +111,7 @@ mock.module("../providers/registry.js", () => ({
   isNativeWebSearchCapableProvider: () => false,
   listProviders: () => [],
   resolveProviderFromConnection: async () => null,
+  shouldUseNativeWebSearch: () => false,
 }));
 
 mock.module("../memory/embedding-backend.js", () => ({
@@ -121,6 +123,7 @@ mock.module("../memory/embedding-backend.js", () => ({
     model: "test",
     vectors: [],
   }),
+  geminiCacheExtras: () => [],
   generateSparseEmbedding: () => ({ indices: [], values: [] }),
   getMemoryBackendStatus: async () => ({
     enabled: false,

package/src/__tests__/non-member-access-request.test.ts

@@ -551,10 +551,14 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("telegram");
   });
 
-  test("notifyGuardianOfAccessRequest falls back to local source-channel binding when gateway delivery is empty", async () => {
-    // Gateway delivery read yields nothing (restart/timeout/malformed IPC).
-    gatewayGuardians = [];
-    // Local dual-written mirror still has the vellum anchor + telegram binding.
+  test("notifyGuardianOfAccessRequest resolves the source-channel guardian from the gateway delivery", async () => {
+    // Gateway delivery serves a telegram guardian matching the vellum anchor.
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-tg",
+      externalChatId: "tg-chat",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-tg",
@@ -578,7 +582,7 @@ describe("access-request-helper unit tests", () => {
       kind: "access_request",
     });
     expect(pending.length).toBe(1);
-    // Request is decidable: local read supplied the principal + source binding.
+    // Request is decidable: gateway delivery supplied the principal + source binding.
     expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
     expect(pending[0].guardianExternalUserId).toBe("guardian-tg");
 
@@ -589,10 +593,8 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("telegram");
   });
 
-  test("notifyGuardianOfAccessRequest falls back to local vellum anchor when gateway delivery is empty", async () => {
-    // Gateway empty; only the local vellum anchor from resetState remains.
-    gatewayGuardians = [];
-
+  test("notifyGuardianOfAccessRequest resolves the vellum anchor from the gateway delivery", async () => {
+    // Only the vellum anchor (seeded in resetState) is served by the gateway.
     const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
@@ -608,7 +610,7 @@ describe("access-request-helper unit tests", () => {
       kind: "access_request",
     });
     expect(pending.length).toBe(1);
-    // Decidable via the local vellum anchor principal.
+    // Decidable via the gateway-served vellum anchor principal.
     expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
 
     const payload = emitSignalCalls[0].contextPayload as Record<
@@ -618,9 +620,9 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("vellum");
   });
 
-  test("notifyGuardianOfAccessRequest does not create a decisionable request when both gateway and local reads are empty", async () => {
-    // Genuinely unbound assistant: gateway empty AND no local binding. Prior
-    // behavior rejects creation of a decisionable request without a principal.
+  test("notifyGuardianOfAccessRequest does not create a decisionable request when the gateway delivery is empty", async () => {
+    // Genuinely unbound assistant: gateway serves no guardian. The guard
+    // rejects creation of a decisionable request without a principal.
     gatewayGuardians = [];
     const db = getDb();
     db.run("DELETE FROM contact_channels");

package/src/__tests__/onboarding-persona-write.test.ts

@@ -30,11 +30,24 @@ import {
 
 // ── Mock state ────────────────────────────────────────────────────
 
+interface GuardianDeliveryStub {
+  channelType: string;
+  address: string;
+  status: string;
+}
+
 let mockWorkspaceDir: string = "";
-let mockVellumGuardian: {
-  contact: { userFile: string | null };
-  channel: Record<string, unknown>;
-} | null = null;
+// Gateway guardian delivery cache; the guardian's userFile (local INFO) is
+// joined via findContactByAddress on the delivery's address.
+let mockGuardianDeliveries: GuardianDeliveryStub[] = [];
+let mockContactsByAddress: Record<string, { userFile: string | null }> = {};
+
+function seedVellumGuardian(userFile: string | null): void {
+  mockGuardianDeliveries = [
+    { channelType: "vellum", address: "vellum:self", status: "active" },
+  ];
+  mockContactsByAddress["vellum:vellum:self"] = { userFile };
+}
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -59,10 +72,20 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByAddress: () => null,
-  findGuardianForChannel: (channelType: string) =>
-    channelType === "vellum" ? mockVellumGuardian : null,
-  listGuardianChannels: () => null,
+  findContactByAddress: (channelType: string, address: string) =>
+    mockContactsByAddress[`${channelType}:${address}`] ?? null,
+}));
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) => {
+    if (!input?.channelTypes) return mockGuardianDeliveries;
+    return mockGuardianDeliveries.filter((g) =>
+      input.channelTypes!.includes(g.channelType),
+    );
+  },
+  guardianForChannel: (list: GuardianDeliveryStub[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: GuardianDeliveryStub[]) => list[0],
 }));
 
 // Import AFTER mocks so the module under test binds to the stubbed
@@ -87,7 +110,8 @@ afterAll(() => {
 
 beforeEach(() => {
   mockWorkspaceDir = mkdtempSync(join(testRoot, "ws-"));
-  mockVellumGuardian = null;
+  mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 });
 
 afterEach(() => {
@@ -98,10 +122,7 @@ afterEach(() => {
 
 describe("writeOnboardingSection", () => {
   test("writes section to guardian persona file when it exists", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
     const guardianPath = workspacePath("users/alice.md");
     mkdirSync(workspacePath("users"), { recursive: true });
     writeFileSync(guardianPath, "# User Profile\n\n- **Name:** Alice\n");
@@ -123,7 +144,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("falls back to users/default.md when guardian path is null", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
     mkdirSync(workspacePath("users"), { recursive: true });
     writeFileSync(
       workspacePath("users/default.md"),
@@ -147,7 +169,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("falls back to USER.md when no users/ files exist", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 
     writeOnboardingSection({
       preferredName: "Alice",
@@ -162,7 +185,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("creates file with header + section when target doesn't exist", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 
     writeOnboardingSection({
       preferredName: "Alice",
@@ -179,7 +203,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("idempotent: calling twice produces the same file content", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
     const normalized = {
       preferredName: "Alice",
       commonWork: ["builds code, apps, or tools"],
@@ -196,7 +221,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("replaces existing onboarding section with updated data", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 
     writeOnboardingSection({
       preferredName: "Alice",
@@ -222,7 +248,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("preserves content outside the managed section", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
     writeFileSync(
       workspacePath("USER.md"),
       "# User Profile\n\n- **Name:** Alice\n- **Role:** Engineer\n",
@@ -242,7 +269,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("omits empty fields", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 
     writeOnboardingSection({
       commonWork: [],
@@ -257,7 +285,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("omits preferredName when undefined", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
 
     writeOnboardingSection({
       preferredName: undefined,
@@ -272,7 +301,8 @@ describe("writeOnboardingSection", () => {
   });
 
   test("preserves content after onboarding section when followed by another heading", () => {
-    mockVellumGuardian = null;
+    mockGuardianDeliveries = [];
+  mockContactsByAddress = {};
     writeFileSync(
       workspacePath("USER.md"),
       [

package/src/__tests__/persist-onboarding-artifacts.test.ts

@@ -23,6 +23,7 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (v: string) => v,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,
+  getCurrentLogFilePath: () => "/tmp/test-assistant.log",
 }));
 
 let writeRelationshipStateCalled = false;