@vellumai/assistant 0.6.5 → 0.7.0

package/src/memory/graph/extraction.ts

@@ -27,7 +27,7 @@ import type {
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { getConversationDirPath } from "../conversation-disk-view.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { conversations, messages } from "../schema.js";
 import {
   enqueueGraphNodeEmbed,
@@ -57,6 +57,47 @@ const log = getLogger("graph-extraction");
 
 const EXTRACTION_SYSTEM_PROMPT_CHAR_BUDGET = 24_000;
 
+export const EVENT_DATE_PROMPT_RULES = `Event date grounding:
+- Treat the authoritative conversation timestamp as the only current date/time source. Do not use the model's built-in current date.
+- Resolve relative dates from that timestamp ("today", "tomorrow", "next Tuesday", "last week").
+- If the transcript gives a month/day or weekday/month/day without a year, use the authoritative conversation year unless the transcript explicitly says another year ("2025", "last year", "next year").
+- Never backdate a month/day-only reference into the prior year just because the event is in the past.
+- Sanity-check weekdays against the resolved year. For example, with an authoritative timestamp in 2026, "April 19 (Sunday night)" resolves to 2026-04-19, not 2025-04-19.
+- If the year is ambiguous after those checks, leave event_date null rather than guessing.`;
+
+export function formatAuthoritativeConversationTimestamp(
+  conversationTimestamp: number,
+): string {
+  const convDate = new Date(conversationTimestamp);
+  const timeZone =
+    Intl.DateTimeFormat().resolvedOptions().timeZone || "local time";
+  const localDate = convDate.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+  });
+  const localTime = convDate.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true,
+    timeZoneName: "short",
+  });
+
+  return `Local: ${localDate} at ${localTime} (${timeZone})\nISO: ${convDate.toISOString()}`;
+}
+
+export function buildAuthoritativeConversationTimestampBlock(
+  conversationTimestamp: number,
+): string {
+  return `## Authoritative Conversation Timestamp
+
+${formatAuthoritativeConversationTimestamp(conversationTimestamp)}
+
+Use this timestamp when resolving relative or partial dates in the transcript.`;
+}
+
 function buildGraphExtractionSystemPrompt(
   candidateNodes: Array<{ id: string; type: string; content: string }>,
   identityContext: string | null,
@@ -108,7 +149,10 @@ Do not: set the scene, describe surrounding context, preserve dialogue verbatim,
   - 0.9: Transformative moments, identity-defining events ("User said 'I love you' for the first time")
   - 1.0: RARE — reserve for the single most important memories. A graph of 1000 nodes should have fewer than 20 at 1.0.
 - **confidence**: 0-1. How sure are you this is accurate? Direct statements: 0.9+. Inferences: 0.4-0.7.
-- **event_date**: If this memory is anchored to a specific future date/time (flight, appointment, birthday, deadline, trip), provide the epoch ms. Use the conversation date above to resolve relative references ("next Tuesday", "tomorrow"). ALSO create a matching event trigger with the same date. Leave null for open-ended plans or recurring patterns.
+- **event_date**: If this memory is anchored to a specific calendar date/time, past or future (flight, appointment, birthday, deadline, trip, dated milestone), provide the epoch ms. For future dates, ALSO create a matching event trigger with the same date. Leave null for open-ended plans or recurring patterns.
+
+${EVENT_DATE_PROMPT_RULES}
+
 - **sourceType**: "direct" (user stated it), "inferred" (you derived it), "observed" (you noticed a pattern), "told-by-other".
 
 Also notice patterns in the ASSISTANT's own behavior — meta-memory. "I tend to skip verification when I'm confident." "I write more when I'm processing something big."
@@ -286,7 +330,7 @@ const EXTRACT_TOOL_SCHEMA = {
             event_date: {
               type: ["number", "null"],
               description:
-                "Epoch ms of the event date for calendar-anchored events (flights, appointments, birthdays, deadlines). Null for non-event memories.",
+                "Epoch ms for a calendar-anchored event. Resolve partial dates from the authoritative conversation timestamp and do not infer a prior year unless stated. Null for non-event memories.",
             },
             triggers: {
               type: "array",
@@ -384,7 +428,7 @@ const EXTRACT_TOOL_SCHEMA = {
             event_date: {
               type: ["number", "null"],
               description:
-                "Epoch ms of the event date. Use to update when an event is rescheduled. Set to null to clear.",
+                "Epoch ms of the event date. Resolve partial dates from the authoritative conversation timestamp. Use to update when an event is rescheduled. Set to null to clear.",
             },
           },
           required: ["id"],
@@ -1002,20 +1046,8 @@ export async function runGraphExtraction(
     imageResult?.lastTimestamp ??
     Date.now();
 
-  const convDate = new Date(conversationTimestamp);
-  const conversationDate =
-    convDate.toLocaleDateString("en-US", {
-      weekday: "long",
-      year: "numeric",
-      month: "long",
-      day: "numeric",
-    }) +
-    " at " +
-    convDate.toLocaleTimeString("en-US", {
-      hour: "numeric",
-      minute: "2-digit",
-      hour12: true,
-    });
+  const conversationTimestampBlock =
+    buildAuthoritativeConversationTimestampBlock(conversationTimestamp);
 
   // 6. LLM call — use multimodal message when images are present
   const useMultimodal = imageResult?.hasImages === true;
@@ -1027,7 +1059,7 @@ export async function runGraphExtraction(
           content: [
             {
               type: "text" as const,
-              text: `## Conversation Date\n\n${conversationDate}\n\n## Conversation Transcript\n\n`,
+              text: `${conversationTimestampBlock}\n\n## Conversation Transcript\n\n`,
             },
             ...imageResult.message.content,
           ],
@@ -1035,7 +1067,7 @@ export async function runGraphExtraction(
       ]
     : [
         userMessage(
-          `## Conversation Date\n\n${conversationDate}\n\n## Conversation Transcript\n\n${transcript}`,
+          `${conversationTimestampBlock}\n\n## Conversation Transcript\n\n${transcript}`,
         ),
       ];
 
@@ -1066,10 +1098,18 @@ export async function runGraphExtraction(
   );
 
   // 7. Handle supersession (inherit durability before applying diff)
+  // TODO: full supersession is not yet implemented. When it lands, iterate
+  // BOTH `diff.createEdges` (existing → existing) AND `deferredEdges`
+  // (new → existing, the typical supersession case).
+  // Tracked by https://github.com/vellum-ai/vellum-assistant/pull/27057 (Devin).
   for (const edge of diff.createEdges) {
     if (edge.relationship === "supersedes") {
-      // Supersession is handled differently — see supersedeNode in store
-      // For now, just mark it; full supersession is applied after node creation
+      // Placeholder — see TODO above.
+    }
+  }
+  for (const de of deferredEdges) {
+    if (de.relationship === "supersedes") {
+      // Placeholder — see TODO above.
     }
   }
 
@@ -1279,7 +1319,7 @@ function loadTranscriptFromDisk(
  *
  * Images are capped at 10 per transcript to control extraction cost.
  */
-export function loadTranscriptWithImages(
+function loadTranscriptWithImages(
   conversationId: string,
   afterTimestamp?: number,
 ): {

package/src/memory/graph/graph-memory-state-store.ts

@@ -1,6 +1,6 @@
 import { eq } from "drizzle-orm";
 
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { conversationGraphMemoryState } from "../schema.js";
 
 /**

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

@@ -1,8 +1,9 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+
 mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  getLogger: () => makeMockLogger(),
 }));
 
 let breakerOpen = false;
@@ -49,6 +50,7 @@ mock.module("../qdrant-client.js", () => ({
     },
   }),
   initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
   VellumQdrantClient: class {},
 }));
 
@@ -90,3 +92,94 @@ describe("searchGraphNodes — _meta filter parity", () => {
     expect(metaClause?.match.value).toBe(true);
   });
 });
+
+describe("searchGraphNodes — excludeScopeIds", () => {
+  beforeEach(() => {
+    breakerOpen = false;
+    hybridSearchCalls.length = 0;
+    searchCalls.length = 0;
+  });
+
+  test("hybrid path adds memory_scope_id must_not when excludeScopeIds provided", async () => {
+    await searchGraphNodes(
+      [0.1],
+      5,
+      undefined,
+      { indices: [1], values: [1] },
+      undefined,
+      ["scope:abc", "scope:xyz"],
+    );
+
+    expect(hybridSearchCalls).toHaveLength(1);
+    const filter = hybridSearchCalls[0]?.filter as {
+      must_not: Array<Record<string, unknown>>;
+    };
+    const scopeExclude = filter.must_not.find(
+      (c) => c.key === "memory_scope_id",
+    ) as { match: { any: string[] } } | undefined;
+    expect(scopeExclude?.match.any).toEqual(["scope:abc", "scope:xyz"]);
+  });
+
+  test("dense-only path adds memory_scope_id must_not when excludeScopeIds provided", async () => {
+    await searchGraphNodes([0.1], 5, undefined, undefined, undefined, [
+      "scope:abc",
+    ]);
+
+    expect(searchCalls).toHaveLength(1);
+    const filter = searchCalls[0]?.filter as {
+      must_not: Array<Record<string, unknown>>;
+    };
+    const scopeExclude = filter.must_not.find(
+      (c) => c.key === "memory_scope_id",
+    ) as { match: { any: string[] } } | undefined;
+    expect(scopeExclude?.match.any).toEqual(["scope:abc"]);
+  });
+
+  test("hybrid path omits memory_scope_id must_not when excludeScopeIds is empty", async () => {
+    await searchGraphNodes(
+      [0.1],
+      5,
+      undefined,
+      { indices: [1], values: [1] },
+      undefined,
+      [],
+    );
+
+    expect(hybridSearchCalls).toHaveLength(1);
+    const filter = hybridSearchCalls[0]?.filter as {
+      must_not: Array<Record<string, unknown>>;
+    };
+    const scopeExclude = filter.must_not.find(
+      (c) => c.key === "memory_scope_id",
+    );
+    expect(scopeExclude).toBeUndefined();
+  });
+});
+
+describe("searchGraphNodes — prefetch floor", () => {
+  beforeEach(() => {
+    breakerOpen = false;
+    hybridSearchCalls.length = 0;
+    searchCalls.length = 0;
+  });
+
+  test("hybrid prefetchLimit floors at 200 for small limits", async () => {
+    await searchGraphNodes([0.1], 10, ["default"], {
+      indices: [1],
+      values: [1],
+    });
+
+    expect(hybridSearchCalls).toHaveLength(1);
+    expect(hybridSearchCalls[0]?.prefetchLimit).toBe(200);
+  });
+
+  test("hybrid prefetchLimit scales with limit when limit*10 exceeds floor", async () => {
+    await searchGraphNodes([0.1], 50, ["default"], {
+      indices: [1],
+      values: [1],
+    });
+
+    expect(hybridSearchCalls).toHaveLength(1);
+    expect(hybridSearchCalls[0]?.prefetchLimit).toBe(500);
+  });
+});

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/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

@@ -877,9 +877,16 @@ export interface TurnRetrievalResult {
    */
   queryVector?: number[];
   /**
-   * Optional sparse vector passed alongside `queryVector`. Currently always
-   * `undefined` — reserved for future hybrid retrieval that produces a
-   * sparse vector at the call site.
+   * Sparse (TF-IDF) vector of the user's last message, computed once per
+   * turn and reused across every return path of `retrieveForTurn`. Surfaced
+   * so downstream callers (e.g. the PKB hint retriever in
+   * `applyRuntimeInjections`) can pair it with `queryVector` to run a
+   * hybrid dense+sparse query — RRF fusion pulls in lexical matches
+   * (exact filenames, proper nouns, uncommon tokens) that pure dense
+   * embeddings wash out. Computed locally (no embedding-service call), so
+   * it survives even when the dense embed fails via the circuit breaker.
+   * `undefined` when the user's last message is empty/whitespace-only or
+   * yields no TF-IDF tokens.
    */
   sparseVector?: QdrantSparseVector;
 }
@@ -926,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) {
@@ -1037,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,