@vellumai/assistant 0.5.15 → 0.6.0

package/src/__tests__/conversation-slash-commands.test.ts

@@ -5,9 +5,7 @@ import {
   type SlashContext,
 } from "../daemon/conversation-slash.js";
 
-function makeSlashContext(
-  overrides: Partial<SlashContext> = {},
-): SlashContext {
+function makeSlashContext(overrides: Partial<SlashContext> = {}): SlashContext {
   return {
     messageCount: 4,
     inputTokens: 1024,
@@ -43,9 +41,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/fork — Fork the current conversation into a new branch",
       "/pair — Generate pairing info for connecting a mobile device",
     ]);
-    expect(lines).not.toContain(
-      "/model — Switch the active model",
-    );
+    expect(lines).not.toContain("/model — Switch the active model");
   });
 
   test("renders iOS command help with /fork but without /pair", async () => {

package/src/__tests__/conversation-starter-routes.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";
 
 import { v4 as uuid } from "uuid";
 
@@ -9,7 +9,7 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
+import { getSqlite, initializeDb } from "../memory/db.js";
 import {
   conversationStarterRouteDefinitions,
   orderStrongestFirst,
@@ -17,10 +17,6 @@ import {
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 const routes = conversationStarterRouteDefinitions();
 
 function dispatch(path: string): Response | Promise<Response> {
@@ -41,7 +37,7 @@ function dispatch(path: string): Response | Promise<Response> {
 
 function clearTables() {
   getSqlite().run("DELETE FROM conversation_starters");
-  getSqlite().run("DELETE FROM memory_items");
+  getSqlite().run("DELETE FROM memory_graph_nodes");
   getSqlite().run("DELETE FROM memory_jobs");
   getSqlite().run("DELETE FROM memory_checkpoints");
 }
@@ -73,10 +69,23 @@ function insertStarter(overrides: {
 function insertMemoryItem(scopeId = "default") {
   const now = Date.now();
   getSqlite().run(
-    `INSERT INTO memory_items (
-      id, kind, subject, statement, status, confidence, fingerprint, scope_id, first_seen_at, last_seen_at
-    ) VALUES (?, 'fact', 'test', 'test statement', 'active', 0.9, ?, ?, ?, ?)`,
-    [uuid(), `fingerprint-${uuid()}`, scopeId, now, now],
+    `INSERT INTO memory_graph_nodes (
+      id, content, type, created, last_accessed, last_consolidated,
+      emotional_charge, fidelity, confidence, significance,
+      stability, reinforcement_count, last_reinforced,
+      source_conversations, source_type, scope_id
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'vivid', 0.8, 0.5, 14, 0, ?, '[]', 'inferred', ?)`,
+    [
+      uuid(),
+      "test\ntest statement",
+      "semantic",
+      now,
+      now,
+      now,
+      '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
+      now,
+      scopeId,
+    ],
   );
 }
 

package/src/__tests__/conversation-store.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: () =>
@@ -24,15 +24,11 @@ import {
   getMessages,
 } from "../memory/conversation-crud.js";
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 
 // Initialize db once before all tests
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 describe("deleteLastExchange", () => {
   beforeEach(() => {
     // Reset database between tests by dropping and recreating tables

package/src/__tests__/conversation-usage.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";
 
 const updateConversationUsageCalls: Array<{
   conversationId: string;
@@ -37,17 +37,13 @@ mock.module("../memory/conversation-crud.js", () => ({
 }));
 
 import { recordUsage } from "../daemon/conversation-usage.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { listUsageEvents } from "../memory/llm-usage-store.js";
 import type { PricingUsage } from "../usage/types.js";
 import { resolvePricingForUsageWithOverrides } from "../util/pricing.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 describe("recordUsage", () => {
   beforeEach(() => {
     const db = getDb();
@@ -202,6 +198,7 @@ describe("recordUsage", () => {
     expect(onEventMessages).toEqual([
       {
         type: "usage_update",
+        conversationId: "conv-usage-1",
         inputTokens: 3_420_218,
         outputTokens: 11_768,
         totalInputTokens: 3_420_218,

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");
@@ -378,52 +142,14 @@ describe("wipeConversation", () => {
     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 +159,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 +191,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 +243,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__/credential-execution-feature-gates.test.ts

@@ -180,7 +180,7 @@ describe("CES flags do not affect unrelated flags", () => {
     expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(true);
   });
 
-  test("enabling all CES flags does not change contacts flag (defaultEnabled: true)", () => {
+  test("enabling all CES flags does not change sounds flag (defaultEnabled: true)", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -188,7 +188,7 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // contacts defaults to true in the registry and should stay true
-    expect(isAssistantFeatureFlagEnabled("contacts", config)).toBe(true);
+    // sounds defaults to true in the registry and should stay true
+    expect(isAssistantFeatureFlagEnabled("sounds", config)).toBe(true);
   });
 });

package/src/__tests__/credential-execution-shell-lockdown.test.ts

@@ -33,8 +33,8 @@ describe("trust class categorization for CES lockdown", () => {
     expect(isUntrustedTrustClass("unknown")).toBe(true);
   });
 
-  test("undefined is not untrusted", () => {
-    expect(isUntrustedTrustClass(undefined)).toBe(false);
+  test("undefined is untrusted", () => {
+    expect(isUntrustedTrustClass(undefined)).toBe(true);
   });
 });
 

package/src/__tests__/credential-security-e2e.test.ts

@@ -66,7 +66,12 @@ mock.module("../security/secure-keys.js", () => {
     setSecureKeyAsync: async (key: string, value: string) =>
       syncSet(key, value),
     deleteSecureKeyAsync: async (key: string) => syncDelete(key),
-    listSecureKeysAsync: async () => ({ accounts: [...storedKeys.keys()], unreachable: false }),
+    listSecureKeysAsync: async () => ({
+      accounts: [...storedKeys.keys()],
+      unreachable: false,
+    }),
+    getProviderKeyAsync: async () => undefined,
+    getMaskedProviderKey: async () => null,
   };
 });