@vellumai/assistant 0.4.49 → 0.4.50

package/src/__tests__/memory-recall-quality.test.ts

@@ -54,12 +54,17 @@ mock.module("../memory/embedding-local.js", () => ({
   },
 }));
 
-// Mock Qdrant client so semantic search returns empty results instead of
-// throwing "Qdrant client not initialized" (which would discard lexical results
-// due to the single try-catch in buildMemoryRecall).
+// Dynamic Qdrant mock: tests can push results to be returned by searchWithFilter/hybridSearch
+let mockQdrantResults: Array<{
+  id: string;
+  score: number;
+  payload: Record<string, unknown>;
+}> = [];
+
 mock.module("../memory/qdrant-client.js", () => ({
   getQdrantClient: () => ({
-    searchWithFilter: async () => [],
+    searchWithFilter: async () => mockQdrantResults,
+    hybridSearch: async () => mockQdrantResults,
     upsertPoints: async () => {},
     deletePoints: async () => {},
   }),
@@ -93,9 +98,6 @@ import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { buildMemoryRecall } from "../memory/retriever.js";
 import {
   conversations,
-  memoryEntities,
-  memoryEntityRelations,
-  memoryItemEntities,
   memoryItems,
   memoryItemSources,
   messages,
@@ -256,18 +258,15 @@ describe("Memory Recall Quality", () => {
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM memory_item_sources");
-    db.run("DELETE FROM memory_item_entities");
-    db.run("DELETE FROM memory_entity_relations");
-    db.run("DELETE FROM memory_entities");
     db.run("DELETE FROM memory_embeddings");
-    db.run("DELETE FROM memory_summaries");
     db.run("DELETE FROM memory_items");
-    db.run("DELETE FROM memory_segment_fts");
+
     db.run("DELETE FROM memory_segments");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
     db.run("DELETE FROM memory_jobs");
     db.run("DELETE FROM memory_checkpoints");
+    mockQdrantResults = [];
   });
 
   afterAll(() => {
@@ -341,14 +340,68 @@ describe("Memory Recall Quality", () => {
         now + 2000,
       );
 
+      // Also insert items so the pipeline has structured data to inject
+      insertItem(db, {
+        id: "item-pref-dark",
+        kind: "preference",
+        subject: "display preference",
+        statement: "User prefers dark mode and concise answers",
+        importance: 0.8,
+        firstSeenAt: now,
+      });
+      insertItemSource(db, "item-pref-dark", "msg-pref-1", now);
+      insertItem(db, {
+        id: "item-pref-editor",
+        kind: "preference",
+        subject: "editor preference",
+        statement: "User favorite editor is Neovim",
+        importance: 0.8,
+        firstSeenAt: now + 1000,
+      });
+      insertItemSource(db, "item-pref-editor", "msg-pref-2", now + 1000);
+
+      // Mock Qdrant to return both preference items as high-scoring results
+      mockQdrantResults = [
+        {
+          id: "emb-pref-dark",
+          score: 0.92,
+          payload: {
+            target_type: "item",
+            target_id: "item-pref-dark",
+            text: "User prefers dark mode and concise answers",
+            kind: "preference",
+            status: "active",
+            created_at: now,
+            last_seen_at: now,
+          },
+        },
+        {
+          id: "emb-pref-editor",
+          score: 0.88,
+          payload: {
+            target_type: "item",
+            target_id: "item-pref-editor",
+            text: "User favorite editor is Neovim",
+            kind: "preference",
+            status: "active",
+            created_at: now + 1000,
+            last_seen_at: now + 1000,
+          },
+        },
+      ];
+
       const recall = await buildMemoryRecall(
         "what are my preferences",
         "conv-pref",
         TEST_CONFIG,
       );
 
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
+      // With high-scoring Qdrant results, items should be injected
+      expect(recall.semanticHits).toBeGreaterThan(0);
       expect(recall.injectedText).toContain("dark mode");
-      expect(recall.injectedText).toContain("concise answers");
+      expect(recall.injectedText).toContain("Neovim");
     });
 
     test("high-importance preferences outrank low-importance facts in recall", async () => {
@@ -384,7 +437,7 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-hi-pref", "msg-hi", now);
 
-      // Low-importance fact
+      // Low-importance project fact
       insertMessage(
         db,
         "msg-lo",
@@ -404,7 +457,7 @@ describe("Memory Recall Quality", () => {
       );
       insertItem(db, {
         id: "item-lo-fact",
-        kind: "fact",
+        kind: "project",
         subject: "default port",
         statement: "The default port is 8080",
         importance: 0.3,
@@ -412,13 +465,45 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-lo-fact", "msg-lo", now + 1000);
 
+      // Mock Qdrant to return both items — the high-importance one with a higher score
+      mockQdrantResults = [
+        {
+          id: "emb-hi-pref",
+          score: 0.95,
+          payload: {
+            target_type: "item",
+            target_id: "item-hi-pref",
+            text: "User strongly prefers TypeScript over JavaScript",
+            kind: "preference",
+            status: "active",
+            created_at: now,
+            last_seen_at: now,
+          },
+        },
+        {
+          id: "emb-lo-fact",
+          score: 0.7,
+          payload: {
+            target_type: "item",
+            target_id: "item-lo-fact",
+            text: "The default port is 8080",
+            kind: "project",
+            status: "active",
+            created_at: now + 1000,
+            last_seen_at: now + 1000,
+          },
+        },
+      ];
+
       const recall = await buildMemoryRecall(
         "TypeScript preference language",
         "conv-rank",
         TEST_CONFIG,
       );
 
-      // The preference should appear
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
+      // High-importance preference should be injected
       expect(recall.injectedText).toContain("TypeScript");
     });
   });
@@ -427,42 +512,13 @@ describe("Memory Recall Quality", () => {
   // Contradiction / Superseding Suppression
   // -------------------------------------------------------------------------
 
-  describe("contradiction suppression", () => {
-    test("superseded memory items do not appear in recall", async () => {
+  describe("supersession suppression", () => {
+    test("superseded memory items do not appear in recall via recency", async () => {
       const db = getDb();
       const now = 1_700_000_200_000;
       insertConversation(db, "conv-contra", now);
 
-      // Old preference (superseded)
-      insertMessage(
-        db,
-        "msg-old-pref",
-        "conv-contra",
-        "user",
-        "I prefer vim for editing code",
-        now - 50_000,
-      );
-      insertSegment(
-        db,
-        "seg-old-pref",
-        "msg-old-pref",
-        "conv-contra",
-        "user",
-        "I prefer vim for editing code",
-        now - 50_000,
-      );
-      insertItem(db, {
-        id: "item-old-pref",
-        kind: "preference",
-        subject: "editor preference",
-        statement: "User prefers vim for editing code",
-        status: "superseded",
-        importance: 0.8,
-        firstSeenAt: now - 50_000,
-      });
-      insertItemSource(db, "item-old-pref", "msg-old-pref", now - 50_000);
-
-      // New preference (active, replaces the old one)
+      // New preference (active, supersedes the old one)
       insertMessage(
         db,
         "msg-new-pref",
@@ -491,30 +547,30 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-new-pref", "msg-new-pref", now);
 
+      // Old preference (superseded by new one via supersession chain)
+      insertItem(db, {
+        id: "item-old-pref",
+        kind: "preference",
+        subject: "editor preference",
+        statement: "User prefers vim for editing code",
+        status: "superseded",
+        importance: 0.8,
+        firstSeenAt: now - 50_000,
+      });
+
       const recall = await buildMemoryRecall(
         "editor preference",
         "conv-contra",
         TEST_CONFIG,
       );
 
-      // Active preference should appear
-      expect(recall.injectedText).toContain("neovim");
-      expect(recall.injectedText).toContain("LazyVim");
-
-      // Superseded preference should NOT appear in recalled item lines.
-      // Assert against the actual statement text unique to the superseded item
-      // ("prefers vim for") rather than an internal candidate key, which is
-      // never emitted in the formatted recall output.
-      const itemLines = recall.injectedText
-        .split("\n")
-        .filter((line) => line.includes("<kind>"));
-      const hasSupersededItem = itemLines.some((line) =>
-        line.includes("prefers vim for"),
-      );
-      expect(hasSupersededItem).toBe(false);
+      // Recency search finds the segment but tier classification filters it
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      // Superseded items should not leak into injected text
+      expect(recall.injectedText).not.toContain("vim for editing code");
     });
 
-    test("only active items are included in entity-based recall", async () => {
+    test("only active items are included in recall (superseded excluded)", async () => {
       const db = getDb();
       const now = 1_700_000_250_000;
       insertConversation(db, "conv-entity-status", now);
@@ -547,6 +603,7 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-active-db", "msg-entity-active", now);
 
+      // Superseded item (should not appear)
       insertItem(db, {
         id: "item-superseded-db",
         kind: "decision",
@@ -556,12 +613,6 @@ describe("Memory Recall Quality", () => {
         importance: 0.8,
         firstSeenAt: now - 100_000,
       });
-      insertItemSource(
-        db,
-        "item-superseded-db",
-        "msg-entity-active",
-        now - 100_000,
-      );
 
       const recall = await buildMemoryRecall(
         "database choice decision",
@@ -569,17 +620,29 @@ describe("Memory Recall Quality", () => {
         TEST_CONFIG,
       );
 
-      expect(recall.injectedText).toContain("PostgreSQL");
+      // Recency search finds segments but tier classification filters them.
+      // Key assertion: superseded MySQL item should not leak.
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.injectedText).not.toContain("MySQL");
     });
 
-    test("pending clarification and invalidated items are excluded from direct item recall", async () => {
+    test("invalidated items are excluded from recall", async () => {
       const db = getDb();
       const now = 1_700_000_275_000;
-      insertConversation(db, "conv-conflict-status", now);
+      insertConversation(db, "conv-invalid-status", now);
       insertMessage(
         db,
-        "msg-conflict-status",
-        "conv-conflict-status",
+        "msg-invalid-status",
+        "conv-invalid-status",
+        "user",
+        "Framework preference is React for this codebase.",
+        now,
+      );
+      insertSegment(
+        db,
+        "seg-invalid-status",
+        "msg-invalid-status",
+        "conv-invalid-status",
         "user",
         "Framework preference is React for this codebase.",
         now,
@@ -594,52 +657,27 @@ describe("Memory Recall Quality", () => {
         importance: 0.9,
         firstSeenAt: now,
       });
-      insertItemSource(db, "item-framework-active", "msg-conflict-status", now);
+      insertItemSource(db, "item-framework-active", "msg-invalid-status", now);
 
+      // Invalidated item (should not appear in recall)
       insertItem(db, {
-        id: "item-framework-pending",
-        kind: "preference",
-        subject: "framework preference",
-        statement: "Framework preference is Vue for this codebase",
-        status: "pending_clarification",
-        importance: 0.9,
-        firstSeenAt: now + 1,
-      });
-      insertItemSource(
-        db,
-        "item-framework-pending",
-        "msg-conflict-status",
-        now + 1,
-      );
-
-      insertItem(db, {
-        id: "item-framework-invalid",
+        id: "item-framework-invalidated",
         kind: "preference",
         subject: "framework preference",
         statement: "Framework preference is Angular for this codebase",
-        status: "active",
+        status: "invalidated",
         importance: 0.9,
-        firstSeenAt: now + 2,
+        firstSeenAt: now - 50_000,
       });
-      db.run(
-        `UPDATE memory_items SET invalid_at = ${
-          now + 3
-        } WHERE id = 'item-framework-invalid'`,
-      );
-      insertItemSource(
-        db,
-        "item-framework-invalid",
-        "msg-conflict-status",
-        now + 2,
-      );
 
       const recall = await buildMemoryRecall(
         "framework preference",
-        "conv-conflict-status",
+        "conv-invalid-status",
         TEST_CONFIG,
       );
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      // Active segment content should be injected; invalidated item should not leak
       expect(recall.injectedText).toContain("React");
-      expect(recall.injectedText).not.toContain("Vue");
       expect(recall.injectedText).not.toContain("Angular");
     });
   });
@@ -693,22 +731,51 @@ describe("Memory Recall Quality", () => {
         oneMonthAgo,
       );
 
+      // Add items and mock Qdrant with the recent item scoring higher
+      insertItem(db, {
+        id: "item-bun-runtime",
+        kind: "project",
+        subject: "runtime environment",
+        statement: "We are using Bun as our runtime environment",
+        importance: 0.7,
+        firstSeenAt: now - 1000,
+      });
+      insertItemSource(db, "item-bun-runtime", "msg-recent", now - 1000);
+
+      mockQdrantResults = [
+        {
+          id: "emb-bun-runtime",
+          score: 0.9,
+          payload: {
+            target_type: "item",
+            target_id: "item-bun-runtime",
+            text: "We are using Bun as our runtime environment",
+            kind: "project",
+            status: "active",
+            created_at: now - 1000,
+            last_seen_at: now - 1000,
+          },
+        },
+      ];
+
       const recall = await buildMemoryRecall(
         "runtime environment",
         "conv-stale",
         TEST_CONFIG,
       );
 
-      // Both may appear but recent should rank higher (appear in injected text)
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
+      // Recent Bun item should be injected, old Node reference should not
       expect(recall.injectedText).toContain("Bun");
     });
 
-    test("frequently accessed items get a retrieval reinforcement boost", async () => {
+    test("frequently accessed items surface via recency search when seeded with segments", async () => {
       const db = getDb();
       const now = 1_700_000_400_000;
       insertConversation(db, "conv-access", now);
 
-      // Frequently accessed item
+      // Frequently accessed item with segment
       insertMessage(
         db,
         "msg-freq",
@@ -728,7 +795,7 @@ describe("Memory Recall Quality", () => {
       );
       insertItem(db, {
         id: "item-freq",
-        kind: "profile",
+        kind: "identity",
         subject: "timezone",
         statement: "User timezone is America/Los_Angeles",
         importance: 0.5,
@@ -737,7 +804,7 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-freq", "msg-freq", now);
 
-      // Rarely accessed item
+      // Rarely accessed item with segment
       insertMessage(
         db,
         "msg-rare",
@@ -757,7 +824,7 @@ describe("Memory Recall Quality", () => {
       );
       insertItem(db, {
         id: "item-rare",
-        kind: "profile",
+        kind: "identity",
         subject: "timezone offset",
         statement: "User timezone offset is UTC-8",
         importance: 0.5,
@@ -766,13 +833,45 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-rare", "msg-rare", now + 1000);
 
+      // Mock Qdrant with the frequently accessed item scoring higher
+      mockQdrantResults = [
+        {
+          id: "emb-freq",
+          score: 0.92,
+          payload: {
+            target_type: "item",
+            target_id: "item-freq",
+            text: "User timezone is America/Los_Angeles",
+            kind: "identity",
+            status: "active",
+            created_at: now,
+            last_seen_at: now,
+          },
+        },
+        {
+          id: "emb-rare",
+          score: 0.75,
+          payload: {
+            target_type: "item",
+            target_id: "item-rare",
+            text: "User timezone offset is UTC-8",
+            kind: "identity",
+            status: "active",
+            created_at: now + 1000,
+            last_seen_at: now + 1000,
+          },
+        },
+      ];
+
       const recall = await buildMemoryRecall(
         "timezone",
         "conv-access",
         TEST_CONFIG,
       );
 
-      // The frequently accessed item should appear
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
+      // Frequently accessed timezone item should be in injected text
       expect(recall.injectedText).toContain("America/Los_Angeles");
     });
   });
@@ -782,12 +881,12 @@ describe("Memory Recall Quality", () => {
   // -------------------------------------------------------------------------
 
   describe("multi-source recall", () => {
-    test("lexical and item-based results are merged into a single recall", async () => {
+    test("recency search surfaces segments when hybrid search is unavailable", async () => {
       const db = getDb();
       const now = 1_700_000_500_000;
       insertConversation(db, "conv-multi", now);
 
-      // Segment (lexical source)
+      // Segment (recency source)
       insertMessage(
         db,
         "msg-seg",
@@ -806,7 +905,7 @@ describe("Memory Recall Quality", () => {
         now,
       );
 
-      // Item (entity/item source)
+      // Item (constraint kind)
       insertItem(db, {
         id: "item-deploy-rule",
         kind: "constraint",
@@ -817,16 +916,33 @@ describe("Memory Recall Quality", () => {
       });
       insertItemSource(db, "item-deploy-rule", "msg-seg", now);
 
+      // Mock Qdrant to return the deployment rule item
+      mockQdrantResults = [
+        {
+          id: "emb-deploy-rule",
+          score: 0.91,
+          payload: {
+            target_type: "item",
+            target_id: "item-deploy-rule",
+            text: "Always deploy to staging before production",
+            kind: "constraint",
+            status: "active",
+            created_at: now,
+            last_seen_at: now,
+          },
+        },
+      ];
+
       const recall = await buildMemoryRecall(
         "deployment staging production",
         "conv-multi",
         TEST_CONFIG,
       );
 
-      // Both the segment and item should contribute to the recall
-      expect(recall.lexicalHits).toBeGreaterThan(0);
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
+      // Deployment rule should be injected
       expect(recall.injectedText).toContain("staging");
-      expect(recall.injectedText).toContain("production");
     });
 
     test("recall with no matching content returns empty injection", async () => {
@@ -843,288 +959,6 @@ describe("Memory Recall Quality", () => {
       expect(recall.injectedText).toBe("");
       expect(recall.injectedTokens).toBe(0);
     });
-
-    test("entity alias matching recalls linked items on indirect query terms", async () => {
-      const db = getDb();
-      const now = 1_700_000_650_000;
-      insertConversation(db, "conv-entity-alias", now);
-      insertMessage(
-        db,
-        "msg-entity-alias",
-        "conv-entity-alias",
-        "user",
-        "Our team standard editor is Visual Studio Code.",
-        now,
-      );
-
-      insertItem(db, {
-        id: "item-editor-vscode",
-        kind: "preference",
-        subject: "editor preference",
-        statement: "Team standard editor is Visual Studio Code",
-        importance: 0.8,
-        firstSeenAt: now,
-      });
-      insertItemSource(db, "item-editor-vscode", "msg-entity-alias", now);
-
-      db.insert(memoryEntities)
-        .values({
-          id: "entity-vscode",
-          name: "Visual Studio Code",
-          type: "tool",
-          aliases: JSON.stringify(["vscode"]),
-          description: null,
-          firstSeenAt: now,
-          lastSeenAt: now,
-          mentionCount: 1,
-        })
-        .run();
-      db.insert(memoryItemEntities)
-        .values({
-          memoryItemId: "item-editor-vscode",
-          entityId: "entity-vscode",
-        })
-        .run();
-
-      const recall = await buildMemoryRecall(
-        "vscode debug setup",
-        "conv-entity-alias",
-        TEST_CONFIG,
-      );
-      expect(recall.entityHits).toBeGreaterThan(0);
-      expect(recall.injectedText).toContain("Visual Studio Code");
-    });
-
-    test("relation expansion recalls neighbor-linked items when only seed entity is mentioned", async () => {
-      const db = getDb();
-      const now = 1_700_000_680_000;
-      insertConversation(db, "conv-entity-rel", now);
-      insertMessage(
-        db,
-        "msg-entity-rel",
-        "conv-entity-rel",
-        "user",
-        "Project Atlas reliability playbook.",
-        now,
-      );
-
-      insertItem(db, {
-        id: "item-k8s-hpa",
-        kind: "fact",
-        subject: "autoscaling strategy",
-        statement:
-          "Use Kubernetes horizontal pod autoscaling for sustained traffic spikes",
-        importance: 0.75,
-        firstSeenAt: now,
-      });
-      insertItemSource(db, "item-k8s-hpa", "msg-entity-rel", now);
-
-      db.insert(memoryEntities)
-        .values([
-          {
-            id: "entity-atlas",
-            name: "Project Atlas",
-            type: "project",
-            aliases: JSON.stringify(["atlas"]),
-            description: null,
-            firstSeenAt: now,
-            lastSeenAt: now,
-            mentionCount: 1,
-          },
-          {
-            id: "entity-kubernetes",
-            name: "Kubernetes",
-            type: "tool",
-            aliases: JSON.stringify(["k8s"]),
-            description: null,
-            firstSeenAt: now,
-            lastSeenAt: now,
-            mentionCount: 1,
-          },
-        ])
-        .run();
-      db.insert(memoryEntityRelations)
-        .values({
-          id: "rel-atlas-k8s",
-          sourceEntityId: "entity-atlas",
-          targetEntityId: "entity-kubernetes",
-          relation: "uses",
-          evidence: "Project Atlas runs on Kubernetes",
-          firstSeenAt: now,
-          lastSeenAt: now,
-        })
-        .run();
-      db.insert(memoryItemEntities)
-        .values({
-          memoryItemId: "item-k8s-hpa",
-          entityId: "entity-kubernetes",
-        })
-        .run();
-
-      const relationConfig = {
-        ...TEST_CONFIG,
-        memory: {
-          ...TEST_CONFIG.memory,
-          entity: {
-            ...TEST_CONFIG.memory.entity,
-            relationRetrieval: {
-              ...TEST_CONFIG.memory.entity.relationRetrieval,
-              enabled: true,
-              maxSeedEntities: 4,
-              maxNeighborEntities: 4,
-              maxEdges: 6,
-              neighborScoreMultiplier: 0.6,
-            },
-          },
-        },
-      };
-
-      const recall = await buildMemoryRecall(
-        "atlas reliability guidance",
-        "conv-entity-rel",
-        relationConfig,
-      );
-      expect(recall.entityHits).toBeGreaterThan(0);
-      expect(recall.injectedText).toContain(
-        "Kubernetes horizontal pod autoscaling",
-      );
-    });
-
-    test("direct preference evidence outranks weak relation-expanded noise", async () => {
-      const db = getDb();
-      const now = 1_700_000_690_000;
-      insertConversation(db, "conv-rel-rank", now);
-      insertMessage(
-        db,
-        "msg-rel-rank",
-        "conv-rel-rank",
-        "user",
-        "For Project Atlas deployments, we prefer blue-green rollout strategy.",
-        now,
-      );
-      insertSegment(
-        db,
-        "seg-rel-rank",
-        "msg-rel-rank",
-        "conv-rel-rank",
-        "user",
-        "For Project Atlas deployments, we prefer blue-green rollout strategy.",
-        now,
-      );
-
-      insertItem(db, {
-        id: "item-direct-pref",
-        kind: "preference",
-        subject: "deployment preference",
-        statement: "Project Atlas deployment preference is blue-green rollouts",
-        importance: 0.95,
-        firstSeenAt: now,
-      });
-      insertItemSource(db, "item-direct-pref", "msg-rel-rank", now);
-
-      db.insert(memoryEntities)
-        .values({
-          id: "entity-atlas-rank",
-          name: "Project Atlas",
-          type: "project",
-          aliases: JSON.stringify(["atlas"]),
-          description: null,
-          firstSeenAt: now,
-          lastSeenAt: now,
-          mentionCount: 1,
-        })
-        .run();
-      db.insert(memoryItemEntities)
-        .values({
-          memoryItemId: "item-direct-pref",
-          entityId: "entity-atlas-rank",
-        })
-        .run();
-
-      for (let index = 1; index <= 8; index++) {
-        const entityId = `entity-noise-${index}`;
-        const itemId = `item-rel-noise-${index}`;
-        db.insert(memoryEntities)
-          .values({
-            id: entityId,
-            name: `AtlasTool${index}`,
-            type: "tool",
-            aliases: JSON.stringify([`atlas-tool-${index}`]),
-            description: null,
-            firstSeenAt: now + index,
-            lastSeenAt: now + index,
-            mentionCount: 1,
-          })
-          .run();
-        db.insert(memoryEntityRelations)
-          .values({
-            id: `rel-atlas-noise-${index}`,
-            sourceEntityId: "entity-atlas-rank",
-            targetEntityId: entityId,
-            relation: "uses",
-            evidence: `Project Atlas uses AtlasTool${index}`,
-            firstSeenAt: now + index,
-            lastSeenAt: now + index,
-          })
-          .run();
-        insertItem(db, {
-          id: itemId,
-          kind: "fact",
-          subject: `monitoring tool ${index}`,
-          statement: `ObservabilityTool${index} emits generic telemetry metrics`,
-          importance: 0.35,
-          firstSeenAt: now + index,
-        });
-        insertItemSource(db, itemId, "msg-rel-rank", now + index);
-        db.insert(memoryItemEntities)
-          .values({
-            memoryItemId: itemId,
-            entityId,
-          })
-          .run();
-      }
-
-      const relationConfig = {
-        ...TEST_CONFIG,
-        memory: {
-          ...TEST_CONFIG.memory,
-          retrieval: {
-            ...TEST_CONFIG.memory.retrieval,
-            semanticTopK: 10,
-          },
-          entity: {
-            ...TEST_CONFIG.memory.entity,
-            relationRetrieval: {
-              ...TEST_CONFIG.memory.entity.relationRetrieval,
-              enabled: true,
-              maxSeedEntities: 6,
-              maxNeighborEntities: 20,
-              maxEdges: 20,
-              neighborScoreMultiplier: 0.7,
-            },
-          },
-        },
-      };
-
-      const recall = await buildMemoryRecall(
-        "atlas deployment preference strategy",
-        "conv-rel-rank",
-        relationConfig,
-      );
-      const orderedKeys = recall.topCandidates.map(
-        (candidate) => candidate.key,
-      );
-      const directIndex = orderedKeys.indexOf("item:item-direct-pref");
-      const noiseIndices = orderedKeys
-        .map((key, index) => ({ key, index }))
-        .filter(({ key }) => key.startsWith("item:item-rel-noise-"))
-        .map(({ index }) => index);
-
-      expect(directIndex).toBeGreaterThanOrEqual(0);
-      expect(noiseIndices.length).toBeGreaterThan(0);
-      expect(noiseIndices.every((index) => index > directIndex)).toBe(true);
-      expect(noiseIndices.length).toBeLessThanOrEqual(4);
-    });
   });
 
   // -------------------------------------------------------------------------
@@ -1152,7 +986,7 @@ describe("Memory Recall Quality", () => {
       );
     });
 
-    test("precision@k guard for preference recall fixture", async () => {
+    test("precision@k guard verifies pipeline completes with seeded segments", async () => {
       const db = getDb();
       const now = 1_700_000_700_000;
       insertConversation(db, "conv-pk", now);
@@ -1188,12 +1022,15 @@ describe("Memory Recall Quality", () => {
         TEST_CONFIG,
       );
 
-      // At least 2 of 3 preference segments should appear in recall
+      // Recency-only candidates are promoted to tier 2 and injected.
+      // Verify the pipeline recalled the preference content.
+      expect(recall.recencyHits).toBeGreaterThan(0);
+      expect(recall.enabled).toBe(true);
       assertPrecisionAtK(
         recall.injectedText,
-        ["dark mode", "TypeScript", "tabs over spaces"],
+        ["dark mode", "TypeScript", "tabs"],
         2,
-        "preference-recall",
+        "preference recall precision",
       );
     });
   });