@vellumai/assistant 0.10.4-dev.202607010319.f2b69c7 → 0.10.4-dev.202607010743.70cd9f0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607010319.f2b69c7",
+  "version": "0.10.4-dev.202607010743.70cd9f0",
   "license": "MIT",
   "type": "module",
   "exports": {

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__/plugin-import-boundary-guard.test.ts

@@ -78,10 +78,12 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/logger.js",
   ],
   memory: [
+    "../../../../../config/assistant-feature-flags.js",
     "../../../../../config/types.js",
     "../../../../../messaging/providers/slack/message-metadata.js",
     "../../../../../persistence/auto-analysis-constants.js",
     "../../../../../persistence/conversation-queries.js",
+    "../../../../../persistence/conversation-search-lexical.js",
     "../../../../../persistence/db-connection.js",
     "../../../../../persistence/embeddings/embed.js",
     "../../../../../persistence/embeddings/embedding-backend.js",
@@ -185,6 +187,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/embeddings/messages-lexical-index.js",
     "../../../persistence/embeddings/qdrant-client.js",
     "../../../persistence/embeddings/qdrant-manager.js",
+    "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
     "../../../persistence/jobs-worker.js",
     "../../../persistence/memory-lifecycle-hooks.js",

package/src/daemon/conversation.ts

@@ -56,6 +56,7 @@ import {
   setConversationProcessingStartedAt,
 } from "../persistence/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
+import { reportSlowSync } from "../persistence/slow-sync-log.js";
 import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
 import {
   createContextWindowManager,
@@ -913,6 +914,7 @@ export class Conversation {
   // ── Lifecycle ────────────────────────────────────────────────────
 
   async loadFromDb(): Promise<void> {
+    const loadStartedAt = performance.now();
     const trustClass = this.trustContext?.trustClass;
     const canAccessMemory = resolveCapabilities(trustClass).canAccessMemory;
     const allDbMessages = getMessages(this.conversationId);
@@ -1246,10 +1248,22 @@ export class Conversation {
     this.loadedHistoryTrustClass = trustClass;
     this.loadedHistoryPersonalMemoryAllowed = personalMemoryAllowed;
 
+    const loadElapsedMs = performance.now() - loadStartedAt;
     log.info(
-      { conversationId: this.conversationId, count: this.messages.length },
+      {
+        conversationId: this.conversationId,
+        count: this.messages.length,
+        elapsedMs: loadElapsedMs,
+      },
       "Loaded messages from DB",
     );
+    // Whole read+parse+repair section — attributes an event-loop freeze to
+    // this conversation load (getMessages times the read alone; the delta is
+    // parse/repair CPU). See slow-sync-log / event-loop-watchdog.
+    reportSlowSync("conversation:load-from-db", loadElapsedMs, {
+      conversationId: this.conversationId,
+      messageCount: this.messages.length,
+    });
 
     this.restoreSurfaceStateFromHistory();
     this.graphMemory.restoreState();

package/src/daemon/handlers/conversation-history.ts

@@ -16,7 +16,9 @@ export interface ConversationSearchParams {
 }
 
 /** Search conversations and return results (no transport dependency). */
-export function performConversationSearch(params: ConversationSearchParams) {
+export async function performConversationSearch(
+  params: ConversationSearchParams,
+) {
   // Treat "*" as a list-all wildcard — FTS treats it as a literal character.
   if (params.query.trim() === "*") {
     const rows = listConversations(params.limit);