@vellumai/assistant 0.7.3 → 0.8.1

package/src/memory/__tests__/bookmark-schema.test.ts

@@ -0,0 +1,181 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../db-connection.js";
+import { migrateMessageBookmarks } from "../migrations/242-message-bookmarks.js";
+import * as schema from "../schema.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  pk: number;
+}
+
+interface IndexInfoRow {
+  name: string;
+  unique: number;
+}
+
+interface CountRow {
+  n: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+/**
+ * Recreate just enough of the conversations + messages tables to exercise
+ * CASCADE behavior. We only need the columns the FKs reference (id) plus
+ * NOT NULL columns required to insert a row.
+ */
+function bootstrapMessageTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function seedConversationAndMessage(
+  raw: Database,
+  conversationId: string,
+  messageId: string,
+): void {
+  const now = Date.now();
+  raw
+    .query(
+      `INSERT INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(conversationId, "Example", now, now);
+  raw
+    .query(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(messageId, conversationId, "user", "hello", now);
+}
+
+function insertBookmark(
+  raw: Database,
+  id: string,
+  messageId: string,
+  conversationId: string,
+): void {
+  raw
+    .query(
+      `INSERT INTO message_bookmarks (id, message_id, conversation_id, created_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(id, messageId, conversationId, Date.now());
+}
+
+function countBookmarks(raw: Database): number {
+  const row = raw
+    .query(`SELECT COUNT(*) AS n FROM message_bookmarks`)
+    .get() as CountRow | null;
+  return row?.n ?? 0;
+}
+
+describe("message_bookmarks schema migration", () => {
+  test("creates table with expected columns and indexes", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapMessageTables(raw);
+
+    migrateMessageBookmarks(db);
+
+    const columns = raw
+      .query(`PRAGMA table_info(message_bookmarks)`)
+      .all() as ColumnRow[];
+    const byName = new Map(columns.map((c) => [c.name, c]));
+    expect(byName.get("id")?.pk).toBe(1);
+    expect(byName.get("id")?.type).toBe("TEXT");
+    expect(byName.get("message_id")?.notnull).toBe(1);
+    expect(byName.get("conversation_id")?.notnull).toBe(1);
+    expect(byName.get("created_at")?.notnull).toBe(1);
+    expect(byName.get("created_at")?.type).toBe("INTEGER");
+
+    const indexes = raw
+      .query(`PRAGMA index_list(message_bookmarks)`)
+      .all() as IndexInfoRow[];
+    const indexByName = new Map(indexes.map((i) => [i.name, i]));
+    const uniqIndex = indexByName.get("message_bookmarks_message_id_uniq");
+    expect(uniqIndex).toBeDefined();
+    expect(uniqIndex?.unique).toBe(1);
+    expect(indexByName.get("message_bookmarks_created_at_idx")).toBeDefined();
+  });
+
+  test("CASCADE removes bookmark when parent message is deleted", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapMessageTables(raw);
+    migrateMessageBookmarks(db);
+
+    seedConversationAndMessage(raw, "conv-1", "msg-1");
+    insertBookmark(raw, "bm-1", "msg-1", "conv-1");
+    expect(countBookmarks(raw)).toBe(1);
+
+    raw.query(`DELETE FROM messages WHERE id = ?`).run("msg-1");
+    expect(countBookmarks(raw)).toBe(0);
+  });
+
+  test("CASCADE removes bookmark when parent conversation is deleted", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapMessageTables(raw);
+    migrateMessageBookmarks(db);
+
+    seedConversationAndMessage(raw, "conv-2", "msg-2");
+    insertBookmark(raw, "bm-2", "msg-2", "conv-2");
+    expect(countBookmarks(raw)).toBe(1);
+
+    raw.query(`DELETE FROM conversations WHERE id = ?`).run("conv-2");
+    // Deleting the conversation cascades to messages, which cascades to
+    // bookmarks. Either FK alone would suffice; both fire here.
+    expect(countBookmarks(raw)).toBe(0);
+  });
+
+  test("unique constraint on message_id rejects a second bookmark", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapMessageTables(raw);
+    migrateMessageBookmarks(db);
+
+    seedConversationAndMessage(raw, "conv-3", "msg-3");
+    insertBookmark(raw, "bm-3a", "msg-3", "conv-3");
+
+    expect(() => insertBookmark(raw, "bm-3b", "msg-3", "conv-3")).toThrow();
+    expect(countBookmarks(raw)).toBe(1);
+  });
+});

package/src/memory/__tests__/conversation-types.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+
+import { isBackgroundConversationType } from "../conversation-types.js";
+
+describe("isBackgroundConversationType", () => {
+  test("returns true for background", () => {
+    expect(isBackgroundConversationType("background")).toBe(true);
+  });
+
+  test("returns true for scheduled", () => {
+    expect(isBackgroundConversationType("scheduled")).toBe(true);
+  });
+
+  test("returns false for standard", () => {
+    expect(isBackgroundConversationType("standard")).toBe(false);
+  });
+
+  test("returns false for null", () => {
+    expect(isBackgroundConversationType(null)).toBe(false);
+  });
+
+  test("returns false for undefined", () => {
+    expect(isBackgroundConversationType(undefined)).toBe(false);
+  });
+
+  test("returns false for empty string", () => {
+    expect(isBackgroundConversationType("")).toBe(false);
+  });
+
+  test.each(["chat", "foo", "BACKGROUND", "Scheduled", " background "])(
+    "returns false for unknown string %p",
+    (value) => {
+      expect(isBackgroundConversationType(value)).toBe(false);
+    },
+  );
+});

package/src/memory/__tests__/find-most-recent-retrospective-for.test.ts

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  createConversation,
+  findMostRecentRetrospectiveFor,
+} from "../conversation-crud.js";
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { MEMORY_RETROSPECTIVE_SOURCE } from "../memory-retrospective-constants.js";
+import { conversations } from "../schema.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+function setForkParent(conversationId: string, parentId: string): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({ forkParentConversationId: parentId })
+    .where(eq(conversations.id, conversationId))
+    .run();
+}
+
+function setCreatedAt(conversationId: string, createdAt: number): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({ createdAt })
+    .where(eq(conversations.id, conversationId))
+    .run();
+}
+
+function createRetro(parentId: string, createdAt: number): { id: string } {
+  const retro = createConversation({
+    title: "retro",
+    source: MEMORY_RETROSPECTIVE_SOURCE,
+  });
+  setForkParent(retro.id, parentId);
+  setCreatedAt(retro.id, createdAt);
+  return { id: retro.id };
+}
+
+describe("findMostRecentRetrospectiveFor", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns null when no retrospective exists anywhere in the fork chain", () => {
+    const conv = createConversation("conv");
+    expect(findMostRecentRetrospectiveFor(conv.id)).toBeNull();
+  });
+
+  test("returns a direct retrospective rooted at the conversation", () => {
+    const conv = createConversation("conv");
+    const retro = createRetro(conv.id, 1_000);
+
+    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({ id: retro.id });
+  });
+
+  test("returns the most recently created retrospective when multiple exist at the same level", () => {
+    const conv = createConversation("conv");
+    createRetro(conv.id, 1_000);
+    const newer = createRetro(conv.id, 2_000);
+    createRetro(conv.id, 500);
+
+    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({ id: newer.id });
+  });
+
+  test("walks up the fork chain when the current conversation has no retros", () => {
+    const parent = createConversation("parent");
+    const parentRetro = createRetro(parent.id, 1_000);
+
+    const fork = createConversation("fork");
+    setForkParent(fork.id, parent.id);
+
+    expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
+      id: parentRetro.id,
+    });
+  });
+
+  test("prefers the fork's own retros over the parent's", () => {
+    const parent = createConversation("parent");
+    createRetro(parent.id, 5_000);
+
+    const fork = createConversation("fork");
+    setForkParent(fork.id, parent.id);
+    const forkRetro = createRetro(fork.id, 1_000);
+
+    expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
+      id: forkRetro.id,
+    });
+  });
+
+  test("walks multiple levels (fork-of-fork) until it finds a retro", () => {
+    const grandparent = createConversation("grandparent");
+    const grandparentRetro = createRetro(grandparent.id, 1_000);
+
+    const parent = createConversation("parent");
+    setForkParent(parent.id, grandparent.id);
+
+    const fork = createConversation("fork");
+    setForkParent(fork.id, parent.id);
+
+    expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
+      id: grandparentRetro.id,
+    });
+  });
+
+  test("returns null when the entire fork chain has no retros", () => {
+    const grandparent = createConversation("grandparent");
+    const parent = createConversation("parent");
+    setForkParent(parent.id, grandparent.id);
+    const fork = createConversation("fork");
+    setForkParent(fork.id, parent.id);
+
+    expect(findMostRecentRetrospectiveFor(fork.id)).toBeNull();
+  });
+});

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -1,19 +1,16 @@
 /**
  * Tests for v1/v2 mutual exclusion in `maybeEnqueueGraphMaintenanceJobs`.
  *
- * The schedule is now mutually exclusive: when both the `memory-v2-enabled`
- * flag and `memory.v2.enabled` config are on, only `memory_v2_consolidate`
- * is scheduled; otherwise the four v1 entries (decay, consolidate,
- * pattern_scan, narrative) fire and the v2 entry does not.
+ * The schedule is mutually exclusive: when `memory.v2.enabled` is true,
+ * only `memory_v2_consolidate` is scheduled; otherwise the four v1
+ * entries (decay, consolidate, pattern_scan, narrative) fire and the v2
+ * entry does not.
  *
  * Coverage:
- *   - Flag off → only v1 entries fire (no `memory_v2_consolidate`).
- *   - Flag on + config off → only v1 entries fire.
- *   - Flag on + config on, no prior checkpoint → only the v2 entry fires.
- *   - Flag on + config on, recent checkpoint → no v2 row (interval not
- *     yet elapsed).
- *   - Flag on + config on, stale checkpoint → v2 row enqueued, checkpoint
- *     refreshed.
+ *   - Config off → only v1 entries fire (no `memory_v2_consolidate`).
+ *   - Config on, no prior checkpoint → only the v2 entry fires.
+ *   - Config on, recent checkpoint → no v2 row (interval not yet elapsed).
+ *   - Config on, stale checkpoint → v2 row enqueued, checkpoint refreshed.
  *
  * The sweep job is intentionally NOT scheduled here: it is wired into the
  * `graph_extract` debounce in `indexer.ts`. Those triggers are covered by
@@ -27,7 +24,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -69,8 +65,6 @@ const { getDb } = await import("../db-connection.js");
 const { initializeDb } = await import("../db-init.js");
 const { resetTestTables } = await import("../raw-query.js");
 const { memoryJobs } = await import("../schema.js");
-const { _setOverridesForTesting } =
-  await import("../../config/assistant-feature-flags.js");
 const { applyNestedDefaults } = await import("../../config/loader.js");
 const { setMemoryCheckpoint, deleteMemoryCheckpoint } =
   await import("../checkpoints.js");
@@ -111,26 +105,10 @@ beforeEach(() => {
   resetTestTables("memory_jobs", "memory_checkpoints");
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 // ---------------------------------------------------------------------------
 
 describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
-  test("does not enqueue consolidate when memory-v2-enabled flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
-
-    // Force the interval to look elapsed. If the gate failed open, this
-    // would be enough to enqueue a job.
-    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
-
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
-  });
-
   test("does not enqueue consolidate when config.memory.v2.enabled is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
@@ -138,8 +116,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 
-  test("enqueues consolidate when both gates are on and no checkpoint exists", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("enqueues consolidate when v2 is on and no checkpoint exists", () => {
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
@@ -153,7 +130,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("does not enqueue consolidate before the interval has elapsed", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -166,7 +142,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("enqueues consolidate again once the interval elapses", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -182,7 +157,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("respects a custom consolidation_interval_hours value", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 6 });
 
     const now = Date.now();
@@ -206,7 +180,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("v1 maintenance entries are suppressed when v2 is active", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     // No checkpoints set — every entry would be due if it were scheduled.
@@ -225,27 +198,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("flag-off path fires v1 entries and does not enqueue v2", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
-
-    deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
-    deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
-
-    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
-
-    expect(countPendingJobs("graph_decay")).toBe(1);
-    expect(countPendingJobs("graph_consolidate")).toBe(1);
-    expect(countPendingJobs("graph_pattern_scan")).toBe(1);
-    expect(countPendingJobs("graph_narrative_refine")).toBe(1);
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
-  });
-
-  test("config-gate-off path fires v1 entries and does not enqueue v2", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("v2-off path fires v1 entries and does not enqueue v2", () => {
     const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock state — reset between tests.
+// ---------------------------------------------------------------------------
+
+let flagEnabled = true;
+let sourceTag: string | null = null;
+let getConfigThrows = false;
+const upsertCalls: Array<{
+  payload: { conversationId: string };
+  runAfter: number;
+}> = [];
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => {
+    if (getConfigThrows) throw new Error("boom");
+    return {};
+  },
+}));
+
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
+    flagEnabled,
+}));
+
+mock.module("../conversation-crud.js", () => ({
+  getConversationSource: (_id: string) => sourceTag,
+}));
+
+mock.module("../jobs-store.js", () => ({
+  upsertMemoryRetrospectiveJob: (
+    payload: { conversationId: string },
+    runAfter: number,
+  ) => {
+    upsertCalls.push({ payload, runAfter });
+  },
+}));
+
+mock.module("../../runtime/actor-trust-resolver.js", () => ({
+  isUntrustedTrustClass: (trustClass: string | undefined) =>
+    trustClass === "trusted_contact" ||
+    trustClass === "unknown" ||
+    trustClass === undefined,
+}));
+
+import {
+  enqueueMemoryRetrospectiveIfEnabled,
+  enqueueMemoryRetrospectiveOnCompaction,
+  isMemoryRetrospectiveConversation,
+} from "../memory-retrospective-enqueue.js";
+
+describe("enqueueMemoryRetrospectiveIfEnabled", () => {
+  beforeEach(() => {
+    flagEnabled = true;
+    sourceTag = null;
+    getConfigThrows = false;
+    upsertCalls.length = 0;
+  });
+
+  test("flag off — no upsert for any trigger", () => {
+    flagEnabled = false;
+    for (const trigger of [
+      "interval",
+      "message_count",
+      "compaction",
+      "lifecycle",
+    ] as const) {
+      enqueueMemoryRetrospectiveIfEnabled({ conversationId: "c1", trigger });
+    }
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("flag on, standard source — interval trigger enqueues with runAfter ≈ now", () => {
+    const before = Date.now();
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+    const after = Date.now();
+
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0]!;
+    expect(call.payload).toEqual({ conversationId: "c1" });
+    expect(call.runAfter).toBeGreaterThanOrEqual(before);
+    expect(call.runAfter).toBeLessThanOrEqual(after);
+  });
+
+  test("compaction trigger applies the small debounce", () => {
+    const before = Date.now();
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "compaction",
+    });
+
+    expect(upsertCalls).toHaveLength(1);
+    const call = upsertCalls[0]!;
+    expect(call.runAfter).toBeGreaterThan(before + 100);
+  });
+
+  test("recursion guard — source = 'memory-retrospective' skips enqueue", () => {
+    sourceTag = "memory-retrospective";
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("getConfig throws — no enqueue, no propagation", () => {
+    getConfigThrows = true;
+    expect(() =>
+      enqueueMemoryRetrospectiveIfEnabled({
+        conversationId: "c1",
+        trigger: "interval",
+      }),
+    ).not.toThrow();
+    expect(upsertCalls).toHaveLength(0);
+  });
+});
+
+describe("isMemoryRetrospectiveConversation", () => {
+  beforeEach(() => {
+    sourceTag = null;
+  });
+
+  test("returns true only for the matching source tag", () => {
+    sourceTag = "memory-retrospective";
+    expect(isMemoryRetrospectiveConversation("c1")).toBe(true);
+  });
+
+  test("returns false for other source tags", () => {
+    sourceTag = "auto-analysis";
+    expect(isMemoryRetrospectiveConversation("c1")).toBe(false);
+  });
+
+  test("returns false when source is null", () => {
+    sourceTag = null;
+    expect(isMemoryRetrospectiveConversation("c1")).toBe(false);
+  });
+});
+
+describe("enqueueMemoryRetrospectiveOnCompaction", () => {
+  beforeEach(() => {
+    flagEnabled = true;
+    sourceTag = null;
+    getConfigThrows = false;
+    upsertCalls.length = 0;
+  });
+
+  test("untrusted trust class — no enqueue", () => {
+    enqueueMemoryRetrospectiveOnCompaction("c1", "unknown");
+    enqueueMemoryRetrospectiveOnCompaction("c1", "trusted_contact");
+    enqueueMemoryRetrospectiveOnCompaction("c1", undefined);
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("guardian trust + flag on — enqueues with compaction debounce", () => {
+    const before = Date.now();
+    enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
+    expect(upsertCalls).toHaveLength(1);
+    expect(upsertCalls[0]!.runAfter).toBeGreaterThan(before + 100);
+  });
+
+  test("guardian trust + flag off — no enqueue", () => {
+    flagEnabled = false;
+    enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
+    expect(upsertCalls).toHaveLength(0);
+  });
+});