@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/context-search-conversations-source.test.ts

@@ -1,6 +1,45 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import type { MessageLexicalSearchResult } from "../persistence/embeddings/messages-lexical-index.js";
+
+// Mutable stand-in for the Qdrant lexical candidate helper. The source treats
+// a thrown lookup as "no candidates" (logged, empty evidence), so the throwing
+// default cannot fail a forgetful test loudly — tests that assert evidence
+// must configure an implementation, and tests that assert the helper is never
+// consulted check `lexicalCalls` instead.
+let lexicalMockImpl: (
+  query: string,
+  limit: number,
+  opts?: { conversationId?: string },
+) => Promise<MessageLexicalSearchResult[]> = () => {
+  throw new Error("searchMessageIdsLexical mock not configured for this test");
+};
+
+// Records the arguments of every mock invocation so tests can assert the
+// candidate over-fetch count and that gated paths never consult the index.
+let lexicalCalls: Array<{
+  query: string;
+  limit: number;
+  opts?: { conversationId?: string };
+}> = [];
+
+mock.module("../persistence/conversation-search-lexical.js", () => ({
+  searchMessageIdsLexical: (
+    query: string,
+    limit: number,
+    opts?: { conversationId?: string },
+  ) => {
+    lexicalCalls.push({ query, limit, opts });
+    return lexicalMockImpl(query, limit, opts);
+  },
+}));
+
+import {
+  deleteMemoryCheckpoint,
+  LEXICAL_BACKFILL_COMPLETE_KEY,
+  setMemoryCheckpoint,
+} from "../persistence/checkpoints.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { rawRun } from "../persistence/raw-query.js";
@@ -10,18 +49,34 @@ await initializeDb();
 
 let seedId = 0;
 
-describe("searchConversationSource", () => {
+describe("searchConversationSource (qdrant lexical index)", () => {
   beforeEach(() => {
     getDb().run("DELETE FROM messages");
     getDb().run("DELETE FROM conversations");
+    lexicalCalls = [];
+    // Content evidence is available once the index is populated (backfill
+    // complete). Most tests exercise that path, so mark the backfill
+    // complete; the gate is covered by its own test.
+    setMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY, "1");
   });
 
-  test("returns matching message evidence through the FTS path", async () => {
+  afterEach(() => {
+    deleteMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY);
+    lexicalMockImpl = () => {
+      throw new Error(
+        "searchMessageIdsLexical mock not configured for this test",
+      );
+    };
+  });
+
+  test("returns matching message evidence for lexical candidates", async () => {
     const { conversation, message } = await seedConversation({
       title: "Launch notes",
       content: "The alpha launch checklist includes database backups.",
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource(
       "alpha launch",
       makeContext(),
@@ -43,7 +98,11 @@ describe("searchConversationSource", () => {
     });
   });
 
-  test("uses LIKE fallback for short and non-ASCII queries", async () => {
+  test("returns no evidence for short and non-ASCII queries (content matching is index-only)", async () => {
+    // Short/punctuation-only and CJK queries produce no usable ≥2-char token.
+    // There is no content-scan fallback, so such queries yield no conversation
+    // evidence even when an exact substring exists — and the index is never
+    // consulted (the sparse encoder would emit noisy 1-char tokens).
     await seedConversation({
       title: "C++ notes",
       role: "user",
@@ -61,107 +120,153 @@ describe("searchConversationSource", () => {
       5,
     );
 
-    expect(shortResult.evidence.map((item) => item.title)).toEqual([
-      "C++ notes",
-    ]);
-    expect(unicodeResult.evidence.map((item) => item.title)).toEqual([
-      "Unicode notes",
-    ]);
+    expect(lexicalCalls).toHaveLength(0);
+    expect(shortResult.evidence).toEqual([]);
+    expect(unicodeResult.evidence).toEqual([]);
   });
 
-  test("does not return derived subagent, auto-analysis, or notification conversations", async () => {
-    const visible = await seedConversation({
-      title: "User conversation",
-      content: "derivedtoken belongs to a user-authored conversation.",
-    });
+  test("returns no evidence until the backfill completion checkpoint is set", async () => {
     await seedConversation({
-      title: "Subagent conversation",
-      source: "subagent",
-      content: "derivedtoken should not include subagent output.",
-    });
-    await seedConversation({
-      title: "Auto-analysis conversation",
-      source: "auto-analysis",
-      content: "derivedtoken should not include auto-analysis output.",
-    });
-    await seedConversation({
-      title: "Notification conversation",
-      source: "notification",
-      content: "derivedtoken should not include notification seed output.",
+      title: "Pre-backfill notes",
+      content: "The prebackfilltoken decision is recorded here.",
     });
 
+    // On an upgraded instance the historical messages are still being indexed
+    // by the background backfill, so the lexical collection is only partially
+    // populated. Until the completion checkpoint is set, the source must
+    // yield no evidence without consulting Qdrant.
+    deleteMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY);
+    lexicalMockImpl = async () => {
+      throw new Error(
+        "searchMessageIdsLexical must not run before the backfill completes",
+      );
+    };
+
     const result = await searchConversationSource(
-      "derivedtoken",
+      "prebackfilltoken",
       makeContext(),
-      10,
+      5,
     );
 
-    expect(result.evidence.map((item) => item.locator)).toEqual([
-      `${visible.conversation.id}#${visible.message.id}`,
-    ]);
+    expect(lexicalCalls).toHaveLength(0);
+    expect(result.evidence).toEqual([]);
   });
 
-  test("excludes the current conversation from recall results", async () => {
-    const other = await seedConversation({
-      title: "Other conversation",
-      content: "currenttoken appears in another conversation.",
-    });
-    const current = await seedConversation({
-      title: "Current conversation",
-      content: "currenttoken appears in the active conversation.",
+  test("over-fetches a wide candidate pool from Qdrant", async () => {
+    const match = await seedConversation({
+      title: "Launch notes",
+      content: "The widecandidatetoken launch checklist is recorded here.",
     });
 
+    lexicalMockImpl = async () => [{ messageId: match.message.id, score: 0.9 }];
+
+    // limit = 5 → the source over-fetches max(5 × 20, 200) = 200 candidates so
+    // post-filter yield stays healthy when top lexical hits are excluded by
+    // the SQL predicates.
     const result = await searchConversationSource(
-      "currenttoken",
-      makeContext({ conversationId: current.conversation.id }),
-      10,
+      "widecandidatetoken",
+      makeContext(),
+      5,
     );
 
+    expect(lexicalCalls).toHaveLength(1);
+    expect(lexicalCalls[0]?.limit).toBe(200);
+    // Filtering still yields the correctly-scored surviving row.
     expect(result.evidence.map((item) => item.locator)).toEqual([
-      `${other.conversation.id}#${other.message.id}`,
+      `${match.conversation.id}#${match.message.id}`,
     ]);
+    expect(result.evidence[0]?.score).toBeGreaterThan(0);
   });
 
-  test("excludes legacy private conversations as defense-in-depth", async () => {
-    const visible = await seedConversation({
-      title: "Visible conversation",
-      content: "privatetoken belongs to a normal conversation.",
+  test("returns app-scored evidence for Qdrant-supplied candidates", async () => {
+    const match = await seedConversation({
+      title: "Launch notes",
+      content: "The alpha launch checklist includes database backups.",
     });
-    const legacyPrivate = await seedConversation({
-      title: "Legacy private conversation",
-      content: "privatetoken belongs to legacy private history.",
+    // A candidate the lexical index also surfaces but that the query does not
+    // actually match — proves the app-side scorer, not Qdrant order, ranks.
+    const weak = await seedConversation({
+      title: "Unrelated",
+      content: "Nothing salient in this conversation at all.",
     });
-    rawRun(
-      "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
-      legacyPrivate.conversation.id,
-    );
+
+    lexicalMockImpl = async () => [
+      { messageId: weak.message.id, score: 0.9 },
+      { messageId: match.message.id, score: 0.1 },
+    ];
 
     const result = await searchConversationSource(
-      "privatetoken",
+      "alpha launch",
       makeContext(),
-      10,
+      5,
     );
 
-    expect(result.evidence.map((item) => item.locator)).toEqual([
-      `${visible.conversation.id}#${visible.message.id}`,
-    ]);
+    expect(result.evidence[0]).toMatchObject({
+      id: `conversations:${match.conversation.id}:${match.message.id}`,
+      source: "conversations",
+      title: "Launch notes",
+      locator: `${match.conversation.id}#${match.message.id}`,
+      excerpt: "The alpha launch checklist includes database backups.",
+      metadata: {
+        role: "assistant",
+        conversationId: match.conversation.id,
+      },
+    });
+    expect(result.evidence[0]?.score).toBeGreaterThan(
+      result.evidence[1]?.score ?? -1,
+    );
   });
 
-  test("excludes legacy private conversations through the LIKE fallback", async () => {
+  test("applies source, type, and excluded-conversation filters to Qdrant candidates", async () => {
     const visible = await seedConversation({
-      title: "Visible non-ASCII conversation",
-      content: "東京 appears in a normal conversation.",
+      title: "User conversation",
+      content: "derivedtoken belongs to a user-authored conversation.",
+    });
+    const subagent = await seedConversation({
+      title: "Subagent conversation",
+      source: "subagent",
+      content: "derivedtoken should not include subagent output.",
+    });
+    const autoAnalysis = await seedConversation({
+      title: "Auto-analysis conversation",
+      source: "auto-analysis",
+      content: "derivedtoken should not include auto-analysis output.",
+    });
+    const notification = await seedConversation({
+      title: "Notification conversation",
+      source: "notification",
+      content: "derivedtoken should not include notification output.",
+    });
+    const current = await seedConversation({
+      title: "Current conversation",
+      content: "derivedtoken appears in the active conversation.",
     });
     const legacyPrivate = await seedConversation({
-      title: "Legacy private non-ASCII conversation",
-      content: "東京 appears in a private conversation.",
+      title: "Legacy private conversation",
+      content: "derivedtoken belongs to legacy private history.",
     });
     rawRun(
+      "test:setPrivateType",
       "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
       legacyPrivate.conversation.id,
     );
 
-    const result = await searchConversationSource("東京", makeContext(), 10);
+    // The lexical index does not filter — it hands back every candidate,
+    // including the ones SQL must exclude.
+    lexicalMockImpl = async () => [
+      { messageId: visible.message.id, score: 0.9 },
+      { messageId: subagent.message.id, score: 0.85 },
+      { messageId: autoAnalysis.message.id, score: 0.8 },
+      { messageId: notification.message.id, score: 0.75 },
+      { messageId: current.message.id, score: 0.7 },
+      { messageId: legacyPrivate.message.id, score: 0.65 },
+    ];
+
+    const result = await searchConversationSource(
+      "derivedtoken",
+      makeContext({ conversationId: current.conversation.id }),
+      10,
+    );
 
     expect(result.evidence.map((item) => item.locator)).toEqual([
       `${visible.conversation.id}#${visible.message.id}`,
@@ -174,6 +279,7 @@ describe("searchConversationSource", () => {
       content: "includetoken appears in archived history.",
     });
     rawRun(
+      "test:archiveConversation",
       "UPDATE conversations SET archived_at = ? WHERE id = ?",
       Date.now(),
       archived.conversation.id,
@@ -189,6 +295,12 @@ describe("searchConversationSource", () => {
       content: "includetoken appears in background history.",
     });
 
+    lexicalMockImpl = async () => [
+      { messageId: archived.message.id, score: 0.9 },
+      { messageId: scheduled.message.id, score: 0.85 },
+      { messageId: background.message.id, score: 0.8 },
+    ];
+
     const result = await searchConversationSource(
       "includetoken",
       makeContext(),
@@ -216,6 +328,8 @@ describe("searchConversationSource", () => {
       content,
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource("needle", makeContext(), 1);
 
     expect(result.evidence).toHaveLength(1);
@@ -233,6 +347,8 @@ describe("searchConversationSource", () => {
         '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource(
       "recalltoken",
       makeContext(),
@@ -257,6 +373,8 @@ describe("searchConversationSource", () => {
       }),
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource(
       "rawrecalltoken",
       makeContext(),
@@ -282,6 +400,8 @@ describe("searchConversationSource", () => {
       }),
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource(
       "tagmentionrecalltoken",
       makeContext(),
@@ -306,6 +426,8 @@ describe("searchConversationSource", () => {
       }),
     });
 
+    lexicalMockImpl = async () => [{ messageId: message.id, score: 0.9 }];
+
     const result = await searchConversationSource(
       "guardianrecalltoken",
       makeContext(),
@@ -319,29 +441,44 @@ describe("searchConversationSource", () => {
     });
   });
 
-  test("broadens overconstrained recall queries to salient terms", async () => {
-    const specific = await seedConversation({
-      title: "Birthday cake plan",
-      content:
-        "The birthday cake was vanilla with raspberry filling and had the message Happy birthday Alice Love Example Assistant.",
-    });
+  test("returns no evidence when the Qdrant lookup throws", async () => {
     await seedConversation({
-      title: "Decoration notes",
-      content: "The decoration and flavor notes for the launch party are open.",
+      title: "Failure notes",
+      content: "The qdranterrortoken decision is recorded here.",
     });
 
+    lexicalMockImpl = async () => {
+      throw new Error("qdrant unavailable");
+    };
+
     const result = await searchConversationSource(
-      "birthday cake flavor decoration message recipient",
+      "qdranterrortoken",
       makeContext(),
       5,
     );
 
-    expect(result.evidence[0]).toMatchObject({
-      locator: `${specific.conversation.id}#${specific.message.id}`,
-      title: "Birthday cake plan",
+    // Content matching is index-only: the failure is logged and the source
+    // yields no conversation evidence — no content-scan recovery.
+    expect(result.evidence).toEqual([]);
+  });
+
+  test("returns no evidence when Qdrant returns no candidates", async () => {
+    await seedConversation({
+      title: "Empty candidate notes",
+      content: "The emptycandidatetoken decision is recorded here.",
     });
-    expect(result.evidence[0]?.excerpt).toContain("vanilla with raspberry");
-    expect(result.evidence[0]?.score).toBeGreaterThan(0);
+
+    lexicalMockImpl = async () => [];
+
+    const result = await searchConversationSource(
+      "emptycandidatetoken",
+      makeContext(),
+      5,
+    );
+
+    // The index is authoritative for content matching — an empty candidate
+    // set is an empty result, not a trigger for a table-scan fallback.
+    expect(result.evidence).toEqual([]);
   });
 });
 
@@ -366,6 +503,7 @@ function seedConversation(opts: {
   };
 
   rawRun(
+    "test:insertConversation",
     `
     INSERT INTO conversations (
       id,
@@ -386,6 +524,7 @@ function seedConversation(opts: {
     opts.memoryScopeId ?? "default",
   );
   rawRun(
+    "test:insertMessage",
     `
     INSERT INTO messages (
       id,

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -182,6 +182,7 @@ function makeCtx(overrides: Partial<Context> = {}): Conversation {
     getTurnChannelContext: () => null,
 
     buildCurrentSystemPrompt: () => "system prompt",
+    syncLoopSystemPrompt: () => {},
     modelOverride: undefined,
     graphMemory: {} as Context["graphMemory"],
     ...overrides,

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -510,6 +510,7 @@ function makeCtx(
     }),
 
     buildCurrentSystemPrompt: () => "system prompt",
+    syncLoopSystemPrompt: () => {},
     modelOverride: undefined,
 
     graphMemory: {

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -656,6 +656,7 @@ function makeCtx(
     }),
 
     buildCurrentSystemPrompt: () => "system prompt",
+    syncLoopSystemPrompt: () => {},
     modelOverride: undefined,
 
     graphMemory: {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -778,6 +778,7 @@ function makeCtx(
     }),
 
     buildCurrentSystemPrompt: () => "system prompt",
+    syncLoopSystemPrompt: () => {},
     modelOverride: undefined,
 
     graphMemory: {
@@ -2408,6 +2409,44 @@ describe("session-agent-loop", () => {
       expect(metadataPublishes).toHaveLength(1);
     });
 
+    test("terminal message_complete is emitted before the deferred indexer runs (LUM-2654)", async () => {
+      // Regression guard for LUM-2654 ("long delay between last streaming token
+      // and send-button becoming available"). The terminal `message_complete`
+      // SSE — which the client uses to flip stop→send — is emitted before the
+      // non-critical finalize side-effects (memory segment indexing, lexical
+      // indexing, attention projection), which the orchestrator drains from its
+      // end-of-turn tail. The tail runs within the turn, so the indexer still
+      // fires exactly once; this test pins the ordering by asserting
+      // `message_complete` is already in the client stream when it does.
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const events: ServerMessage[] = [];
+      let messageCompleteSeenWhenIndexed: boolean | undefined;
+      indexMessageNowMock.mockImplementationOnce(async () => {
+        messageCompleteSeenWhenIndexed = events.some(
+          (event) => event.type === "message_complete",
+        );
+        return { indexedSegments: 0, enqueuedJobs: 0 };
+      });
+
+      const ctx = makeCtx({
+        providerResponses: [textResponse("indexed reply")],
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", (msg) => events.push(msg));
+
+      // The deferred indexer runs exactly once, within the turn…
+      expect(indexMessageNowMock).toHaveBeenCalledTimes(1);
+      // …and only after the terminal SSE that re-enables the composer.
+      expect(messageCompleteSeenWhenIndexed).toBe(true);
+    });
+
     test("handleMessageComplete skips sync invalidation when attention state unchanged", async () => {
       // Mirror of the previous test but with the default projector return
       // (`false`). The projection still runs every turn, but the sync

package/src/__tests__/conversation-analysis-routes.test.ts

@@ -103,7 +103,7 @@ describe("POST /v1/conversations/:id/analyze", () => {
       "analysis-1",
       "user",
       expect.any(String),
-      { metadata: { provenanceTrustClass: "unknown" } },
+      { id: expect.any(String), metadata: { provenanceTrustClass: "unknown" } },
     );
     expect(mockConversation.setTrustContext).toHaveBeenCalledWith({
       trustClass: "unknown",

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -79,6 +79,8 @@ const mockSkillRefCount = new Map<string, number>();
 
 mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => mockCatalog,
+  // Pass-through: these tests don't exercise per-chat plugin scoping.
+  filterSkillsByEnabledPlugins: (skills: unknown) => skills,
 }));
 
 mock.module("../skills/active-skill-tools.js", () => ({

package/src/__tests__/conversation-clear-safety.test.ts

@@ -33,7 +33,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   },
   switchConversation: async () => null,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import {

package/src/__tests__/conversation-crud-enabled-plugins.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  addMessage,
+  createConversation,
+  forkConversation,
+  getConversation,
+  getConversationEnabledPlugins,
+  setConversationEnabledPlugins,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+await initializeDb();
+
+describe("getConversationEnabledPlugins / setConversationEnabledPlugins", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+  });
+
+  test("defaults to null on a fresh conversation", () => {
+    const conv = createConversation("enabled-plugins-default");
+    expect(getConversationEnabledPlugins(conv.id)).toBeNull();
+    expect(getConversation(conv.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("round-trips a plugin list and clears it with null", () => {
+    const conv = createConversation("enabled-plugins-roundtrip");
+
+    setConversationEnabledPlugins(conv.id, ["a", "b"]);
+    expect(getConversationEnabledPlugins(conv.id)).toEqual(["a", "b"]);
+    expect(getConversation(conv.id)?.enabledPlugins).toEqual(["a", "b"]);
+
+    setConversationEnabledPlugins(conv.id, null);
+    expect(getConversationEnabledPlugins(conv.id)).toBeNull();
+    expect(getConversation(conv.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("stores an empty list distinctly from null", () => {
+    const conv = createConversation("enabled-plugins-empty");
+    setConversationEnabledPlugins(conv.id, []);
+    expect(getConversationEnabledPlugins(conv.id)).toEqual([]);
+  });
+
+  test("a forked conversation carries the plugin selection", async () => {
+    const conv = createConversation("enabled-plugins-fork-source");
+    setConversationEnabledPlugins(conv.id, ["x", "y"]);
+    await addMessage(conv.id, "user", "hi");
+
+    const forked = forkConversation({ conversationId: conv.id });
+    expect(getConversationEnabledPlugins(forked.id)).toEqual(["x", "y"]);
+  });
+});

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -26,7 +26,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   clearAllConversations: async () => 0,
   switchConversation: async () => null,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import type { Database } from "bun:sqlite";

package/src/__tests__/conversation-disk-view.test.ts

@@ -552,6 +552,7 @@ describe("syncMessageToDisk", () => {
     });
     const att = uploadAttachment("repair.png", "image/png", "iVBORw0K");
     rawRun(
+      "test:linkAttachment",
       `INSERT INTO message_attachments (id, message_id, attachment_id, position, created_at)
        VALUES (?, ?, ?, ?, ?)`,
       `manual-link-${msg.id}`,