@vellumai/assistant 0.10.12 → 0.11.0-staging.1

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

@@ -1,18 +1,29 @@
 // ---------------------------------------------------------------------------
 // Memory Graph — Conversation-level memory integration
 //
-// Replaces the old `prepareMemoryContext` from conversation-memory.ts.
-// Manages the InContextTracker lifecycle and dispatches to the correct
-// retrieval mode based on conversation state.
+// `graph/` is the all-tier legacy-graph store + tier dispatcher: `store.ts`,
+// `capability-seed.ts`, and `tool-handlers.ts` are written on every tier
+// (capability nodes feed `list_memory`), while the read ENGINE lives in
+// `../v1/graph/`. This class manages the InContextTracker lifecycle,
+// dispatches retrieval to the active tier's engine, and owns compaction
+// eviction of v2/v3 per-conversation state.
 // ---------------------------------------------------------------------------
 
-import type { ContentBlock, ImageContent, Message } from "@vellumai/plugin-api";
+import type {
+  AssistantEvent,
+  ContentBlock,
+  ImageContent,
+  Message,
+} from "@vellumai/plugin-api";
 import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
 import { z } from "zod";
 
+import {
+  isMemoryEnabled,
+  isV2InjectionEngineActive,
+} from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { estimateTextTokens } from "../../../../context/token-estimator.js";
-import type { ServerMessage } from "../../../../daemon/message-protocol.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import { embedWithRetry } from "../../../../persistence/embeddings/embed.js";
 import { generateSparseEmbedding } from "../../../../persistence/embeddings/embedding-backend.js";
@@ -22,6 +33,19 @@ import { memorySummaries } from "../../../../persistence/schema/index.js";
 import { getLogger } from "../logging.js";
 import { wrapMemoryBlock } from "../memory-marker.js";
 import { getWorkspaceDir } from "../paths.js";
+// V1 — delete with v1. The v1 read engine: legacy-graph retrieval and block
+// assembly, feeding the v1 fallback arms of `loadContextMemory` /
+// `retrieveForTurn` below.
+import {
+  assembleContextBlock,
+  assembleInjectionBlock,
+  MAX_CONTEXT_LOAD_IMAGES,
+  MAX_PER_TURN_IMAGES,
+  type ResolvedImage,
+  resolveInjectionImages,
+} from "../v1/graph/injection.js";
+import { loadContextMemory, retrieveForTurn } from "../v1/graph/retriever.js";
+// v2 injection engine — turn-time selection over the concept-page substrate
 import {
   clearEverInjected as clearV2EverInjected,
   hydrate as hydrateV2State,
@@ -33,22 +57,16 @@ import {
 } from "../v2/injection.js";
 import { loadNowText } from "../v2/now-text.js";
 import type { RouterTurnPair } from "../v2/router.js";
+// v3 per-conversation state — evicted here on compaction
 import { clearConversation as clearV3EverInjected } from "../v3/ever-injected-store.js";
 import {
   loadGraphMemoryState,
   saveGraphMemoryState,
 } from "./graph-memory-state-store.js";
 import {
-  assembleContextBlock,
-  assembleInjectionBlock,
   InContextTracker,
   type InContextTrackerSnapshot,
-  MAX_CONTEXT_LOAD_IMAGES,
-  MAX_PER_TURN_IMAGES,
-  type ResolvedImage,
-  resolveInjectionImages,
-} from "./injection.js";
-import { loadContextMemory, retrieveForTurn } from "./retriever.js";
+} from "./in-context-tracker.js";
 import type { RetrievalMetrics } from "./types.js";
 
 const log = getLogger("graph-conversation-memory");
@@ -80,7 +98,9 @@ const liveByConversation = new Map<string, ConversationGraphMemory>();
 export function getLiveGraphMemory(
   conversationId: string | undefined,
 ): ConversationGraphMemory | undefined {
-  if (!conversationId) return undefined;
+  if (!conversationId) {
+    return undefined;
+  }
   return liveByConversation.get(conversationId);
 }
 
@@ -132,7 +152,9 @@ export class ConversationGraphMemory {
    * Called during conversation disposal.
    */
   persistState(): void {
-    if (!this.initialized) return;
+    if (!this.initialized) {
+      return;
+    }
     try {
       const snapshot: InContextTrackerSnapshot & {
         initialized: boolean;
@@ -156,10 +178,14 @@ export class ConversationGraphMemory {
    * On failure or missing row, silently falls back to full context-load.
    */
   restoreState(): void {
-    if (this.stateRestored) return;
+    if (this.stateRestored) {
+      return;
+    }
     try {
       const json = loadGraphMemoryState(this.conversationId);
-      if (!json) return;
+      if (!json) {
+        return;
+      }
 
       const snapshot = JSON.parse(json) as InContextTrackerSnapshot & {
         initialized: boolean;
@@ -360,7 +386,9 @@ export class ConversationGraphMemory {
    * not the original user message.
    */
   retrackCachedNodes(): void {
-    if (this.lastInjectedNodeIds.length === 0) return;
+    if (this.lastInjectedNodeIds.length === 0) {
+      return;
+    }
     this.tracker.add(this.lastInjectedNodeIds);
   }
 
@@ -419,7 +447,7 @@ export class ConversationGraphMemory {
     messages: Message[],
     config: AssistantConfig,
     abortSignal: AbortSignal,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent: (msg: AssistantEvent) => void,
   ): Promise<{
     runMessages: Message[];
     injectedTokens: number;
@@ -467,7 +495,7 @@ export class ConversationGraphMemory {
       metrics: null as RetrievalMetrics | null,
     };
 
-    if (config.memory.enabled === false) {
+    if (!isMemoryEnabled(config)) {
       // Clear any cached injection so a later overflow-reduction
       // re-injection via `reinjectCachedMemory()` cannot reintroduce a
       // stale <memory> block after the user disables memory.
@@ -480,12 +508,15 @@ export class ConversationGraphMemory {
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
     const lastMessage = messages[messages.length - 1];
-    if (!lastMessage || lastMessage.role !== "user") return noopResult;
+    if (!lastMessage || lastMessage.role !== "user") {
+      return noopResult;
+    }
     const hasUserContent = lastMessage.content.some(
       (block) => block.type === "text" && block.text.trim().length > 0,
     );
-    if (!hasUserContent && this.initialized && !this.needsReload)
+    if (!hasUserContent && this.initialized && !this.needsReload) {
       return noopResult;
+    }
 
     try {
       // Decide which retrieval mode to use
@@ -530,7 +561,7 @@ export class ConversationGraphMemory {
     recentSummaries: string[],
     userQuery: string | undefined,
     signal: AbortSignal,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent: (msg: AssistantEvent) => void,
   ) {
     // 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.
@@ -581,7 +612,9 @@ export class ConversationGraphMemory {
       };
     }
 
-    // v1 fallback — only reached when the v2 flag or workspace config is off.
+    // v1 fallback — only reached when the v2 engine is not the live tier (v2
+    // disabled, memory off, or v3 live; under the concept-page substrate the
+    // retriever short-circuits to zero nodes).
     const result = await loadContextMemory({
       recentSummaries,
       userQuery,
@@ -650,7 +683,7 @@ export class ConversationGraphMemory {
       type: "memory_status",
       enabled: true,
       degraded: false,
-    } as ServerMessage);
+    } as AssistantEvent);
 
     this.lastInjectedBlock = contextBlock;
     this.lastInjectedNodeIds = [
@@ -700,11 +733,13 @@ export class ConversationGraphMemory {
       } else if (msg.role === "assistant" && !assistantLast) {
         assistantLast = text;
       }
-      if (userLastBlocks.length > 0 && assistantLast) break;
+      if (userLastBlocks.length > 0 && assistantLast) {
+        break;
+      }
     }
 
-    // v2 path — skip v1 retrieval entirely when v2 is enabled. See the
-    // matching comment in `runContextLoad` for rationale.
+    // v2 path — skip v1 retrieval entirely when the v2 engine is the live
+    // tier. See the matching comment in `runContextLoad` for rationale.
     const startedAt = Date.now();
     const v2 = await this.maybeRouteV2Injection(
       messages,
@@ -747,7 +782,9 @@ export class ConversationGraphMemory {
       };
     }
 
-    // v1 path (only reached when the v2 flag or workspace config is off).
+    // v1 path (only reached when the v2 engine is not the live tier — v2
+    // disabled, memory off, or v3 live; under the concept-page substrate the
+    // retriever short-circuits to zero nodes).
     const result = await retrieveForTurn({
       assistantLastMessage: assistantLast,
       userLastMessage: userLast,
@@ -851,11 +888,16 @@ export class ConversationGraphMemory {
   }
 
   /**
-   * Run the v2 activation pipeline when the workspace config
-   * (`memory.v2.enabled`) is on.
+   * Run the v2 activation pipeline when the v2 injection engine is the live
+   * tier ({@link isV2InjectionEngineActive}) — memory on, `memory.v2.enabled`
+   * set, and v3 not live. Every `prepareMemory` entry point shares this gate,
+   * including callers without their own v3 guard (e.g. the persona
+   * workflow-leaf runner), so a v3-live assistant never runs the v2
+   * router/activation pipeline or writes its activation/injection logs.
    *
    * The two outcomes the caller distinguishes via `routed`:
-   *   - `routed: false` — v2 disabled; caller falls through to the legacy v1
+   *   - `routed: false` — v2 engine not active (disabled, memory off, or v3
+   *                        live); caller falls through to the legacy v1
    *                        retrieval path.
    *   - `routed: true`  — v2 ran. `runMessages` is either the v2-prepended
    *                        message list (block was non-null) or the input
@@ -880,7 +922,7 @@ export class ConversationGraphMemory {
     runMessages: Message[];
     injectedBlockText: string | null;
   }> {
-    if (!config.memory.v2.enabled) {
+    if (!isV2InjectionEngineActive(config)) {
       return { routed: false, runMessages: messages, injectedBlockText: null };
     }
 
@@ -991,12 +1033,18 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
  * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
  */
 export function stripExistingMemoryInjections(messages: Message[]): Message[] {
-  if (messages.length === 0) return messages;
+  if (messages.length === 0) {
+    return messages;
+  }
   const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return messages;
+  if (!last || last.role !== "user") {
+    return messages;
+  }
 
   const stripped = stripMemoryPrefixFromUserMessage(last);
-  if (stripped === last) return messages;
+  if (stripped === last) {
+    return messages;
+  }
 
   return [...messages.slice(0, -1), stripped];
 }
@@ -1011,9 +1059,13 @@ export function stripExistingMemoryInjections(messages: Message[]): Message[] {
  * assembly strips only the TAIL's fresh v2 prefix when v3 supersedes it.
  */
 function stripMemoryPrefixFromUserMessage(message: Message): Message {
-  if (message.role !== "user") return message;
+  if (message.role !== "user") {
+    return message;
+  }
   const firstNonMemory = countMemoryPrefixBlocks(message.content);
-  if (firstNonMemory === 0) return message;
+  if (firstNonMemory === 0) {
+    return message;
+  }
   return { ...message, content: message.content.slice(firstNonMemory) };
 }
 
@@ -1024,21 +1076,31 @@ function stripMemoryPrefixFromUserMessage(message: Message): Message {
  * rendering) that otherwise discard the prepended content.
  */
 export function extractMemoryPrefixBlocks(messages: Message[]): ContentBlock[] {
-  if (messages.length === 0) return [];
+  if (messages.length === 0) {
+    return [];
+  }
   const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return [];
+  if (!last || last.role !== "user") {
+    return [];
+  }
   const count = countMemoryPrefixBlocks(last.content);
   return count === 0 ? [] : last.content.slice(0, count);
 }
 
 function injectTextBlock(messages: Message[], text: string): Message[] {
-  if (text.trim().length === 0) return messages;
-  if (messages.length === 0) return messages;
+  if (text.trim().length === 0) {
+    return messages;
+  }
+  if (messages.length === 0) {
+    return messages;
+  }
   // Strip existing memory blocks from the last user message first to prevent
   // duplicates when the message was loaded from DB with a persisted block.
   const cleaned = stripExistingMemoryInjections(messages);
   const userTail = cleaned[cleaned.length - 1];
-  if (!userTail || userTail.role !== "user") return messages;
+  if (!userTail || userTail.role !== "user") {
+    return messages;
+  }
   return [
     ...cleaned.slice(0, -1),
     {
@@ -1059,13 +1121,19 @@ function injectMemoryBlock(
   text: string,
   images: Map<string, ResolvedImage>,
 ): Message[] {
-  if (text.trim().length === 0 && images.size === 0) return messages;
-  if (messages.length === 0) return messages;
+  if (text.trim().length === 0 && images.size === 0) {
+    return messages;
+  }
+  if (messages.length === 0) {
+    return messages;
+  }
   // Strip existing memory blocks from the last user message first to prevent
   // duplicates when the message was loaded from DB with a persisted block.
   const cleaned = stripExistingMemoryInjections(messages);
   const userTail = cleaned[cleaned.length - 1];
-  if (!userTail || userTail.role !== "user") return messages;
+  if (!userTail || userTail.role !== "user") {
+    return messages;
+  }
 
   const blocks: ContentBlock[] = [];
 
@@ -1106,7 +1174,9 @@ function injectMemoryBlock(
  */
 function extractUserText(message: Message): string | null {
   const joined = readRawUserText(message);
-  if (!joined) return null;
+  if (!joined) {
+    return null;
+  }
   return joined.length > 10 ? joined : null;
 }
 
@@ -1117,12 +1187,16 @@ function extractUserText(message: Message): string | null {
  * v1 needs would unnecessarily starve v2 on short greetings.
  */
 function readRawUserText(message: Message | undefined): string | null {
-  if (!message) return 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;
+  if (texts.length === 0) {
+    return null;
+  }
   return texts.join(" ");
 }
 

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

@@ -1,5 +1,10 @@
 // ---------------------------------------------------------------------------
-// Memory Graph — Qdrant vector search for graph nodes
+// Memory Graph — node/trigger embedding plumbing (all tiers)
+//
+// Capability seeding writes graph nodes on every tier, so the
+// `embed_graph_node` and `graph_trigger_embed` jobs handled here run under
+// the substrate too. The v1 hybrid node SEARCH path lives in
+// `../v1/graph/graph-search.ts`.
 // ---------------------------------------------------------------------------
 
 import {
@@ -7,17 +12,8 @@ import {
   selectedBackendSupportsMultimodal,
 } from "@vellumai/plugin-api";
 
-import { getConfig } from "../../../../config/loader.js";
-import { usesConceptPageMemory } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import type { EmbeddingInput } from "../../../../persistence/embeddings/embedding-types.js";
-import { isQdrantBreakerOpen } from "../../../../persistence/embeddings/qdrant-circuit-breaker.js";
-import { withQdrantBreaker } from "../../../../persistence/embeddings/qdrant-circuit-breaker.js";
-import {
-  getQdrantClient,
-  type QdrantSearchResult,
-  type QdrantSparseVector,
-} from "../../../../persistence/embeddings/qdrant-client.js";
 import { asString } from "../../../../persistence/job-utils.js";
 import {
   enqueueMemoryJob,
@@ -31,114 +27,6 @@ import type { MemoryNode } from "./types.js";
 
 const log = getLogger("graph-search");
 
-// ---------------------------------------------------------------------------
-// Search
-// ---------------------------------------------------------------------------
-
-export interface GraphSearchResult {
-  nodeId: string;
-  score: number;
-  text: string;
-}
-
-/**
- * Semantic search across graph nodes in Qdrant. Returns scored node IDs
- * that the caller can hydrate from the graph store.
- *
- * Filters to `target_type: "graph_node"`.
- */
-export async function searchGraphNodes(
-  queryVector: number[],
-  limit: number,
-  sparseVector?: QdrantSparseVector,
-  dateRange?: { afterMs?: number; beforeMs?: number },
-): Promise<GraphSearchResult[]> {
-  // Concept-page memory owns the read path when active. The v1 `memory`
-  // collection is in active retirement and a corrupted sparse segment can
-  // OOM-crash the shared Qdrant process — short-circuiting here keeps v1
-  // background work and stale callers from taking it down.
-  if (usesConceptPageMemory(getConfig().memory)) {
-    return [];
-  }
-
-  if (isQdrantBreakerOpen()) {
-    log.warn("Qdrant circuit breaker open, skipping graph search");
-    return [];
-  }
-
-  const client = getQdrantClient();
-
-  const mustNot: Record<string, unknown>[] = [
-    { key: "_meta", match: { value: true } },
-  ];
-
-  // 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) {
-    const must: Record<string, unknown>[] = [
-      { key: "target_type", match: { value: "graph_node" } },
-    ];
-    if (dateRange?.afterMs != null) {
-      must.push({ key: "created_at", range: { gte: dateRange.afterMs } });
-    }
-    if (dateRange?.beforeMs != null) {
-      must.push({ key: "created_at", range: { lte: dateRange.beforeMs } });
-    }
-    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({
-        denseVector: queryVector,
-        sparseVector,
-        filter,
-        limit,
-        prefetchLimit,
-      }),
-    );
-
-    return results.map((r) => ({
-      nodeId: r.payload.target_id,
-      score: r.score,
-      text: r.payload.text,
-    }));
-  }
-
-  // Dense-only fallback
-  const denseMusts: Record<string, unknown>[] = [
-    {
-      key: "target_type",
-      match: { value: "graph_node" },
-    },
-  ];
-
-  if (dateRange?.afterMs != null) {
-    denseMusts.push({ key: "created_at", range: { gte: dateRange.afterMs } });
-  }
-  if (dateRange?.beforeMs != null) {
-    denseMusts.push({ key: "created_at", range: { lte: dateRange.beforeMs } });
-  }
-
-  const filter: Record<string, unknown> = {
-    must: denseMusts,
-    must_not: mustNot,
-  };
-
-  const results: QdrantSearchResult[] = await withQdrantBreaker(async () => {
-    return client.search(queryVector, limit, filter);
-  });
-
-  return results.map((r) => ({
-    nodeId: r.payload.target_id,
-    score: r.score,
-    text: r.payload.text,
-  }));
-}
-
 // ---------------------------------------------------------------------------
 // Embedding job
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/graph/in-context-tracker.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from "bun:test";
+
+import { InContextTracker } from "./in-context-tracker.js";
+import type { MemoryNode, ScoredNode } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const DAY_MS = 1000 * 60 * 60 * 24;
+
+function makeNode(overrides: Partial<MemoryNode> = {}): MemoryNode {
+  return {
+    id: "node-1",
+    content: "Test memory content.",
+    type: "episodic",
+    created: Date.now() - 5 * DAY_MS,
+    lastAccessed: Date.now(),
+    lastConsolidated: Date.now(),
+    eventDate: null,
+    emotionalCharge: {
+      valence: 0,
+      intensity: 0,
+      decayCurve: "linear",
+      decayRate: 0.05,
+      originalIntensity: 0,
+    },
+    fidelity: "vivid",
+    confidence: 0.8,
+    significance: 0.5,
+    stability: 14,
+    reinforcementCount: 0,
+    lastReinforced: Date.now(),
+    sourceConversations: ["conv-1"],
+    sourceType: "direct",
+    narrativeRole: null,
+    partOfStory: null,
+    imageRefs: null,
+    ...overrides,
+  };
+}
+
+function makeScored(nodeOverrides: Partial<MemoryNode> = {}): ScoredNode {
+  return {
+    node: makeNode(nodeOverrides),
+    score: 0.5,
+    scoreBreakdown: {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.5,
+      emotionalIntensity: 0,
+      temporalBoost: 0,
+      recencyBoost: 0.5,
+      triggerBoost: 0,
+      activationBoost: 0,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// InContextTracker
+// ---------------------------------------------------------------------------
+
+describe("InContextTracker", () => {
+  test("tracks added node IDs", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a", "b"]);
+    expect(tracker.isInContext("a")).toBe(true);
+    expect(tracker.isInContext("b")).toBe(true);
+    expect(tracker.isInContext("c")).toBe(false);
+  });
+
+  test("filters out nodes already in context", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+
+    const candidates: ScoredNode[] = [
+      makeScored({ id: "a" }),
+      makeScored({ id: "b" }),
+      makeScored({ id: "c" }),
+    ];
+    const filtered = tracker.filterNew(candidates);
+    expect(filtered).toHaveLength(2);
+    expect(filtered.map((c) => c.node.id)).toEqual(["b", "c"]);
+  });
+
+  test("advances turn counter", () => {
+    const tracker = new InContextTracker();
+    expect(tracker.getTurn()).toBe(0);
+    tracker.advanceTurn();
+    expect(tracker.getTurn()).toBe(1);
+    tracker.advanceTurn();
+    expect(tracker.getTurn()).toBe(2);
+  });
+
+  test("records injection log with turn numbers", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+    tracker.advanceTurn();
+    tracker.add(["b"]);
+
+    const log = tracker.getLog();
+    expect(log).toHaveLength(2);
+    expect(log[0]).toEqual({ nodeId: "a", turn: 0 });
+    expect(log[1]).toEqual({ nodeId: "b", turn: 1 });
+  });
+
+  test("returns all active node IDs", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a", "b"]);
+    tracker.advanceTurn();
+    tracker.add(["c"]);
+
+    const active = tracker.getActiveNodeIds();
+    expect(active.sort()).toEqual(["a", "b", "c"]);
+  });
+
+  test("evicts compacted turns", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+    tracker.advanceTurn();
+    tracker.add(["b"]);
+    tracker.advanceTurn();
+    tracker.add(["c"]);
+
+    // Evict turns 0 and 1
+    tracker.evictCompactedTurns(1);
+
+    expect(tracker.isInContext("a")).toBe(false);
+    expect(tracker.isInContext("b")).toBe(false);
+    expect(tracker.isInContext("c")).toBe(true);
+  });
+
+  test("keeps nodes that appear in both compacted and non-compacted turns", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+    tracker.advanceTurn();
+    tracker.add(["a"]); // same node re-injected in turn 1
+
+    // Evict turn 0 only
+    tracker.evictCompactedTurns(0);
+
+    // "a" should still be in context because it was also injected in turn 1
+    expect(tracker.isInContext("a")).toBe(true);
+  });
+
+  test("eviction cleans up log entries", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+    tracker.advanceTurn();
+    tracker.add(["b"]);
+
+    tracker.evictCompactedTurns(0);
+
+    const log = tracker.getLog();
+    expect(log).toHaveLength(1);
+    expect(log[0].nodeId).toBe("b");
+  });
+
+  test("evicting with upToTurn=0 only evicts turn 0", () => {
+    const tracker = new InContextTracker();
+    tracker.add(["a"]);
+    tracker.advanceTurn();
+    tracker.add(["b"]);
+    tracker.advanceTurn();
+    tracker.add(["c"]);
+
+    tracker.evictCompactedTurns(0);
+
+    expect(tracker.isInContext("a")).toBe(false);
+    expect(tracker.isInContext("b")).toBe(true);
+    expect(tracker.isInContext("c")).toBe(true);
+  });
+});