@vellumai/assistant 0.4.49 → 0.4.50

package/src/__tests__/memory-lifecycle-e2e.test.ts

@@ -1,3 +1,14 @@
+/**
+ * Memory lifecycle E2E regression test.
+ *
+ * Verifies the new memory pipeline end-to-end:
+ * - 6-kind enum items (identity, preference, project, decision, constraint, event)
+ * - Supersession chains (supersedes/supersededBy fields)
+ * - Hybrid search retrieval
+ * - Two-layer XML injection format (<memory_context> with sections)
+ * - Stripping removes <memory_context> tags
+ * - No conflict gate references
+ */
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -11,8 +22,6 @@ import {
   test,
 } from "bun:test";
 
-import { eq } from "drizzle-orm";
-
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 
 const testDir = mkdtempSync(join(tmpdir(), "memory-lifecycle-e2e-"));
@@ -38,56 +47,13 @@ mock.module("../util/logger.js", () => ({
 mock.module("../memory/qdrant-client.js", () => ({
   getQdrantClient: () => ({
     searchWithFilter: async () => [],
+    hybridSearch: async () => [],
     upsertPoints: async () => {},
     deletePoints: async () => {},
   }),
   initQdrantClient: () => {},
 }));
 
-// Mock clarification resolver to prevent real Anthropic API calls when
-// ANTHROPIC_API_KEY is set. Without this, resolveConflictClarification can
-// resolve conflicts via LLM before the test asserts on pending state.
-mock.module("../memory/clarification-resolver.js", () => ({
-  resolveConflictClarification: async (input: { userMessage: string }) => {
-    const msg = input.userMessage.toLowerCase();
-    // "Use the new renderer going forward" → keep candidate
-    if (
-      msg.includes("new") ||
-      msg.includes("replace") ||
-      msg.includes("instead")
-    ) {
-      return {
-        resolution: "keep_candidate" as const,
-        strategy: "heuristic" as const,
-        resolvedStatement: null,
-        explanation:
-          "User response explicitly points to candidate/new statement.",
-      };
-    }
-    // "Keep the old runtime one" → keep existing
-    if (
-      msg.includes("old") ||
-      msg.includes("existing") ||
-      msg.includes("still")
-    ) {
-      return {
-        resolution: "keep_existing" as const,
-        strategy: "heuristic" as const,
-        resolvedStatement: null,
-        explanation:
-          "User response explicitly points to existing/old statement.",
-      };
-    }
-    // Default: still_unclear (e.g. "Need react roadmap update today")
-    return {
-      resolution: "still_unclear" as const,
-      strategy: "heuristic" as const,
-      resolvedStatement: null,
-      explanation: "No clear directional cue found in user message.",
-    };
-  },
-}));
-
 const TEST_CONFIG = {
   ...DEFAULT_CONFIG,
   memory: {
@@ -103,43 +69,7 @@ const TEST_CONFIG = {
     },
     retrieval: {
       ...DEFAULT_CONFIG.memory.retrieval,
-      lexicalTopK: 40,
-      semanticTopK: 0,
       maxInjectTokens: 900,
-      dynamicBudget: {
-        ...DEFAULT_CONFIG.memory.retrieval.dynamicBudget,
-        enabled: true,
-        minInjectTokens: 180,
-        maxInjectTokens: 360,
-        targetHeadroomTokens: 700,
-      },
-      reranking: {
-        ...DEFAULT_CONFIG.memory.retrieval.reranking,
-        enabled: false,
-      },
-    },
-    entity: {
-      ...DEFAULT_CONFIG.memory.entity,
-      relationRetrieval: {
-        ...DEFAULT_CONFIG.memory.entity.relationRetrieval,
-        enabled: true,
-        maxSeedEntities: 4,
-        maxNeighborEntities: 6,
-        maxEdges: 8,
-        neighborScoreMultiplier: 0.65,
-      },
-    },
-    conflicts: {
-      ...DEFAULT_CONFIG.memory.conflicts,
-      enabled: true,
-      gateMode: "soft" as const,
-      relevanceThreshold: 0.2,
-      resolverLlmTimeoutMs: 250,
-    },
-    profile: {
-      ...DEFAULT_CONFIG.memory.profile,
-      enabled: true,
-      maxInjectTokens: 300,
     },
   },
 };
@@ -152,41 +82,22 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
-import { ConflictGate } from "../daemon/session-conflict-gate.js";
-import {
-  injectDynamicProfileIntoUserMessage,
-  stripDynamicProfileMessages,
-} from "../daemon/session-dynamic-profile.js";
-import {
-  createOrUpdatePendingConflict,
-  getConflictById,
-} from "../memory/conflict-store.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { enqueueResolvePendingConflictsForMessageJob } from "../memory/jobs-store.js";
 import {
   resetCleanupScheduleThrottle,
   resetStaleSweepThrottle,
-  runMemoryJobsOnce,
 } from "../memory/jobs-worker.js";
-import { buildMemoryRecall } from "../memory/retriever.js";
+import {
+  buildMemoryRecall,
+  injectMemoryRecallAsSeparateMessage,
+  stripMemoryRecallMessages,
+} from "../memory/retriever.js";
 import {
   conversations,
-  memoryEntities,
-  memoryEntityRelations,
-  memoryItemConflicts,
-  memoryItemEntities,
   memoryItems,
   memoryItemSources,
   messages,
 } from "../memory/schema.js";
-import type { Message } from "../providers/types.js";
-
-function messageText(message: Message): string {
-  return message.content
-    .filter((block) => block.type === "text")
-    .map((block) => (block as { type: "text"; text: string }).text)
-    .join("\n");
-}
 
 describe("Memory lifecycle E2E regression", () => {
   beforeAll(() => {
@@ -195,15 +106,9 @@ describe("Memory lifecycle E2E regression", () => {
 
   beforeEach(() => {
     const db = getDb();
-    db.run("DELETE FROM memory_item_conflicts");
-    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_item_sources");
     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");
@@ -222,7 +127,7 @@ describe("Memory lifecycle E2E regression", () => {
     }
   });
 
-  test("relation expansion, soft gate, background resolution, and profile hygiene remain consistent", async () => {
+  test("extraction produces items with 6-kind enum and supersession chains form correctly", async () => {
     const db = getDb();
     const now = 1_701_100_000_000;
     const conversationId = "conv-memory-lifecycle";
@@ -256,315 +161,267 @@ describe("Memory lifecycle E2E regression", () => {
           ]),
           createdAt: now + 10,
         },
-        {
-          id: "msg-lifecycle-background",
-          conversationId,
-          role: "user",
-          content: JSON.stringify([
-            { type: "text", text: "Keep the old runtime one." },
-          ]),
-          createdAt: now + 500,
-        },
       ])
       .run();
 
-    db.insert(memoryItems)
-      .values([
-        {
-          id: "item-atlas-direct",
-          kind: "preference",
-          subject: "atlas rollout",
-          statement: "Project Atlas prefers blue-green rollouts.",
+    // Seed items using the 6-kind enum
+    const kinds = [
+      "identity",
+      "preference",
+      "project",
+      "decision",
+      "constraint",
+      "event",
+    ] as const;
+    for (let i = 0; i < kinds.length; i++) {
+      db.insert(memoryItems)
+        .values({
+          id: `item-kind-${kinds[i]}`,
+          kind: kinds[i],
+          subject: `${kinds[i]} test`,
+          statement: `This is a ${kinds[i]} item for testing.`,
           status: "active",
-          confidence: 0.95,
-          importance: 0.9,
-          fingerprint: "fp-item-atlas-direct",
-          verificationState: "assistant_inferred",
-          scopeId: "default",
-          firstSeenAt: now + 10,
-          lastSeenAt: now + 10,
-          validFrom: now + 10,
-          invalidAt: null,
-        },
-        {
-          id: "item-k8s-relation",
-          kind: "fact",
-          subject: "autoscaling",
-          statement: "Scale API pods at 70% CPU with Kubernetes HPA.",
-          status: "active",
-          confidence: 0.82,
-          importance: 0.7,
-          fingerprint: "fp-item-k8s-relation",
+          confidence: 0.9,
+          importance: 0.8,
+          fingerprint: `fp-item-kind-${kinds[i]}`,
           verificationState: "assistant_inferred",
           scopeId: "default",
-          firstSeenAt: now + 12,
-          lastSeenAt: now + 12,
-          validFrom: now + 12,
-          invalidAt: null,
-        },
-      ])
-      .run();
-
-    db.insert(memoryItemSources)
-      .values([
-        {
-          memoryItemId: "item-atlas-direct",
+          firstSeenAt: now + i,
+          lastSeenAt: now + i,
+        })
+        .run();
+
+      db.insert(memoryItemSources)
+        .values({
+          memoryItemId: `item-kind-${kinds[i]}`,
           messageId: "msg-lifecycle-seed",
-          evidence: "Atlas rollout policy note",
-          createdAt: now + 10,
-        },
-        {
-          memoryItemId: "item-k8s-relation",
-          messageId: "msg-lifecycle-seed",
-          evidence: "Kubernetes autoscaling note",
-          createdAt: now + 12,
-        },
-      ])
-      .run();
+          evidence: `${kinds[i]} evidence`,
+          createdAt: now + i,
+        })
+        .run();
+    }
 
-    db.insert(memoryEntities)
-      .values([
-        {
-          id: "entity-atlas-lifecycle",
-          name: "Project Atlas",
-          type: "project",
-          aliases: JSON.stringify(["atlas"]),
-          description: null,
-          firstSeenAt: now,
-          lastSeenAt: now + 500,
-          mentionCount: 4,
-        },
-        {
-          id: "entity-kubernetes-lifecycle",
-          name: "Kubernetes",
-          type: "tool",
-          aliases: JSON.stringify(["k8s"]),
-          description: null,
-          firstSeenAt: now,
-          lastSeenAt: now + 500,
-          mentionCount: 3,
-        },
-      ])
+    // Create a supersession chain: old decision superseded by new decision
+    db.insert(memoryItems)
+      .values({
+        id: "item-old-decision",
+        kind: "decision",
+        subject: "deploy strategy",
+        statement: "Deploy manually every Friday.",
+        status: "superseded",
+        confidence: 0.7,
+        importance: 0.6,
+        fingerprint: "fp-old-decision",
+        verificationState: "assistant_inferred",
+        scopeId: "default",
+        firstSeenAt: now - 10_000,
+        lastSeenAt: now - 10_000,
+        supersededBy: "item-kind-decision",
+      })
       .run();
 
-    db.insert(memoryEntityRelations)
+    // Update the new decision to reference the old one
+    db.run(
+      `UPDATE memory_items SET supersedes = 'item-old-decision' WHERE id = 'item-kind-decision'`,
+    );
+
+    // Verify supersession chain is stored correctly
+    const oldDecision = db
+      .select()
+      .from(memoryItems)
+      .all()
+      .find((i) => i.id === "item-old-decision");
+    const newDecision = db
+      .select()
+      .from(memoryItems)
+      .all()
+      .find((i) => i.id === "item-kind-decision");
+
+    expect(oldDecision).toBeDefined();
+    expect(oldDecision!.status).toBe("superseded");
+    expect(oldDecision!.supersededBy).toBe("item-kind-decision");
+
+    expect(newDecision).toBeDefined();
+    expect(newDecision!.status).toBe("active");
+    expect(newDecision!.supersedes).toBe("item-old-decision");
+  });
+
+  test("recall completes and recency search retrieves relevant items", async () => {
+    const db = getDb();
+    const now = 1_701_100_000_000;
+    const conversationId = "conv-recall-lifecycle";
+
+    db.insert(conversations)
       .values({
-        id: "rel-atlas-kubernetes-lifecycle",
-        sourceEntityId: "entity-atlas-lifecycle",
-        targetEntityId: "entity-kubernetes-lifecycle",
-        relation: "uses",
-        evidence: "Project Atlas runs on Kubernetes",
-        firstSeenAt: now + 20,
-        lastSeenAt: now + 20,
+        id: conversationId,
+        title: null,
+        createdAt: now,
+        updatedAt: now,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalEstimatedCost: 0,
+        contextSummary: null,
+        contextCompactedMessageCount: 0,
+        contextCompactedAt: null,
       })
       .run();
 
-    db.insert(memoryItemEntities)
-      .values([
-        {
-          memoryItemId: "item-atlas-direct",
-          entityId: "entity-atlas-lifecycle",
-        },
-        {
-          memoryItemId: "item-k8s-relation",
-          entityId: "entity-kubernetes-lifecycle",
-        },
-      ])
+    db.insert(messages)
+      .values({
+        id: "msg-recall-seed",
+        conversationId,
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "Atlas deployment notes mention Kubernetes infrastructure.",
+          },
+        ]),
+        createdAt: now + 10,
+      })
       .run();
 
+    // Insert a segment that recency search can find
+    db.run(`
+      INSERT INTO memory_segments (
+        id, message_id, conversation_id, role, segment_index, text, token_estimate, scope_id, created_at, updated_at
+      ) VALUES (
+        'seg-recall-seed', 'msg-recall-seed', '${conversationId}', 'user', 0,
+        'Atlas deployment notes mention Kubernetes infrastructure.', 10, 'default',
+        ${now + 10}, ${now + 10}
+      )
+    `);
+
     const recall = await buildMemoryRecall(
       "atlas deployment guidance",
       conversationId,
       TEST_CONFIG,
     );
-    expect(recall.injectedText).toContain("blue-green rollouts");
-    expect(recall.injectedText).toContain("70% CPU");
-    expect(recall.relationSeedEntityCount).toBeGreaterThan(0);
-    expect(recall.relationTraversedEdgeCount).toBeGreaterThan(0);
-    expect(recall.relationNeighborEntityCount).toBeGreaterThan(0);
-    expect(recall.relationExpandedItemCount).toBeGreaterThan(0);
 
-    db.insert(memoryItems)
-      .values([
-        {
-          id: "item-ui-existing",
-          kind: "preference",
-          subject: "ui renderer",
-          statement: "React renderer is the default for Atlas dashboard.",
-          status: "active",
-          confidence: 0.88,
-          importance: 0.8,
-          fingerprint: "fp-item-ui-existing",
-          verificationState: "user_reported",
-          scopeId: "default",
-          firstSeenAt: now + 30,
-          lastSeenAt: now + 30,
-          validFrom: now + 30,
-          invalidAt: null,
-        },
-        {
-          id: "item-ui-candidate",
-          kind: "preference",
-          subject: "ui renderer",
-          statement: "Svelte renderer is the default for Atlas dashboard.",
-          status: "pending_clarification",
-          confidence: 0.84,
-          importance: 0.8,
-          fingerprint: "fp-item-ui-candidate",
-          verificationState: "user_reported",
-          scopeId: "default",
-          firstSeenAt: now + 31,
-          lastSeenAt: now + 31,
-          validFrom: now + 31,
-          invalidAt: null,
-        },
-      ])
+    // Recency search finds segments but their finalScore (semantic*0.7 +
+    // recency*0.2 + confidence*0.1) is too low to pass tier classification
+    // (threshold > 0.6) because semantic=0 with Qdrant mocked empty.
+    // Verify recency search ran successfully.
+    expect(recall.recencyHits).toBeGreaterThan(0);
+    // Candidates exist but don't pass tier classification, so injectedText is empty
+    expect(recall.enabled).toBe(true);
+  });
+
+  test("two-layer XML injection format uses <memory_context> tags", async () => {
+    const db = getDb();
+    const now = 1_701_100_000_000;
+    const conversationId = "conv-injection-format";
+
+    db.insert(conversations)
+      .values({
+        id: conversationId,
+        title: null,
+        createdAt: now,
+        updatedAt: now,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalEstimatedCost: 0,
+        contextSummary: null,
+        contextCompactedMessageCount: 0,
+        contextCompactedAt: null,
+      })
       .run();
 
-    const gatedConflict = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: "item-ui-existing",
-      candidateItemId: "item-ui-candidate",
-      relationship: "ambiguous_contradiction",
-      clarificationQuestion: "Should we keep React or move to Svelte?",
-    });
-
-    const conflictGate = new ConflictGate();
-
-    // First evaluation: conflict remains pending; evaluate returns void (no
-    // user-facing output — conflict handling is fully internal)
-    const firstResult = await conflictGate.evaluate(
-      "Need react roadmap update today",
-      TEST_CONFIG.memory.conflicts,
-    );
-    expect(firstResult).toBeUndefined();
+    db.insert(messages)
+      .values({
+        id: "msg-injection-seed",
+        conversationId,
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "My preferred timezone is America/Los_Angeles.",
+          },
+        ]),
+        createdAt: now + 10,
+      })
+      .run();
 
-    const pendingAfterFirstGate = getConflictById(gatedConflict.id);
-    expect(pendingAfterFirstGate?.status).toBe("pending_clarification");
+    db.run(`
+      INSERT INTO memory_segments (
+        id, message_id, conversation_id, role, segment_index, text, token_estimate, scope_id, created_at, updated_at
+      ) VALUES (
+        'seg-injection-seed', 'msg-injection-seed', '${conversationId}', 'user', 0,
+        'My preferred timezone is America/Los_Angeles.', 10, 'default',
+        ${now + 10}, ${now + 10}
+      )
+    `);
 
-    // Second evaluation: clarification-like reply resolves the conflict
-    // internally; still no user-facing prompt is produced
-    const secondResult = await conflictGate.evaluate(
-      "Use the new renderer going forward.",
-      TEST_CONFIG.memory.conflicts,
+    const recall = await buildMemoryRecall(
+      "timezone",
+      conversationId,
+      TEST_CONFIG,
     );
-    expect(secondResult).toBeUndefined();
 
-    const resolvedAfterSecondGate = getConflictById(gatedConflict.id);
-    expect(resolvedAfterSecondGate?.status).toBe("resolved_keep_candidate");
+    // The recency-only promotion path (Step 6 in retriever) ensures the
+    // seeded segment reaches tier 2 and is injected even without semantic
+    // search. Verify structure of the two-layer XML format.
+    expect(recall.recencyHits).toBeGreaterThan(0);
+    expect(recall.enabled).toBe(true);
+    expect(recall.injectedText.length).toBeGreaterThan(0);
+    expect(recall.injectedTokens).toBeGreaterThan(0);
+    expect(recall.injectedText).toContain("<memory_context>");
+    expect(recall.injectedText).toContain("</memory_context>");
+  });
 
-    const uiExisting = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.id, "item-ui-existing"))
-      .get();
-    const uiCandidate = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.id, "item-ui-candidate"))
-      .get();
-    expect(uiExisting?.status).toBe("superseded");
-    expect(uiCandidate?.status).toBe("active");
+  test("stripping removes <memory_context> tags from injected recall", () => {
+    const memoryRecallText =
+      "<memory_context>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    const originalMessages = [
+      {
+        role: "user" as const,
+        content: [{ type: "text", text: "Actual user request" }],
+      },
+    ];
+    const injected = injectMemoryRecallAsSeparateMessage(
+      originalMessages,
+      memoryRecallText,
+    );
 
-    db.insert(memoryItems)
-      .values([
-        {
-          id: "item-runtime-existing",
-          kind: "preference",
-          subject: "runtime",
-          statement: "Node.js 20 remains the default runtime.",
-          status: "active",
-          confidence: 0.83,
-          importance: 0.7,
-          fingerprint: "fp-item-runtime-existing",
-          verificationState: "user_reported",
-          scopeId: "default",
-          firstSeenAt: now + 200,
-          lastSeenAt: now + 200,
-          validFrom: now + 200,
-          invalidAt: null,
-        },
-        {
-          id: "item-runtime-candidate",
-          kind: "preference",
-          subject: "runtime",
-          statement: "Bun becomes the default runtime.",
-          status: "pending_clarification",
-          confidence: 0.81,
-          importance: 0.7,
-          fingerprint: "fp-item-runtime-candidate",
-          verificationState: "user_reported",
-          scopeId: "default",
-          firstSeenAt: now + 201,
-          lastSeenAt: now + 201,
-          validFrom: now + 201,
-          invalidAt: null,
-        },
-      ])
-      .run();
+    expect(injected).toHaveLength(3);
+    expect(injected[0].role).toBe("user");
+    expect(injected[0].content[0].text).toBe(memoryRecallText);
+    expect(injected[1].role as string).toBe("assistant");
+    expect(injected[2].role).toBe("user");
+    expect(injected[2].content[0].text).toBe("Actual user request");
 
-    const backgroundConflict = createOrUpdatePendingConflict({
-      scopeId: "default",
-      existingItemId: "item-runtime-existing",
-      candidateItemId: "item-runtime-candidate",
-      relationship: "ambiguous_contradiction",
-    });
+    const cleaned = stripMemoryRecallMessages(injected, memoryRecallText);
+    expect(cleaned).toHaveLength(1);
+    expect(cleaned[0].content[0].text).toBe("Actual user request");
+  });
 
-    db.update(memoryItemConflicts)
-      .set({ createdAt: now + 300, updatedAt: now + 300 })
-      .where(eq(memoryItemConflicts.id, backgroundConflict.id))
-      .run();
+  test("empty retrieval returns no injection", async () => {
+    const db = getDb();
+    const now = 1_701_100_000_000;
+    const conversationId = "conv-empty-lifecycle";
 
-    enqueueResolvePendingConflictsForMessageJob(
-      "msg-lifecycle-background",
-      "default",
-    );
-    const processedJobs = await runMemoryJobsOnce();
-    expect(processedJobs).toBe(1);
+    db.insert(conversations)
+      .values({
+        id: conversationId,
+        title: null,
+        createdAt: now,
+        updatedAt: now,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalEstimatedCost: 0,
+        contextSummary: null,
+        contextCompactedMessageCount: 0,
+        contextCompactedAt: null,
+      })
+      .run();
 
-    const backgroundResolvedConflict = getConflictById(backgroundConflict.id);
-    expect(backgroundResolvedConflict?.status).toBe("resolved_keep_existing");
-    expect(backgroundResolvedConflict?.resolutionNote).toContain(
-      "Background message resolver",
+    const recall = await buildMemoryRecall(
+      "completely unrelated xyzzy topic",
+      conversationId,
+      TEST_CONFIG,
     );
 
-    const runtimeExisting = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.id, "item-runtime-existing"))
-      .get();
-    const runtimeCandidate = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.id, "item-runtime-candidate"))
-      .get();
-    expect(runtimeExisting?.status).toBe("active");
-    expect(runtimeCandidate?.status).toBe("superseded");
-
-    const profileText =
-      "<dynamic-user-profile>\n- timezone: America/Los_Angeles\n- prefers concise answers\n</dynamic-user-profile>";
-    const baseUserMessage: Message = {
-      role: "user",
-      content: [{ type: "text", text: "Plan next sprint milestones." }],
-    };
-
-    const injectedProfileMessage = injectDynamicProfileIntoUserMessage(
-      baseUserMessage,
-      profileText,
-    );
-    const runtimeUserText = messageText(injectedProfileMessage);
-    expect(runtimeUserText).toContain("<dynamic-profile-context>");
-    expect(runtimeUserText).toContain("<dynamic-user-profile>");
-    expect(runtimeUserText).toContain("</dynamic-profile-context>");
-
-    const strippedMessages = stripDynamicProfileMessages(
-      [injectedProfileMessage],
-      profileText,
-    );
-    expect(strippedMessages).toHaveLength(1);
-    expect(messageText(strippedMessages[0] as Message).trim()).toBe(
-      "Plan next sprint milestones.",
-    );
-    expect(messageText(baseUserMessage)).toBe("Plan next sprint milestones.");
+    expect(recall.injectedText).toBe("");
+    expect(recall.injectedTokens).toBe(0);
   });
 });