@vellumai/assistant 0.5.16 → 0.6.0

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

@@ -70,6 +70,8 @@ mock.module("../security/secure-keys.js", () => {
       accounts: [...storedKeys.keys()],
       unreachable: false,
     }),
+    getProviderKeyAsync: async () => undefined,
+    getMaskedProviderKey: async () => null,
   };
 });
 

package/src/__tests__/followup-tools.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: () =>
@@ -16,7 +16,7 @@ mock.module("../config/loader.js", () => ({
 
 import type { Database } from "bun:sqlite";
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { executeFollowupCreate } from "../tools/followups/followup_create.js";
 import { executeFollowupList } from "../tools/followups/followup_list.js";
 import { executeFollowupResolve } from "../tools/followups/followup_resolve.js";
@@ -24,10 +24,6 @@ import type { ToolContext } from "../tools/types.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;
 }