@vellumai/assistant 0.10.4-dev.202607010146.a37a2fa → 0.10.4-dev.202607010541.092b857

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607010146.a37a2fa",
+  "version": "0.10.4-dev.202607010541.092b857",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/clear-all-lexical.test.ts

@@ -0,0 +1,93 @@
+// clearAll() must drop the memory feature's bulk per-message index (the whole
+// lexical Qdrant collection) — a "delete all" leaves no conversation ids to key
+// per-conversation purges on, so the points would otherwise survive a
+// "permanently delete everything" action. clearAll routes this through the
+// `MemoryPersistenceHooks.onAllConversationsCleared` seam (persistence stays
+// decoupled from the plugin); the memory plugin's impl calls
+// `clearMessagesLexicalIndex`. This asserts the full chain fires.
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// Spy on `clearMessagesLexicalIndex` (the plugin's `onAllConversationsCleared`
+// impl calls it) while keeping the rest of the module REAL. `mock.module` is
+// process-global and not undone by `mock.restore()`, so a partial mock that
+// drops the other exports would leak into any later test file in the same
+// process that imports them (e.g. the handler tests importing
+// `indexMessageLexicalJob`). Spread the real module so only this one export is
+// replaced. Importing the real module here is safe: its deps
+// (`@qdrant/js-client-rest`, `uuid`, the local TF-IDF encoder) resolve in the
+// worktree.
+const actualLexical =
+  await import("../plugins/defaults/memory/job-handlers/index-message-lexical.js");
+let clearCalls = 0;
+mock.module(
+  "../plugins/defaults/memory/job-handlers/index-message-lexical.js",
+  () => ({
+    ...actualLexical,
+    clearMessagesLexicalIndex: async () => {
+      clearCalls += 1;
+    },
+  }),
+);
+
+import { clearAll } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getMemoryPersistenceHooks,
+  registerMemoryPersistenceHooks,
+  resetMemoryPersistenceHooksForTests,
+} from "../persistence/memory-lifecycle-hooks.js";
+import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
+
+await initializeDb();
+
+describe("clearAll bulk lexical index cleanup", () => {
+  beforeEach(() => {
+    clearCalls = 0;
+    // Register the real memory persistence hooks so `onAllConversationsCleared`
+    // routes to the plugin impl (which calls the spied clear helper).
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll fires onAllConversationsCleared, which clears the lexical index", async () => {
+    await clearAll();
+    expect(clearCalls).toBe(1);
+  });
+
+  test("clearAll AWAITS the collection drop before returning", async () => {
+    // The drop must complete before clearAll resolves — otherwise a write right
+    // after clear-all could land in a collection that is about to be dropped.
+    // Register a hook whose drop yields to the microtask queue before finishing;
+    // if clearAll did not await, `dropCompleted` would still be false here.
+    let dropCompleted = false;
+    registerMemoryPersistenceHooks({
+      ...getMemoryPersistenceHooks(),
+      async onAllConversationsCleared() {
+        await new Promise((r) => setTimeout(r, 10));
+        dropCompleted = true;
+      },
+    });
+
+    await clearAll();
+    expect(dropCompleted).toBe(true);
+
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll is a safe no-op when the memory hooks are not registered", async () => {
+    // Persistence must work with no memory present — the seam falls through to
+    // its no-op and clearAll does not touch the lexical index.
+    resetMemoryPersistenceHooksForTests();
+    clearCalls = 0;
+    await clearAll();
+    expect(clearCalls).toBe(0);
+    // Restore for any later test in the same process.
+    registerDefaultPluginPersistenceHooks();
+  });
+});

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

@@ -1,6 +1,57 @@
-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";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+// Mutable stand-in for the Qdrant lexical candidate helper. The default
+// throws so any qdrant-path test that forgets to set an implementation fails
+// loudly rather than silently exercising an empty candidate set. FTS-path
+// tests never reach it (the flag defaults to fts5), so its value is irrelevant
+// there.
+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 the qdrant branch requests.
+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);
+  },
+}));
+
+// Drives the real recall backend gate: when true the source must fall back to
+// FTS regardless of the flag, because the lexical index write path is
+// suppressed and Qdrant is never populated. Defaults false so every other test
+// exercises its intended backend. Spread the real module so the other 9 exports
+// (job handlers, enqueue helpers) stay intact for transitive importers.
+let suppressIndexing = false;
+const realLexicalModule =
+  await import("../plugins/defaults/memory/job-handlers/index-message-lexical.js");
+mock.module(
+  "../plugins/defaults/memory/job-handlers/index-message-lexical.js",
+  () => ({
+    ...realLexicalModule,
+    isMemoryIndexingSuppressed: () => suppressIndexing,
+  }),
+);
+
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { rawRun } from "../persistence/raw-query.js";
@@ -345,6 +396,235 @@ describe("searchConversationSource", () => {
   });
 });
 
+describe("searchConversationSource with the qdrant backend", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM messages");
+    getDb().run("DELETE FROM conversations");
+    lexicalCalls = [];
+    suppressIndexing = false;
+    setOverridesForTesting({ "messages-search-backend": true });
+  });
+
+  afterEach(() => {
+    setOverridesForTesting({});
+    suppressIndexing = false;
+    lexicalMockImpl = () => {
+      throw new Error(
+        "searchMessageIdsLexical mock not configured for this test",
+      );
+    };
+  });
+
+  test("falls back to FTS when memory indexing is suppressed, even with the qdrant flag on", async () => {
+    const match = await seedConversation({
+      title: "Suppressed indexing notes",
+      content: "The suppressedtoken decision is recorded here.",
+    });
+
+    // The lexical index is not populated while indexing is suppressed, so the
+    // source must NOT query Qdrant — it must use the FTS path.
+    suppressIndexing = true;
+    lexicalMockImpl = async () => {
+      throw new Error("searchMessageIdsLexical must not run while suppressed");
+    };
+
+    const result = await searchConversationSource(
+      "suppressedtoken",
+      makeContext(),
+      5,
+    );
+
+    // FTS path found the row (proves the backend fell back), and the Qdrant
+    // candidate helper was never called.
+    expect(lexicalCalls).toHaveLength(0);
+    expect(result.evidence.map((item) => item.locator)).toEqual([
+      `${match.conversation.id}#${match.message.id}`,
+    ]);
+  });
+
+  test("routes short/punctuation-only queries to the exact LIKE path, not Qdrant", async () => {
+    const match = await seedConversation({
+      title: "C++ notes",
+      role: "user",
+      content: "Use C++ when the example needs deterministic lifetime notes.",
+    });
+
+    // `C++` produces no usable ≥2-char FTS match shape, so the source must use
+    // the exact LIKE path rather than the sparse encoder (which would still
+    // emit a noisy 1-char `c` token). The mock throws to prove it never runs.
+    lexicalMockImpl = async () => {
+      throw new Error("searchMessageIdsLexical must not run for a short query");
+    };
+
+    const result = await searchConversationSource("C++", makeContext(), 5);
+
+    expect(lexicalCalls).toHaveLength(0);
+    expect(result.evidence.map((item) => item.locator)).toEqual([
+      `${match.conversation.id}#${match.message.id}`,
+    ]);
+  });
+
+  test("over-fetches a wide candidate pool from Qdrant, not the FTS prefetch window", 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 → FTS would prefetch 5 × 5 = 25. The qdrant branch instead
+    // 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(
+      "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([
+      `${match.conversation.id}#${match.message.id}`,
+    ]);
+    expect(result.evidence[0]?.score).toBeGreaterThan(0);
+  });
+
+  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.",
+    });
+    // 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.",
+    });
+
+    lexicalMockImpl = async () => [
+      { messageId: weak.message.id, score: 0.9 },
+      { messageId: match.message.id, score: 0.1 },
+    ];
+
+    const result = await searchConversationSource(
+      "alpha launch",
+      makeContext(),
+      5,
+    );
+
+    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("applies source, type, and excluded-conversation filters to Qdrant candidates", async () => {
+    const visible = await seedConversation({
+      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 conversation",
+      content: "derivedtoken belongs to legacy private history.",
+    });
+    rawRun(
+      "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
+      legacyPrivate.conversation.id,
+    );
+
+    // 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}`,
+    ]);
+  });
+
+  test("falls back to LIKE when the Qdrant lookup throws", async () => {
+    const match = await seedConversation({
+      title: "Fallback notes",
+      content: "The likefallbacktoken decision is recorded here.",
+    });
+
+    lexicalMockImpl = async () => {
+      throw new Error("qdrant unavailable");
+    };
+
+    const result = await searchConversationSource(
+      "likefallbacktoken",
+      makeContext(),
+      5,
+    );
+
+    expect(result.evidence.map((item) => item.locator)).toEqual([
+      `${match.conversation.id}#${match.message.id}`,
+    ]);
+  });
+
+  test("falls back to LIKE when Qdrant returns no candidates", async () => {
+    const match = await seedConversation({
+      title: "Empty candidate notes",
+      content: "The emptycandidatetoken decision is recorded here.",
+    });
+
+    lexicalMockImpl = async () => [];
+
+    const result = await searchConversationSource(
+      "emptycandidatetoken",
+      makeContext(),
+      5,
+    );
+
+    expect(result.evidence.map((item) => item.locator)).toEqual([
+      `${match.conversation.id}#${match.message.id}`,
+    ]);
+  });
+});
+
 function seedConversation(opts: {
   title?: string;
   conversationType?: "standard" | "background" | "scheduled";

package/src/__tests__/conversation-wipe.test.ts

@@ -118,16 +118,31 @@ describe("wipeConversation", () => {
       }
     ).$client;
 
-    // Both jobs should be failed with conversation_wiped error
     const jobs = raw
-      .query("SELECT status, last_error FROM memory_jobs")
-      .all() as Array<{ status: string; last_error: string | null }>;
-
-    for (const job of jobs) {
+      .query("SELECT type, status, last_error FROM memory_jobs")
+      .all() as Array<{
+      type: string;
+      status: string;
+      last_error: string | null;
+    }>;
+
+    // The pre-existing jobs should be failed with the conversation_wiped error.
+    for (const job of jobs.filter(
+      (j) => j.type !== "purge_conversation_lexical",
+    )) {
       expect(job.status).toBe("failed");
       expect(job.last_error).toContain("conversation_wiped");
     }
 
+    // Wiping also enqueues a lexical-index purge, which must SURVIVE the
+    // job-cancellation pass (it is enqueued after cancellation) so the worker
+    // can delete the conversation's Qdrant points.
+    const purgeJobs = jobs.filter(
+      (j) => j.type === "purge_conversation_lexical",
+    );
+    expect(purgeJobs).toHaveLength(1);
+    expect(purgeJobs[0].status).toBe("pending");
+
     expect(result.cancelledJobCount).toBeGreaterThanOrEqual(2);
   });
 

package/src/__tests__/edit-propagation.test.ts

@@ -21,10 +21,10 @@ mock.module("../util/logger.js", () => ({
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { addMessage } from "../persistence/conversation-crud.js";
 import { getConversationByKey } from "../persistence/conversation-key-store.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getMemoryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
-import { messages } from "../persistence/schema/index.js";
+import { memoryJobs, messages } from "../persistence/schema/index.js";
 import { handleEditIntercept } from "../runtime/routes/inbound-stages/edit-intercept.js";
 
 await initializeDb();
@@ -35,6 +35,25 @@ function resetTables(): void {
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversation_keys");
   db.run("DELETE FROM conversations");
+  // memory_jobs lives in the dedicated memory connection.
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
+}
+
+function lexicalIndexJobMessageIds(): string[] {
+  return getMemoryDb()!
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "index_message_lexical"))
+    .all()
+    .map((r) => {
+      try {
+        return (
+          (JSON.parse(r.payload) as { messageId?: string }).messageId ?? ""
+        );
+      } catch {
+        return "";
+      }
+    });
 }
 
 interface SeededFixture {
@@ -276,6 +295,41 @@ describe("Slack edit propagation", () => {
     expect(after.content).toBe(before.content);
     // No metadata mutation either -- the write is fully skipped.
     expect(after.metadata).toBe(before.metadata);
+
+    // A no-op edit changes no searchable text, so it must NOT enqueue a lexical
+    // reindex.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+  });
+
+  test("a content-changing edit enqueues a lexical reindex for the message", async () => {
+    // Regression: channel edits update the row in-place via
+    // updateMessageContentAndMetadata / updateMessageContent, bypassing
+    // onMessagePersisted. The lexical index must be refreshed so the old Qdrant
+    // point does not go stale against the edited (FTS-updated) content.
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "C0123CHANNEL",
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+
+    // The seed used skipIndexing, so no lexical job exists yet.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+
+    await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId: seeded.conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      canonicalAssistantId: "self",
+      assistantId: "self",
+      content: "edited searchable text",
+    });
+
+    expect(readMessageRow(seeded.messageId).content).toBe(
+      "edited searchable text",
+    );
+    // The edit reindexed the message into the lexical index.
+    expect(lexicalIndexJobMessageIds()).toContain(seeded.messageId);
   });
 
   // The lookup retries 5 times with 2s backoff (~10s total) before giving up,

package/src/__tests__/job-handler-registry-guard.test.ts

@@ -45,6 +45,7 @@ const MEMORY_JOB_TYPES = [
   "memory_retrospective",
   "index_message_lexical",
   "purge_conversation_lexical",
+  "delete_message_lexical",
   "backfill_lexical_index",
 ].sort();