@vellumai/assistant 0.6.6 → 0.7.1

package/src/memory/graph/graph-search.ts

@@ -37,6 +37,8 @@ export interface GraphSearchResult {
  * that the caller can hydrate from the graph store.
  *
  * Filters to `target_type: "graph_node"` and optionally by scope.
+ * `excludeScopeIds` adds a `must_not` against `memory_scope_id` for callers
+ * that need to omit specific scopes from a broader recall search.
  */
 export async function searchGraphNodes(
   queryVector: number[],
@@ -44,6 +46,7 @@ export async function searchGraphNodes(
   scopeIds?: string[],
   sparseVector?: QdrantSparseVector,
   dateRange?: { afterMs?: number; beforeMs?: number },
+  excludeScopeIds?: string[],
 ): Promise<GraphSearchResult[]> {
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
@@ -52,6 +55,16 @@ export async function searchGraphNodes(
 
   const client = getQdrantClient();
 
+  const mustNot: Record<string, unknown>[] = [
+    { key: "_meta", match: { value: true } },
+  ];
+  if (excludeScopeIds && excludeScopeIds.length > 0) {
+    mustNot.push({
+      key: "memory_scope_id",
+      match: { any: excludeScopeIds },
+    });
+  }
+
   // Use hybrid search (dense + sparse with RRF fusion) when a non-empty
   // sparse vector is available; otherwise fall back to dense-only search.
   if (sparseVector && sparseVector.indices.length > 0) {
@@ -67,10 +80,12 @@ export async function searchGraphNodes(
     if (dateRange?.beforeMs != null) {
       must.push({ key: "created_at", range: { lte: dateRange.beforeMs } });
     }
-    const filter = {
-      must,
-      must_not: [{ key: "_meta", match: { value: true } }],
-    };
+    const filter = { must, must_not: mustNot };
+
+    // RRF fuses per-modality top-N. A small prefetch (e.g. limit*3) silently
+    // truncates good matches when the query is wordy or low-similarity, so
+    // give RRF a meaningful candidate window with a generous floor.
+    const prefetchLimit = Math.max(limit * 10, 200);
 
     const results: QdrantSearchResult[] = await withQdrantBreaker(() =>
       client.hybridSearch({
@@ -78,7 +93,7 @@ export async function searchGraphNodes(
         sparseVector,
         filter,
         limit,
-        prefetchLimit: limit * 3,
+        prefetchLimit,
       }),
     );
 
@@ -112,7 +127,7 @@ export async function searchGraphNodes(
 
   const filter: Record<string, unknown> = {
     must: denseMusts,
-    must_not: [{ key: "_meta", match: { value: true } }],
+    must_not: mustNot,
   };
 
   const results: QdrantSearchResult[] = await withQdrantBreaker(async () => {
@@ -250,7 +265,7 @@ export async function embedGraphTriggerJob(
   if (!triggerId) return;
 
   // Import here to avoid circular dependency
-  const { getDb } = await import("../db.js");
+  const { getDb } = await import("../db-connection.js");
   const { eq } = await import("drizzle-orm");
   const { memoryGraphTriggers } = await import("../schema.js");
   const { embedWithBackend } = await import("../embedding-backend.js");

package/src/memory/graph/image-ref-utils.ts

@@ -1,6 +1,6 @@
 import { eq } from "drizzle-orm";
 
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { extractMediaBlocks } from "../message-content.js";
 import { messages } from "../schema.js";
 import type { ImageRef } from "./types.js";

package/src/memory/graph/injection.test.ts

@@ -192,9 +192,9 @@ describe("assembleContextBlock", () => {
     expect(assembleContextBlock([])).toBe("");
   });
 
-  test("includes the main heading", () => {
+  test("omits the legacy `What I Remember Right Now` heading", () => {
     const result = assembleContextBlock([makeScored()]);
-    expect(result).toContain("## What I Remember Right Now");
+    expect(result).not.toContain("## What I Remember Right Now");
   });
 
   test("puts prospective nodes under Active Threads", () => {

package/src/memory/graph/injection.ts

@@ -381,7 +381,7 @@ export function assembleContextBlock(
   }
 
   if (parts.length === 0) return "";
-  return `## What I Remember Right Now\n\n${parts.join("\n\n")}`;
+  return parts.join("\n\n");
 }
 
 function buildSection(nodes: ScoredNode[], maxItems: number): string[] {

package/src/memory/graph/retriever.test.ts

@@ -31,10 +31,12 @@ mock.module("../embed.js", () => ({
   ) => {
     embedCallCount++;
     if (embedShouldThrow) throw new Error("embedding backend down");
-    const firstText = typeof texts[0] === "string" ? texts[0] : "";
-    const vector = embedRouter ? embedRouter(firstText) : embedVector;
+    const vectors = texts.map((t) => {
+      const text = typeof t === "string" ? t : "";
+      return embedRouter ? embedRouter(text) : embedVector;
+    });
     return {
-      vectors: [vector],
+      vectors,
       provider: "test-provider",
       model: "test-model",
     };
@@ -71,7 +73,9 @@ mock.module("../../providers/provider-send-message.js", () => ({
 
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { initializeDb, resetDb, resetTestTables } from "../db.js";
+import { resetDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { resetTestTables } from "../raw-query.js";
 import { InContextTracker } from "./injection.js";
 import { loadContextMemory, retrieveForTurn } from "./retriever.js";
 import { createNode } from "./store.js";
@@ -238,6 +242,156 @@ describe("retrieveForTurn — query/sparse vector surfacing", () => {
   });
 });
 
+describe("retrieveForTurn — topic-pivot recovery", () => {
+  // Build a one-hot keyword router so the combined assistant+user query and
+  // the user-only query produce distinct vectors that can be routed to
+  // disjoint Qdrant result sets. The key for the bug fix is that a long
+  // shirt-themed assistant message + a short cake-themed user message
+  // currently produces a vector dominated by the shirt content (the
+  // user-only signal is washed out), so unless the user-only embedding
+  // also runs and feeds Qdrant, cake nodes never enter the candidate pool.
+  function keywordEmbedRouter(text: string): number[] {
+    const lowered = text.toLowerCase();
+    const cakeHits = (lowered.match(/cake/g) ?? []).length;
+    const shirtHits = (lowered.match(/shirt/g) ?? []).length;
+    if (cakeHits > shirtHits) return [0, 1, 0];
+    if (shirtHits > cakeHits) return [1, 0, 0];
+    return [0.1, 0.1, 0.1];
+  }
+
+  let cakeNodeId = "";
+  let shirtNodeId = "";
+
+  function vectorSearchRouter(vector: number[]): SearchHit[] {
+    const [a = 0, b = 0] = vector;
+    if (a === 1 && b === 0) return [{ nodeId: shirtNodeId, score: 0.9 }];
+    if (a === 0 && b === 1) return [{ nodeId: cakeNodeId, score: 0.9 }];
+    return [];
+  }
+
+  function makeEpisodicNode(content: string): NewNode {
+    const now = Date.now();
+    return {
+      content,
+      type: "episodic",
+      created: now,
+      lastAccessed: now,
+      lastConsolidated: now,
+      eventDate: null,
+      emotionalCharge: {
+        valence: 0,
+        intensity: 0,
+        decayCurve: "linear",
+        decayRate: 0,
+        originalIntensity: 0,
+      },
+      fidelity: "vivid",
+      confidence: 1,
+      significance: 0.5,
+      stability: 14,
+      reinforcementCount: 0,
+      lastReinforced: now,
+      sourceConversations: [],
+      sourceType: "direct",
+      narrativeRole: null,
+      partOfStory: null,
+      imageRefs: null,
+      scopeId: "test-scope",
+    };
+  }
+
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  beforeEach(() => {
+    embedShouldThrow = false;
+    embedVector = [0.1, 0.2, 0.3];
+    embedCallCount = 0;
+    embedRouter = keywordEmbedRouter;
+    searchRouter = vectorSearchRouter;
+    resetTestTables(
+      "memory_graph_triggers",
+      "memory_graph_edges",
+      "memory_graph_nodes",
+    );
+    cakeNodeId = createNode(
+      makeEpisodicNode("Notes on the birthday cake from the bakery."),
+    ).id;
+    shirtNodeId = createNode(
+      makeEpisodicNode("Notes on the souvenir shirt from the conference."),
+    ).id;
+  });
+
+  test("user-only embed surfaces topic-pivot candidates the combined embed misses", async () => {
+    const tracker = new InContextTracker();
+    // Long shirt-themed assistant message that dominates the combined
+    // embedding, paired with a short cake-themed user pivot.
+    const assistantLast =
+      "shirt shirt shirt shirt shirt shirt shirt shirt " +
+      "shirt shirt shirt shirt shirt shirt shirt shirt";
+    const userLast = "the birthday cake";
+
+    const result = await retrieveForTurn({
+      assistantLastMessage: assistantLast,
+      userLastMessage: userLast,
+      scopeId: "test-scope",
+      config: TEST_CONFIG,
+      tracker,
+    });
+
+    // Both embeds ran (combined + user-only).
+    expect(embedCallCount).toBe(1);
+    // Combined query embedding (still surfaced for PKB hybrid search).
+    expect(result.queryVector).toEqual([1, 0, 0]);
+    // The cake node should appear in the candidate pool — it would be
+    // missing entirely if only the combined embedding drove the search.
+    const candidateIds = new Set(
+      result.metrics.topCandidates.map((c) => c.nodeId),
+    );
+    expect(candidateIds.has(cakeNodeId)).toBe(true);
+    expect(candidateIds.has(shirtNodeId)).toBe(true);
+  });
+
+  test("skips the user-only chunk when the user message is empty", async () => {
+    const tracker = new InContextTracker();
+    const result = await retrieveForTurn({
+      assistantLastMessage: "shirt shirt shirt shirt shirt",
+      userLastMessage: "",
+      scopeId: "test-scope",
+      config: TEST_CONFIG,
+      tracker,
+    });
+
+    // Only the combined (assistant-only) embedding ran; user-only is skipped.
+    expect(embedCallCount).toBe(1);
+    const candidateIds = new Set(
+      result.metrics.topCandidates.map((c) => c.nodeId),
+    );
+    expect(candidateIds.has(shirtNodeId)).toBe(true);
+    expect(candidateIds.has(cakeNodeId)).toBe(false);
+  });
+
+  test("does not duplicate the user-only chunk when it is already the only chunk", async () => {
+    const tracker = new InContextTracker();
+    // No assistant message → queryText === userLastMessage, so user-only is
+    // already the sole chunk. The dedup check should prevent re-adding it.
+    const result = await retrieveForTurn({
+      assistantLastMessage: "",
+      userLastMessage: "the birthday cake",
+      scopeId: "test-scope",
+      config: TEST_CONFIG,
+      tracker,
+    });
+
+    expect(embedCallCount).toBe(1);
+    const candidateIds = new Set(
+      result.metrics.topCandidates.map((c) => c.nodeId),
+    );
+    expect(candidateIds.has(cakeNodeId)).toBe(true);
+  });
+});
+
 describe("loadContextMemory — dual-query capability ranking", () => {
   // Capture seeded capability node IDs so the searchGraphNodes mock can
   // reference them by ID (the mock runs at call time, not seed time).

package/src/memory/graph/retriever.ts

@@ -933,11 +933,10 @@ export async function retrieveForTurn(
   // hint search can pair it with the per-turn dense vector, pulling in
   // lexical matches (exact filenames, proper nouns, uncommon tokens) that
   // pure dense embeddings wash out. Computed locally with no network call.
-  // The dense `queryVector` for per-turn is the combined assistant+user
-  // embedding (it drives graph search), so this pairing is slightly
-  // asymmetric — the sparse signal is user-only while the dense is mixed.
-  // That's acceptable for PKB's purpose: lexical matches are overwhelmingly
-  // driven by the user's own wording.
+  // The surfaced `queryVector` is the combined assistant+user embedding
+  // (drives PKB hybrid search alongside this sparse signal). The graph
+  // search itself runs against both the combined embedding and a separate
+  // user-only embedding — see the user-only chunk added below.
   const trimmedUserLast = opts.userLastMessage.trim();
   let perTurnSparseVector: QdrantSparseVector | undefined = undefined;
   if (trimmedUserLast.length > 0) {
@@ -1044,6 +1043,19 @@ export async function retrieveForTurn(
     }
   }
 
+  // Topic-pivot recovery: also embed the user message alone. When the
+  // assistant's prior message is long (e.g. includes <thinking>), the
+  // combined embedding is dominated by it and a short user pivot to a new
+  // topic gets drowned out. Searching with both vectors and unioning the
+  // candidates lets the pivot compete in scoring.
+  if (
+    trimmedUserLast.length > 0 &&
+    opts.userLastMessage.length <= maxQueryChars &&
+    !chunks.includes(opts.userLastMessage)
+  ) {
+    chunks.push(opts.userLastMessage);
+  }
+
   // 2. Embed chunks and search (parallel)
   let queryEmbeddings: number[][] = [];
 

package/src/memory/graph/store.test.ts

@@ -1,6 +1,7 @@
 import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
 
-import { initializeDb, resetTestTables } from "../db.js";
+import { initializeDb } from "../db-init.js";
+import { resetTestTables } from "../raw-query.js";
 import {
   applyDiff,
   countNodes,

package/src/memory/graph/store.ts

@@ -5,7 +5,7 @@
 import { and, desc, eq, inArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob } from "../jobs-store.js";
 import {
   memoryGraphEdges,