@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/conversation-wipe.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -15,22 +15,17 @@ import {
   getMessages,
   wipeConversation,
 } from "../memory/conversation-crud.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 
 // Initialize db once before all tests
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 describe("wipeConversation", () => {
   beforeEach(() => {
     const db = getDb();
-    db.run(`DELETE FROM memory_item_sources`);
+    db.run(`DELETE FROM memory_graph_nodes`);
     db.run(`DELETE FROM memory_segments`);
-    db.run(`DELETE FROM memory_items`);
     db.run(`DELETE FROM memory_summaries`);
     db.run(`DELETE FROM memory_embeddings`);
     db.run(`DELETE FROM memory_jobs`);
@@ -52,237 +47,6 @@ describe("wipeConversation", () => {
     expect(getMessages(conv.id)).toEqual([]);
   });
 
-  test("restores explicitly superseded memory items", async () => {
-    const convA = createConversation("conversation A");
-    const msgA = await addMessage(convA.id, "user", "I like blue");
-
-    const convB = createConversation("conversation B");
-    const msgB = await addMessage(convB.id, "user", "I like red");
-
-    const db = getDb();
-    const now = Date.now();
-
-    // Insert itemA: active preference about color
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('itemA', 'active', 'preference', 'color', 'likes blue', 0.8, 'fp-a', 'default', ${now}, ${now})`,
-    );
-
-    // Insert itemB: active preference about color, supersedes itemA
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, supersedes, first_seen_at, last_seen_at)
-       VALUES ('itemB', 'active', 'preference', 'color', 'likes red', 0.9, 'fp-b', 'default', 'itemA', ${now}, ${now})`,
-    );
-
-    // Mark itemA as superseded by itemB
-    db.run(
-      `UPDATE memory_items SET status = 'superseded', superseded_by = 'itemB' WHERE id = 'itemA'`,
-    );
-
-    // Link itemA to convA's message, itemB to convB's message
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemA', '${msgA.id}', ${now})`,
-    );
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemB', '${msgB.id}', ${now})`,
-    );
-
-    const result = wipeConversation(convB.id);
-
-    // itemA should be restored to active with superseded_by cleared
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-    const itemARow = raw
-      .query(
-        "SELECT status, superseded_by FROM memory_items WHERE id = 'itemA'",
-      )
-      .get() as { status: string; superseded_by: string | null } | null;
-    expect(itemARow).not.toBeNull();
-    expect(itemARow!.status).toBe("active");
-    expect(itemARow!.superseded_by).toBeNull();
-
-    // itemB should no longer exist (orphaned and deleted by deleteConversation)
-    const itemBRow = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client
-      .query("SELECT * FROM memory_items WHERE id = 'itemB'")
-      .get();
-    expect(itemBRow).toBeNull();
-
-    expect(result.unsupersededItemIds).toContain("itemA");
-  });
-
-  test("does not restore superseded items when superseding item has other sources", async () => {
-    const convA = createConversation("conversation A");
-    const msgA = await addMessage(convA.id, "user", "I like red in A");
-
-    const convB = createConversation("conversation B");
-    const msgB = await addMessage(convB.id, "user", "I like red in B");
-
-    const db = getDb();
-    const now = Date.now();
-
-    // Insert itemOld (will be superseded)
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('itemOld', 'active', 'preference', 'color', 'likes blue', 0.8, 'fp-old', 'default', ${now}, ${now})`,
-    );
-
-    // Insert itemNew (supersedes itemOld)
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, supersedes, first_seen_at, last_seen_at)
-       VALUES ('itemNew', 'active', 'preference', 'color', 'likes red', 0.9, 'fp-new', 'default', 'itemOld', ${now}, ${now})`,
-    );
-
-    // Mark itemOld as superseded
-    db.run(
-      `UPDATE memory_items SET status = 'superseded', superseded_by = 'itemNew' WHERE id = 'itemOld'`,
-    );
-
-    // Link itemNew to BOTH conversations
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemNew', '${msgA.id}', ${now})`,
-    );
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemNew', '${msgB.id}', ${now})`,
-    );
-
-    wipeConversation(convA.id);
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // itemOld should still be superseded because itemNew has another source (convB)
-    const itemOldRow = raw
-      .query("SELECT status FROM memory_items WHERE id = 'itemOld'")
-      .get() as { status: string } | null;
-    expect(itemOldRow).not.toBeNull();
-    expect(itemOldRow!.status).toBe("superseded");
-
-    // itemNew should still exist (has source from convB)
-    const itemNewRow = raw
-      .query("SELECT * FROM memory_items WHERE id = 'itemNew'")
-      .get();
-    expect(itemNewRow).not.toBeNull();
-  });
-
-  test("restores orphaned subject-match superseded items", async () => {
-    const convB = createConversation("conversation B");
-    const msgB = await addMessage(convB.id, "user", "I use vim");
-
-    const db = getDb();
-    const now = Date.now();
-
-    // Insert itemOld: superseded with no superseded_by link
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('itemOld', 'superseded', 'preference', 'editor', 'uses emacs', 0.7, 'fp-old', 'default', ${now}, ${now})`,
-    );
-
-    // Insert itemNew: active, same kind/subject/scope_id
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('itemNew', 'active', 'preference', 'editor', 'uses vim', 0.9, 'fp-new', 'default', ${now}, ${now})`,
-    );
-
-    // Link itemNew to convB's message
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemNew', '${msgB.id}', ${now})`,
-    );
-
-    wipeConversation(convB.id);
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // itemOld should now be active (restored as orphaned subject-match superseded item)
-    const itemOldRow = raw
-      .query("SELECT status FROM memory_items WHERE id = 'itemOld'")
-      .get() as { status: string } | null;
-    expect(itemOldRow).not.toBeNull();
-    expect(itemOldRow!.status).toBe("active");
-  });
-
-  test("does not restore superseded items from unrelated conversations", async () => {
-    // convA has an item that superseded an older item — convA was previously
-    // deleted via regular deleteConversation, leaving the old item superseded
-    // with superseded_by = NULL. When we later wipe convB, Step F should NOT
-    // restore that unrelated item.
-    const convA = createConversation("conversation A");
-    const _msgA = await addMessage(convA.id, "user", "I use dark theme");
-
-    const convB = createConversation("conversation B");
-    const msgB = await addMessage(convB.id, "user", "I use vim");
-
-    const db = getDb();
-    const now = Date.now();
-
-    // unrelatedOld: superseded item from an old conversation (e.g. "uses light theme")
-    // Its superseder was deleted in a prior deleteConversation, leaving
-    // superseded_by = NULL.
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('unrelatedOld', 'superseded', 'preference', 'theme', 'uses light theme', 0.7, 'fp-unrelated', 'default', ${now}, ${now})`,
-    );
-
-    // convA's active item that superseded unrelatedOld — we simulate the
-    // case where convA was already deleted, leaving unrelatedOld with
-    // superseded_by = NULL and no active replacement.
-    // (We don't actually insert the superseder — just leave unrelatedOld
-    // as a superseded item with no superseded_by and no active match.)
-
-    // convB's items — itemOld is superseded by itemNew (subject: editor)
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('editorOld', 'superseded', 'preference', 'editor', 'uses emacs', 0.7, 'fp-editor-old', 'default', ${now}, ${now})`,
-    );
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('editorNew', 'active', 'preference', 'editor', 'uses vim', 0.9, 'fp-editor-new', 'default', ${now}, ${now})`,
-    );
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('editorNew', '${msgB.id}', ${now})`,
-    );
-
-    const result = wipeConversation(convB.id);
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // editorOld SHOULD be restored (its kind+subject matches an orphaned item from convB)
-    const editorOldRow = raw
-      .query("SELECT status FROM memory_items WHERE id = 'editorOld'")
-      .get() as { status: string } | null;
-    expect(editorOldRow).not.toBeNull();
-    expect(editorOldRow!.status).toBe("active");
-
-    // unrelatedOld should NOT be restored — it was superseded by a different
-    // conversation's item (theme, not editor) and has nothing to do with convB
-    const unrelatedOldRow = raw
-      .query("SELECT status FROM memory_items WHERE id = 'unrelatedOld'")
-      .get() as { status: string } | null;
-    expect(unrelatedOldRow).not.toBeNull();
-    expect(unrelatedOldRow!.status).toBe("superseded");
-
-    // Only editorOld should be in the unsuperseded list, not unrelatedOld
-    expect(result.unsupersededItemIds).toContain("editorOld");
-    expect(result.unsupersededItemIds).not.toContain("unrelatedOld");
-  });
-
   test("deletes conversation summaries", async () => {
     const conv = createConversation("test");
     await addMessage(conv.id, "user", "hello");
@@ -330,7 +94,7 @@ describe("wipeConversation", () => {
 
   test("cancels pending memory jobs", async () => {
     const conv = createConversation("test");
-    const msg = await addMessage(conv.id, "user", "hello", undefined, {
+    await addMessage(conv.id, "user", "hello", undefined, {
       skipIndexing: true,
     });
 
@@ -338,7 +102,7 @@ describe("wipeConversation", () => {
     const db = getDb();
     db.run(`DELETE FROM memory_jobs`);
 
-    enqueueMemoryJob("extract_items", { messageId: msg.id });
+    enqueueMemoryJob("graph_extract", { conversationId: conv.id });
     enqueueMemoryJob("build_conversation_summary", {
       conversationId: conv.id,
     });
@@ -357,8 +121,6 @@ describe("wipeConversation", () => {
       .all() as Array<{ status: string; last_error: string | null }>;
 
     for (const job of jobs) {
-      // Skip embed_item jobs enqueued by wipeConversation's unsupersede logic
-      if (job.status === "pending") continue;
       expect(job.status).toBe("failed");
       expect(job.last_error).toContain("conversation_wiped");
     }
@@ -373,57 +135,17 @@ describe("wipeConversation", () => {
 
     expect(getConversation(conv.id)).toBeNull();
     expect(result.segmentIds).toEqual([]);
-    expect(result.orphanedItemIds).toEqual([]);
-    expect(result.unsupersededItemIds).toEqual([]);
     expect(result.deletedSummaryIds).toEqual([]);
     expect(result.cancelledJobCount).toBe(0);
   });
-
-  test("does not affect other conversations", async () => {
-    const convA = createConversation("conversation A");
-    await addMessage(convA.id, "user", "message in A");
-
-    const convB = createConversation("conversation B");
-    const msgB = await addMessage(convB.id, "user", "message in B");
-
-    const db = getDb();
-    const now = Date.now();
-
-    // Insert a memory item sourced from convB's message
-    db.run(
-      `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-       VALUES ('itemB', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-b', 'default', ${now}, ${now})`,
-    );
-    db.run(
-      `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('itemB', '${msgB.id}', ${now})`,
-    );
-
-    wipeConversation(convA.id);
-
-    // convB should still exist
-    expect(getConversation(convB.id)).not.toBeNull();
-    expect(getMessages(convB.id)).toHaveLength(1);
-
-    // convB's memory item should still exist
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-    const itemBRow = raw
-      .query("SELECT * FROM memory_items WHERE id = 'itemB'")
-      .get();
-    expect(itemBRow).not.toBeNull();
-  });
 });
 
 describe("deleteConversation — private scope cleanup", () => {
   beforeEach(() => {
     const db = getDb();
     db.run(`DELETE FROM conversation_starters`);
-    db.run(`DELETE FROM memory_item_sources`);
+    db.run(`DELETE FROM memory_graph_nodes`);
     db.run(`DELETE FROM memory_segments`);
-    db.run(`DELETE FROM memory_items`);
     db.run(`DELETE FROM memory_summaries`);
     db.run(`DELETE FROM memory_embeddings`);
     db.run(`DELETE FROM memory_jobs`);
@@ -433,37 +155,6 @@ describe("deleteConversation — private scope cleanup", () => {
     db.run(`DELETE FROM conversations`);
   });
 
-  test("sourceless items cleaned up", () => {
-    const conv = createConversation({ conversationType: "private" });
-    const scopeId = conv.memoryScopeId;
-    const now = Date.now();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // Insert a memory item with matching scopeId but no memory_item_sources
-    raw
-      .query(
-        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-         VALUES ('priv-item-1', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-1', ?, ?, ?)`,
-      )
-      .run(scopeId, now, now);
-
-    const result = deleteConversation(conv.id);
-
-    // Item should be gone
-    const itemRow = raw
-      .query("SELECT * FROM memory_items WHERE id = 'priv-item-1'")
-      .get();
-    expect(itemRow).toBeNull();
-
-    // Its ID should be in orphanedItemIds
-    expect(result.orphanedItemIds).toContain("priv-item-1");
-  });
-
   test("summaries cleaned up", () => {
     const conv = createConversation({ conversationType: "private" });
     const scopeId = conv.memoryScopeId;
@@ -496,71 +187,15 @@ describe("deleteConversation — private scope cleanup", () => {
   });
 
   test("standard conversations unaffected", async () => {
-    const conv = createConversation("standard test");
-    const now = Date.now();
+    // Create a standard conversation and a private one
+    const standardConv = createConversation("standard test");
+    const privateConv = createConversation({ conversationType: "private" });
 
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
+    // Delete the private conversation
+    deleteConversation(privateConv.id);
 
-    // Insert items with scopeId = "default"
-    raw
-      .query(
-        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-         VALUES ('default-item-1', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-default', 'default', ?, ?)`,
-      )
-      .run(now, now);
-
-    deleteConversation(conv.id);
-
-    // Default-scope items should still exist
-    const itemRow = raw
-      .query("SELECT * FROM memory_items WHERE id = 'default-item-1'")
-      .get();
-    expect(itemRow).not.toBeNull();
-  });
-
-  test("embeddings cleaned up", () => {
-    const conv = createConversation({ conversationType: "private" });
-    const scopeId = conv.memoryScopeId;
-    const now = Date.now();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // Insert a memory item with matching scopeId
-    raw
-      .query(
-        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-         VALUES ('priv-item-emb', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-emb', ?, ?, ?)`,
-      )
-      .run(scopeId, now, now);
-
-    // Insert a corresponding embedding
-    raw
-      .query(
-        `INSERT INTO memory_embeddings (id, target_type, target_id, provider, model, dimensions, created_at, updated_at)
-         VALUES ('emb-priv-item', 'item', 'priv-item-emb', 'test', 'test', 384, ?, ?)`,
-      )
-      .run(now, now);
-
-    deleteConversation(conv.id);
-
-    // Both item and embedding should be deleted
-    const itemRow = raw
-      .query("SELECT * FROM memory_items WHERE id = 'priv-item-emb'")
-      .get();
-    expect(itemRow).toBeNull();
-
-    const embeddingRow = raw
-      .query("SELECT * FROM memory_embeddings WHERE id = 'emb-priv-item'")
-      .get();
-    expect(embeddingRow).toBeNull();
+    // Standard conversation should still exist
+    expect(getConversation(standardConv.id)).not.toBeNull();
   });
 
   test("conversationStarters cleaned up", () => {
@@ -604,40 +239,4 @@ describe("deleteConversation — private scope cleanup", () => {
       .get();
     expect(defaultStarterRow).not.toBeNull();
   });
-
-  test("no duplicate IDs", async () => {
-    const conv = createConversation({ conversationType: "private" });
-    const scopeId = conv.memoryScopeId;
-    const msg = await addMessage(conv.id, "user", "hello");
-    const now = Date.now();
-
-    const raw = (
-      getDb() as unknown as {
-        $client: import("bun:sqlite").Database;
-      }
-    ).$client;
-
-    // Insert a memory item with the private scopeId AND a source linking to the message
-    raw
-      .query(
-        `INSERT INTO memory_items (id, status, kind, subject, statement, confidence, fingerprint, scope_id, first_seen_at, last_seen_at)
-         VALUES ('priv-item-dup', 'active', 'fact', 'test', 'test fact', 0.8, 'fp-priv-dup', ?, ?, ?)`,
-      )
-      .run(scopeId, now, now);
-
-    raw
-      .query(
-        `INSERT INTO memory_item_sources (memory_item_id, message_id, created_at) VALUES ('priv-item-dup', ?, ?)`,
-      )
-      .run(msg.id, now);
-
-    const result = deleteConversation(conv.id);
-
-    // The item ID should appear exactly once in orphanedItemIds (caught by
-    // source-based cleanup, not double-counted by scope sweep).
-    const count = result.orphanedItemIds.filter(
-      (id) => id === "priv-item-dup",
-    ).length;
-    expect(count).toBe(1);
-  });
 });

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -91,7 +91,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
   updateConversationContextWindow: () => {},
-  deleteMessageById: () => ({ segmentIds: [], orphanedItemIds: [] }),
+  deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
 }));
 
@@ -227,16 +227,13 @@ describe("Conversation workspace cache state", () => {
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
-      "<workspace_top_level>",
+      "<workspace>",
     );
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
-      "</workspace_top_level>",
+      "</workspace>",
     );
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
-      `Current conversation folder: ${conversationPath}`,
-    );
-    expect(conversation.getWorkspaceTopLevelContext()!).toContain(
-      `Attachment files: ${conversationAttachmentsPath}`,
+      `Current conversation attachments: ${conversationAttachmentsPath}`,
     );
   });
 
@@ -267,7 +264,7 @@ describe("Conversation workspace cache state", () => {
 
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
-      "<workspace_top_level>",
+      "<workspace>",
     );
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
   });
@@ -286,10 +283,7 @@ describe("Conversation workspace cache state", () => {
       tempConversation.refreshWorkspaceTopLevelContextIfNeeded();
 
       expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
-        `Current conversation folder: conversations/${legacyDirName}/`,
-      );
-      expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
-        `Attachment files: conversations/${legacyDirName}/attachments/`,
+        `Current conversation attachments: conversations/${legacyDirName}/attachments/`,
       );
     } finally {
       rmSync(workspaceRoot, { recursive: true, force: true });

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -1,7 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { getConversationDirName } from "../memory/conversation-disk-view.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -124,7 +123,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
   updateConversationContextWindow: () => {},
-  deleteMessageById: () => ({ segmentIds: [], orphanedItemIds: [] }),
+  deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
 }));
 
@@ -274,13 +273,6 @@ function messageText(message: Message): string {
     .join("\n");
 }
 
-const conversationDirName = getConversationDirName(
-  "conv-1",
-  Date.parse("2026-03-19T12:00:00.000Z"),
-);
-const conversationPath = `conversations/${conversationDirName}/`;
-const conversationAttachmentsPath = `${conversationPath}attachments/`;
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -302,8 +294,8 @@ describe("Conversation workspace injection", () => {
     const runtimeUser = runCalls[0][runCalls[0].length - 1];
     expect(runtimeUser.role).toBe("user");
     const text = messageText(runtimeUser);
-    expect(text).toContain("<workspace_top_level>");
-    expect(text).toContain("</workspace_top_level>");
+    expect(text).toContain("<workspace>");
+    expect(text).toContain("</workspace>");
   });
 
   test("workspace context includes root path and directories", async () => {
@@ -316,8 +308,8 @@ describe("Conversation workspace injection", () => {
     const runtimeUser = runCalls[0][runCalls[0].length - 1];
     const text = messageText(runtimeUser);
     expect(text).toContain("Root: /tmp");
-    expect(text).toContain(`Current conversation folder: ${conversationPath}`);
-    expect(text).toContain(`Attachment files: ${conversationAttachmentsPath}`);
+    expect(text).toContain("Directories: src, tests, docs");
+    expect(text).toContain("Files: README.md, package.json");
   });
 
   test("workspace context is prepended before user text", async () => {
@@ -331,33 +323,40 @@ describe("Conversation workspace injection", () => {
     const firstBlock = runtimeUser.content[0];
     expect(firstBlock.type).toBe("text");
     const firstText = (firstBlock as { type: "text"; text: string }).text;
-    expect(firstText).toContain("<workspace_top_level>");
+    expect(firstText).toContain("<workspace>");
   });
 
-  test("workspace context is stripped from persisted history", async () => {
+  test("workspace context persists in history (not stripped between turns)", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
     await conversation.processMessage("Hello", [], () => {});
 
+    // Workspace blocks use <workspace> tag which is intentionally NOT stripped.
     const persistedMessages = conversation.getMessages();
-    for (const msg of persistedMessages) {
-      const text = messageText(msg);
-      expect(text).not.toContain("<workspace_top_level>");
-    }
+    const userMsg = persistedMessages.find((m) => m.role === "user");
+    expect(userMsg).toBeDefined();
+    const text = messageText(userMsg!);
+    expect(text).toContain("<workspace>");
   });
 
-  test("no empty user messages after stripping workspace context", async () => {
+  test("second message does NOT include workspace block", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
+    // First message — workspace is injected
     await conversation.processMessage("Hello", [], () => {});
-
-    const persistedMessages = conversation.getMessages();
-    const emptyUserMsgs = persistedMessages.filter(
-      (m) => m.role === "user" && m.content.length === 0,
-    );
-    expect(emptyUserMsgs).toHaveLength(0);
+    expect(runCalls).toHaveLength(1);
+    const firstCallUser = runCalls[0][runCalls[0].length - 1];
+    const firstText = messageText(firstCallUser);
+    expect(firstText).toContain("<workspace>");
+
+    // Second message — workspace is NOT injected (not first message, no compaction)
+    await conversation.processMessage("Follow up", [], () => {});
+    expect(runCalls).toHaveLength(2);
+    const secondCallUser = runCalls[1][runCalls[1].length - 1];
+    const secondText = messageText(secondCallUser);
+    expect(secondText).not.toContain("<workspace>");
   });
 });
 

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -120,7 +120,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
   updateConversationContextWindow: () => {},
-  deleteMessageById: () => ({ segmentIds: [], orphanedItemIds: [] }),
+  deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
 }));