@vellumai/assistant 0.6.6 → 0.7.1

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

@@ -1,13 +1,8 @@
 import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { setMemoryCheckpoint } from "../checkpoints.js";
-import {
-  initializeDb,
-  rawAll,
-  rawGet,
-  rawRun,
-  resetTestTables,
-} from "../db.js";
+import { initializeDb } from "../db-init.js";
+import { rawAll, rawGet, rawRun, resetTestTables } from "../raw-query.js";
 import { migrateToolCreatedItems } from "./bootstrap.js";
 
 // ---------------------------------------------------------------------------

package/src/memory/graph/bootstrap.ts

@@ -19,9 +19,10 @@ import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
-import { getDb, rawAll, rawGet, rawRun } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, hasActiveJobOfType } from "../jobs-store.js";
 import { initQdrantClient, resolveQdrantUrl } from "../qdrant-client.js";
+import { rawAll, rawGet, rawRun } from "../raw-query.js";
 import { conversations, memoryGraphNodes, memorySegments } from "../schema.js";
 import { runGraphExtraction } from "./extraction.js";
 import { countNodes } from "./store.js";

package/src/memory/graph/capability-seed.ts

@@ -22,7 +22,7 @@ import {
   type SkillCapabilityInput,
 } from "../../skills/skill-memory.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob } from "../jobs-store.js";
 import { memoryGraphNodes } from "../schema.js";
 import { createNode } from "./store.js";
@@ -40,7 +40,7 @@ const CLI_SOURCE_PREFIX = "capability:cli:";
  * Upsert a graph node for a skill capability.
  * Uses sourceConversations[0] as a stable key for deduplication.
  */
-export function upsertSkillCapabilityNode(
+function upsertSkillCapabilityNode(
   skillId: string,
   input: SkillCapabilityInput,
 ): void {
@@ -56,7 +56,7 @@ export function upsertSkillCapabilityNode(
 /**
  * Upsert a graph node for a CLI command capability.
  */
-export function upsertCliCapabilityNode(
+function upsertCliCapabilityNode(
   commandName: string,
   description: string,
 ): void {

package/src/memory/graph/compaction.ts

@@ -18,7 +18,7 @@ import {
 } from "../../providers/provider-send-message.js";
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { memoryGraphNodes } from "../schema.js";
 import { recordNodeEdit, updateNode } from "./store.js";
 

package/src/memory/graph/consolidation.ts

@@ -18,8 +18,12 @@ import {
 } from "../../providers/provider-send-message.js";
 import { BackendUnavailableError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
-import { parseEpochMs } from "./extraction.js";
+import { getDb } from "../db-connection.js";
+import {
+  EVENT_DATE_PROMPT_RULES,
+  formatAuthoritativeConversationTimestamp,
+  parseEpochMs,
+} from "./extraction.js";
 import {
   createTrigger,
   deduplicateParagraphs,
@@ -77,16 +81,15 @@ function buildConsolidationPrompt(
           .join("\n")
       : "  (none)";
 
-  const today = new Date().toLocaleDateString("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-  });
+  const currentTimestamp = formatAuthoritativeConversationTimestamp(Date.now());
 
   return `You are consolidating the "${partitionName}" partition of a memory graph. These are memories stored by an AI assistant about its conversations and relationship with a user.
 
-Today is ${today}.
+## Authoritative Current Timestamp
+
+${currentTimestamp}
+
+${EVENT_DATE_PROMPT_RULES}
 
 ## Your Tasks
 
@@ -150,7 +153,7 @@ const CONSOLIDATE_TOOL_SCHEMA = {
             event_date: {
               type: ["number", "null"] as const,
               description:
-                "Epoch ms of the event this memory describes. Preserve from merged duplicates when the survivor lacks one. Set to null to clear a stale event date.",
+                "Epoch ms of the event this memory describes. Resolve partial dates from the authoritative current timestamp and do not infer a prior year unless stated. Preserve from merged duplicates when the survivor lacks one. Set to null to clear a stale event date.",
             },
           },
           required: ["id"] as const,

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

@@ -8,6 +8,7 @@
 
 import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
@@ -17,10 +18,16 @@ import type {
   Message,
 } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
-import { getDb } from "../db.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import { getDb } from "../db-connection.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
+import {
+  injectMemoryV2Block,
+  type InjectMemoryV2Mode,
+} from "../v2/injection.js";
+import { loadNowText } from "../v2/now-text.js";
 import {
   loadGraphMemoryState,
   saveGraphMemoryState,
@@ -228,7 +235,7 @@ export class ConversationGraphMemory {
     }
     // Re-track node IDs since onCompacted evicted them
     this.tracker.add(this.lastInjectedNodeIds);
-    // Strip any existing <memory __injected> blocks from the last user message
+    // Strip any existing <memory> blocks from the last user message
     // before re-injecting, so compaction sites don't end up with duplicates.
     const cleaned = stripExistingMemoryInjections(messages);
 
@@ -257,7 +264,7 @@ export class ConversationGraphMemory {
    * Re-register cached node IDs with the InContextTracker after compaction
    * WITHOUT modifying messages. Use this at post-agent-loop compaction sites
    * where the memory block already survives on the original user message
-   * (since `<memory __injected>` is not stripped by stripInjectionsForCompaction).
+   * (since `<memory>` is not stripped by stripInjectionsForCompaction).
    *
    * Calling reinjectCachedMemory at these sites would inject a duplicate
    * onto the last user message — which after tool calls is a tool_result,
@@ -389,6 +396,46 @@ export class ConversationGraphMemory {
     this.initialized = true;
     this.needsReload = false;
 
+    // v2 routing: when the feature flag and workspace config are both on,
+    // replace v1's injection with the activation-pipeline output. v1
+    // retrieval still runs above so its tracker stays warm — keeps the
+    // off→on→off flag flip cheap and avoids invalidating cached metrics.
+    // assistantMessage is empty: context-load fires on turn 1 / post-
+    // compaction, so there is no immediately-prior assistant turn to
+    // weight the activation against.
+    //
+    // Use the raw user text (no >10-char filter) so even short greetings
+    // ("hi") get a fresh top-K activation dump on the first user message.
+    // The activation pipeline is robust to weak ANN signal — it still falls
+    // back to spreading + nowText to surface candidates.
+    const rawUserText = readRawUserText(messages[messages.length - 1]);
+    const v2 = await this.maybeRouteV2Injection(
+      messages,
+      config,
+      "context-load",
+      rawUserText ?? userQuery ?? "",
+      "",
+    );
+    if (v2.routed) {
+      this.lastInjectedBlock = v2.injectedBlockText;
+      this.lastInjectedNodeIds = [];
+      this.lastInjectedImages = new Map();
+      return {
+        runMessages: v2.runMessages,
+        injectedTokens: v2.injectedBlockText
+          ? estimateTextTokens(v2.injectedBlockText)
+          : 0,
+        latencyMs: result.latencyMs,
+        mode: "context-load" as const,
+        injectedBlockText: v2.injectedBlockText,
+        metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
+        userQueryVector: result.userQueryVector,
+        userQuerySparseVector: result.userQuerySparseVector,
+      };
+    }
+
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
       this.lastInjectedNodeIds = [];
@@ -506,6 +553,36 @@ export class ConversationGraphMemory {
       signal,
     });
 
+    // v2 routing: same gating as `runContextLoad` — when the flag and config
+    // are both on, the v2 activation pipeline produces the injection block
+    // (or `null` for the cache-stable empty path). v1 retrieval above runs
+    // unconditionally so the tracker stays in sync with the v1 nodes —
+    // cheap insurance for an off→on→off flag flip mid-conversation.
+    const v2 = await this.maybeRouteV2Injection(
+      messages,
+      config,
+      "per-turn",
+      userLast,
+      assistantLast,
+    );
+    if (v2.routed) {
+      this.lastInjectedBlock = v2.injectedBlockText;
+      this.lastInjectedNodeIds = [];
+      this.lastInjectedImages = new Map();
+      return {
+        runMessages: v2.runMessages,
+        injectedTokens: v2.injectedBlockText
+          ? estimateTextTokens(v2.injectedBlockText)
+          : 0,
+        latencyMs: result.latencyMs,
+        mode: "per-turn" as const,
+        injectedBlockText: v2.injectedBlockText,
+        metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
+      };
+    }
+
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
       this.lastInjectedNodeIds = [];
@@ -562,6 +639,62 @@ export class ConversationGraphMemory {
       sparseVector: result.sparseVector,
     };
   }
+
+  /**
+   * Route the v1 retrieval's injection step through the v2 activation
+   * pipeline when the `memory-v2-enabled` feature flag *and* the workspace
+   * config (`memory.v2.enabled`) are both on.
+   *
+   * The two outcomes the caller distinguishes via `routed`:
+   *   - `routed: false` — v2 disabled; caller runs the existing v1 injection.
+   *   - `routed: true`  — v2 ran. `runMessages` is either the v2-prepended
+   *                        message list (block was non-null) or the input
+   *                        messages unchanged (cache-stable empty path).
+   *                        Caller does NOT fall through to v1 in either case.
+   */
+  private async maybeRouteV2Injection(
+    messages: Message[],
+    config: AssistantConfig,
+    mode: InjectMemoryV2Mode,
+    userMessage: string,
+    assistantMessage: string,
+  ): Promise<{
+    routed: boolean;
+    runMessages: Message[];
+    injectedBlockText: string | null;
+  }> {
+    if (
+      !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
+      !config.memory.v2.enabled
+    ) {
+      return { routed: false, runMessages: messages, injectedBlockText: null };
+    }
+
+    const nowText = await loadNowText(getWorkspaceDir());
+    const currentTurn = this.tracker.getTurn();
+
+    const result = await injectMemoryV2Block({
+      database: getDb(),
+      conversationId: this.conversationId,
+      currentTurn,
+      userMessage,
+      assistantMessage,
+      nowText,
+      messageId: `${this.conversationId}:turn:${currentTurn}`,
+      mode,
+      config,
+    });
+
+    if (!result.block) {
+      return { routed: true, runMessages: messages, injectedBlockText: null };
+    }
+
+    return {
+      routed: true,
+      runMessages: prependMemoryV2Block(messages, result.block),
+      injectedBlockText: result.block,
+    };
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -572,7 +705,7 @@ export class ConversationGraphMemory {
  * Count the leading content blocks on a user message that were added by
  * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
  * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory __injected>…</memory>` text block. A legacy
+ * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted). A legacy
  * 2-block image pattern (no closing tag) is also accepted for backward
  * compatibility. The injection prefix is always contiguous at the start,
  * so we stop at the first non-memory block.
@@ -585,7 +718,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
     const block = content[firstNonMemory];
     if (
       block.type === "text" &&
-      block.text.startsWith("<memory __injected>\n")
+      (block.text.startsWith("<memory>\n") ||
+        block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;
       prevWasMemoryImageMarker = false;
@@ -620,7 +754,7 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
  *
  * `injectMemoryBlock` always prepends blocks in this order:
  *   1. For each image: `<memory_image __injected>…` text + `image` + `</memory_image>` text (3-block group)
- *   2. `<memory __injected>…</memory>` text block
+ *   2. `<memory>…</memory>` text block
  *
  * We strip all leading blocks that match this pattern so that
  * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
@@ -668,7 +802,7 @@ function injectTextBlock(messages: Message[], text: string): Message[] {
       content: [
         {
           type: "text" as const,
-          text: `<memory __injected>\n${text}\n</memory>`,
+          text: `<memory>\n${text}\n</memory>`,
         },
         ...userTail.content,
       ],
@@ -712,7 +846,7 @@ function injectMemoryBlock(
 
   blocks.push({
     type: "text" as const,
-    text: `<memory __injected>\n${text}\n</memory>`,
+    text: `<memory>\n${text}\n</memory>`,
   });
 
   return [
@@ -721,14 +855,52 @@ function injectMemoryBlock(
   ];
 }
 
-/** Extract text content from a user message. */
+/**
+ * Extract text content from a user message for v1's `loadContextMemory`,
+ * skipping very short messages because v1's path embeds a single dense
+ * vector and short queries produce vague results.
+ */
 function extractUserText(message: Message): string | null {
+  const joined = readRawUserText(message);
+  if (!joined) return null;
+  return joined.length > 10 ? joined : null;
+}
+
+/**
+ * Raw user-text reader (no length filter). The v2 activation pipeline can
+ * use even short queries because it spreads activation through the edge
+ * graph and combines user/assistant/now signals, so the ≤10-char guard
+ * v1 needs would unnecessarily starve v2 on short greetings.
+ */
+function readRawUserText(message: Message | undefined): string | null {
+  if (!message) return null;
   const texts = message.content
     .filter((b): b is Extract<typeof b, { type: "text" }> => b.type === "text")
     .map((b) => b.text.trim())
     .filter((t) => t.length > 0);
   if (texts.length === 0) return null;
-  const joined = texts.join(" ");
-  // Skip very short messages ("hi", "yes") — they produce vague embeddings
-  return joined.length > 10 ? joined : null;
+  return texts.join(" ");
+}
+
+/**
+ * Prepend a pre-rendered `<memory>` block (produced by
+ * `injectMemoryV2Block`) to the last user message. Unlike v1's
+ * {@link injectMemoryBlock}, the input here is already wrapped — we
+ * just need to attach it as a leading text block. We still strip any
+ * pre-existing memory injections first so the layer is idempotent
+ * across compaction-driven re-injection.
+ */
+function prependMemoryV2Block(messages: Message[], block: string): Message[] {
+  if (block.trim().length === 0) return messages;
+  if (messages.length === 0) return messages;
+  const cleaned = stripExistingMemoryInjections(messages);
+  const userTail = cleaned[cleaned.length - 1];
+  if (!userTail || userTail.role !== "user") return messages;
+  return [
+    ...cleaned.slice(0, -1),
+    {
+      ...userTail,
+      content: [{ type: "text" as const, text: block }, ...userTail.content],
+    },
+  ];
 }

package/src/memory/graph/decay.ts

@@ -9,7 +9,7 @@
 
 import { and, eq, sql } from "drizzle-orm";
 
-import { getDb } from "../db.js";
+import { getDb } from "../db-connection.js";
 import { memoryGraphNodes } from "../schema.js";
 import type { EmotionalCharge, Fidelity } from "./types.js";
 

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}`,
         ),
       ];
 
@@ -1287,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;
@@ -91,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);
+  });
+});