@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/assistant-event-hub-self-exclusion.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Tests for self-echo suppression in `AssistantEventHub`.
+ *
+ * Validates:
+ *   - hub.publish(event, { excludeClientId }) skips the matching client
+ *     subscriber and delivers to every other matching subscriber.
+ *   - Suppression is unconditional: it applies whether the broadcast is
+ *     untargeted, conversation-scoped, or capability-targeted.
+ *   - `broadcastMessage(sync_changed { originClientId })` derives the
+ *     exclusion from the message itself — no caller wiring needed.
+ *   - `broadcastMessage(sync_changed)` without an originClientId fans out
+ *     to every subscriber (the daemon-internal emit path).
+ *   - Process-type subscribers are never excluded by a clientId match.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import {
+  AssistantEventHub,
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+
+function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
+  return {
+    id: "evt_test_sync",
+    conversationId: undefined,
+    emittedAt: "2026-05-03T00:00:00.000Z",
+    message: {
+      type: "sync_changed",
+      tags: ["conversation:abc:messages"],
+      ...(originClientId ? { originClientId } : {}),
+    },
+  };
+}
+
+describe("AssistantEventHub — self-echo suppression (excludeClientId)", () => {
+  test("skips the named client and delivers to every other client", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+    const receivedC: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-c",
+      interfaceId: "macos",
+      capabilities: [],
+      callback: (e) => {
+        receivedC.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+    expect(receivedC).toHaveLength(1);
+  });
+
+  test("delivers to every subscriber when excludeClientId is omitted", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent());
+
+    expect(receivedA).toHaveLength(1);
+    expect(receivedB).toHaveLength(1);
+  });
+
+  test("excludeClientId does not match process-type subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedProcess: AssistantEvent[] = [];
+
+    // A process subscriber sits in the same hub as a client whose id
+    // matches `excludeClientId`. It must never be suppressed because
+    // `excludeClientId` only matches `type: "client"` entries — process
+    // entries have no `clientId` field at all.
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        receivedProcess.push(e);
+      },
+    });
+
+    await hub.publish(makeSyncChangedEvent("client-a"), {
+      excludeClientId: "client-a",
+    });
+
+    expect(receivedProcess).toHaveLength(1);
+  });
+
+  test("excludeClientId composes with conversation-scoped subscribers", async () => {
+    const hub = new AssistantEventHub();
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    hub.subscribe({
+      type: "client",
+      clientId: "client-a",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    hub.subscribe({
+      type: "client",
+      clientId: "client-b",
+      interfaceId: "web",
+      capabilities: [],
+      filter: { conversationId: "sess_x" },
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    // Scoped event for sess_x; both clients filter to sess_x; exclude A.
+    const event: AssistantEvent = {
+      id: "evt_scoped",
+      conversationId: "sess_x",
+      emittedAt: "2026-05-03T00:00:00.000Z",
+      message: {
+        type: "sync_changed",
+        tags: ["conversation:sess_x:messages"],
+        originClientId: "client-a",
+      },
+    };
+
+    await hub.publish(event, { excludeClientId: "client-a" });
+
+    expect(receivedA).toHaveLength(0);
+    expect(receivedB).toHaveLength(1);
+  });
+});
+
+describe("broadcastMessage — derives excludeClientId from sync_changed.originClientId", () => {
+  test("skips the originating client when originClientId is present", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-a",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-b",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        originClientId: "broadcast-a",
+      });
+      // broadcastMessage queues onto a microtask chain — yield until it
+      // drains. Two awaits cover the publish promise + its `.then` chain.
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(0);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("fans out to every client when originClientId is absent", async () => {
+    const receivedA: AssistantEvent[] = [];
+    const receivedB: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-c",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+    const subB = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-d",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedB.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+      expect(receivedB).toHaveLength(1);
+    } finally {
+      subA.dispose();
+      subB.dispose();
+    }
+  });
+
+  test("ignores an empty-string originClientId (treats as absent)", async () => {
+    const receivedA: AssistantEvent[] = [];
+
+    const subA = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "broadcast-e",
+      interfaceId: "web",
+      capabilities: [],
+      callback: (e) => {
+        receivedA.push(e);
+      },
+    });
+
+    try {
+      broadcastMessage({
+        type: "sync_changed",
+        tags: ["resource:test"],
+        // Exercise the length-zero guard. `originClientId?: string` accepts
+        // empty strings at the type level, but production code path can't
+        // produce one — `buildSyncChangedMessage` trims and drops empty
+        // values before calling `broadcastMessage`.
+        originClientId: "",
+      });
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(receivedA).toHaveLength(1);
+    } finally {
+      subA.dispose();
+    }
+  });
+});

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -4,7 +4,7 @@
  * Covers:
  *   - Missing persisted value falls back to code default
  *   - Protected feature-flags.json is the sole override mechanism
- *   - Undeclared keys default to enabled
+ *   - Undeclared keys default to disabled
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -14,10 +14,11 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 const DECLARED_FLAG_ID = "email-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
-const SAFE_STORAGE_LIMITS_FLAG = "safe-storage-limits";
 
-const { isAssistantFeatureFlagEnabled, _setOverridesForTesting } =
+const { isAssistantFeatureFlagEnabled } =
   await import("../config/assistant-feature-flags.js");
+const { setOverridesForTesting } =
+  await import("./feature-flag-test-helpers.js");
 const { skillFlagKey } = await import("../config/skill-state.js");
 
 // ---------------------------------------------------------------------------
@@ -25,11 +26,11 @@ const { skillFlagKey } = await import("../config/skill-state.js");
 // ---------------------------------------------------------------------------
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 // ---------------------------------------------------------------------------
@@ -38,14 +39,14 @@ afterEach(() => {
 
 describe("isAssistantFeatureFlagEnabled", () => {
   test("reads from file-based overrides", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const config = {} as any;
 
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
   });
 
   test("explicit false override in file-based overrides", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = {} as any;
 
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
@@ -63,31 +64,14 @@ describe("isAssistantFeatureFlagEnabled", () => {
     );
   });
 
-  test("safe-storage-limits defaults to disabled", () => {
+  test("unknown flag defaults to false when no persisted override", () => {
     const config = {} as any;
 
-    expect(
-      isAssistantFeatureFlagEnabled(SAFE_STORAGE_LIMITS_FLAG, config),
-    ).toBe(false);
-  });
-
-  test("safe-storage-limits respects explicit override", () => {
-    _setOverridesForTesting({ [SAFE_STORAGE_LIMITS_FLAG]: true });
-    const config = {} as any;
-
-    expect(
-      isAssistantFeatureFlagEnabled(SAFE_STORAGE_LIMITS_FLAG, config),
-    ).toBe(true);
-  });
-
-  test("unknown flag defaults to true when no persisted override", () => {
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("unknown-skill", config)).toBe(false);
   });
 
   test("undeclared flag respects persisted override", () => {
-    _setOverridesForTesting({ "some-undeclared-flag": false });
+    setOverridesForTesting({ "some-undeclared-flag": false });
     const config = {} as any;
 
     expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
@@ -98,7 +82,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
 describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   test("resolves skill flag via canonical path", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = {} as any;
 
     expect(

package/src/__tests__/audit-log-rotation.test.ts

@@ -12,13 +12,13 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { resetDb } from "../memory/db-connection.js";
 import { getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   getRecentInvocations,
   rotateToolInvocations,
 } from "../memory/tool-usage-store.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -57,7 +57,7 @@ const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 
 describe("audit log rotation", () => {
   beforeAll(() => {
-    resetDb();
+    resetDbForTesting();
     initializeDb();
     // Insert a conversations row so FK-enforced ORM inserts succeed
     getSqlite().run(
@@ -69,72 +69,126 @@ describe("audit log rotation", () => {
     clearTable();
   });
 
-  test("returns 0 when retentionDays is 0 (retain forever)", () => {
+  test("returns 0 when retentionDays is 0 (retain forever)", async () => {
     addInvocation(100 * ONE_DAY_MS); // 100 days old
-    const deleted = rotateToolInvocations(0);
+    const deleted = await rotateToolInvocations(0);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("returns 0 when retentionDays is negative", () => {
+  test("returns 0 when retentionDays is negative", async () => {
     addInvocation(100 * ONE_DAY_MS);
-    const deleted = rotateToolInvocations(-5);
+    const deleted = await rotateToolInvocations(-5);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("deletes records older than retentionDays", () => {
+  test("deletes records older than retentionDays", async () => {
     addInvocation(10 * ONE_DAY_MS); // 10 days old — should be deleted with 7-day retention
     addInvocation(3 * ONE_DAY_MS); // 3 days old — should be kept
     addInvocation(1 * ONE_DAY_MS); // 1 day old — should be kept
 
-    const deleted = rotateToolInvocations(7);
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(2);
   });
 
-  test("keeps all records when none exceed retention", () => {
+  test("keeps all records when none exceed retention", async () => {
     addInvocation(1 * ONE_DAY_MS);
     addInvocation(2 * ONE_DAY_MS);
     addInvocation(3 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(3);
   });
 
-  test("deletes all records when all exceed retention", () => {
+  test("deletes all records when all exceed retention", async () => {
     addInvocation(60 * ONE_DAY_MS);
     addInvocation(90 * ONE_DAY_MS);
     addInvocation(120 * ONE_DAY_MS);
 
-    const deleted = rotateToolInvocations(30);
+    const deleted = await rotateToolInvocations(30);
     expect(deleted).toBe(3);
     expect(getRecentInvocations(100).length).toBe(0);
   });
 
-  test("returns 0 when table is empty", () => {
-    const deleted = rotateToolInvocations(7);
+  test("returns 0 when table is empty", async () => {
+    const deleted = await rotateToolInvocations(7);
     expect(deleted).toBe(0);
   });
 
-  test("handles 1-day retention (deletes everything older than 24h)", () => {
+  test("handles 1-day retention (deletes everything older than 24h)", async () => {
     addInvocation(2 * ONE_DAY_MS); // 2 days old — delete
     addInvocation(12 * 60 * 60 * 1000); // 12 hours old — keep
 
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test("works with recordToolInvocation (via ORM)", () => {
+  test("works with recordToolInvocation (via ORM)", async () => {
     // Use raw SQL to insert (avoids db singleton issues in parallel test runs)
     // and verify the rotation/query functions work correctly with it
     addInvocation(0); // just-created record
 
     // This record was just created, so it should not be rotated
-    const deleted = rotateToolInvocations(1);
+    const deleted = await rotateToolInvocations(1);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
+
+  test(
+    "yields to the event loop while the purge is in flight (anti-block)",
+    async () => {
+      // Seed a few thousand rows so the DELETE has measurable
+      // subprocess work behind the scenes.
+      const ROW_COUNT = 2000;
+      const past = 100 * ONE_DAY_MS;
+      const sqlite = getSqlite();
+      sqlite.exec("BEGIN");
+      try {
+        for (let i = 0; i < ROW_COUNT; i++) {
+          addInvocation(past);
+        }
+        sqlite.exec("COMMIT");
+      } catch (err) {
+        sqlite.exec("ROLLBACK");
+        throw err;
+      }
+
+      // Race the purge against a `setImmediate` ping. The ping
+      // resolves on the very next event-loop iteration after it is
+      // scheduled.
+      //
+      // If the purge is async (subprocess), `rotateToolInvocations`
+      // returns a pending Promise immediately; the ping wins the race
+      // while the subprocess is still running.
+      //
+      // If the purge is ever regressed back to a synchronous DELETE,
+      // `rotateToolInvocations` blocks the main thread for the full
+      // DELETE duration. `setImmediate` cannot fire until the main
+      // thread releases, so the purge's already-resolved Promise
+      // beats the ping through the microtask queue and "purge" wins.
+      //
+      // The signal is deterministic regardless of how fast the
+      // subprocess is or how busy the event loop is.
+      const ping = new Promise<"ping">((resolve) =>
+        setImmediate(() => resolve("ping")),
+      );
+      const purgePromise = rotateToolInvocations(7);
+      const winner = await Promise.race([
+        ping,
+        purgePromise.then(() => "purge" as const),
+      ]);
+
+      expect(winner).toBe("ping");
+
+      // Drain the purge so the log + subprocess cleanup complete
+      // before the test exits.
+      const deleted = await purgePromise;
+      expect(deleted).toBe(ROW_COUNT);
+    },
+    60_000,
+  );
 });

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -130,7 +130,6 @@ mock.module("../runtime/services/analyze-conversation.js", () => ({
 
 // ── Real imports ──────────────────────────────────────────────────
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import { conversationAnalyzeJob } from "../memory/conversation-analyze-job.js";
 import { createConversation } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
@@ -138,6 +137,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { indexMessageNow } from "../memory/indexer.js";
 import type { MemoryJob } from "../memory/jobs-store.js";
 import { conversations, memoryJobs, messages } from "../memory/schema.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Helpers ───────────────────────────────────────────────────────
 
@@ -279,14 +279,14 @@ beforeEach(() => {
   resetTables();
   analyzeCalls.length = 0;
   // Clear any stale feature-flag overrides between tests.
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 // ─────────────────────────────────────────────────────────────────
 
 describe("auto-analysis end-to-end trigger path", () => {
   test("flag on, batch threshold reached → conversation_analyze enqueued, handler runs, analysis conversation created", async () => {
-    _setOverridesForTesting({ "auto-analyze": true });
+    setOverridesForTesting({ "auto-analyze": true });
 
     const source = createConversation("source-conv");
 
@@ -329,7 +329,7 @@ describe("auto-analysis end-to-end trigger path", () => {
   });
 
   test("flag off → no conversation_analyze job is ever enqueued", async () => {
-    _setOverridesForTesting({ "auto-analyze": false });
+    setOverridesForTesting({ "auto-analyze": false });
 
     const source = createConversation("source-conv-flag-off");
     await indexMessages(source.id, 3);
@@ -343,7 +343,7 @@ describe("auto-analysis end-to-end trigger path", () => {
   });
 
   test("recursion guard: indexing into an auto-analysis conversation does not enqueue conversation_analyze or graph_extract", async () => {
-    _setOverridesForTesting({ "auto-analyze": true });
+    setOverridesForTesting({ "auto-analyze": true });
 
     // Set up an auto-analysis conversation directly. This is the
     // scenario we need to protect against — the analysis agent writes
@@ -392,7 +392,7 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
   const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
 
   beforeEach(() => {
-    _setOverridesForTesting({ "auto-analyze": true });
+    setOverridesForTesting({ "auto-analyze": true });
     // memory.v2.enabled gates v1 graph_extract enqueue; force off so
     // these cadence tests can observe the v1 path.
     TEST_CONFIG.memory.v2.enabled = false;

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { createMockLoggerModule } from "./helpers/mock-logger.js";
+
 // Default the warm-pool gate to OPEN — these tests probe background-job
 // disk-pressure behavior, not the pre-first-message guard.
 mock.module("../runtime/pre-first-message-gate.js", () => ({
@@ -7,14 +9,7 @@ mock.module("../runtime/pre-first-message-gate.js", () => ({
   _resetPreFirstMessageGateCacheForTests: () => {},
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    debug: () => {},
-    warn: () => {},
-    error: () => {},
-  }),
-}));
+mock.module("../util/logger.js", () => createMockLoggerModule());
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
@@ -108,7 +103,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
   batchSetDisplayOrders: mock(() => {}),
-  clearStrippedInjectionMetadataForConversation: mock(() => {}),
   createConversation: (opts: { conversationType: string }) => {
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };
@@ -116,7 +110,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   countConversationsByScheduleJobId: mock(() => 0),
   countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
-  clearAll: mock(() => ({ conversations: 0, messages: 0 })),
+  clearAll: mock(async () => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
@@ -156,8 +150,10 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: mock(() => {}),
   updateConversationUsage: mock(() => {}),
   setLastNotifiedInferenceProfile: mock(() => {}),
-  setConversationCleanedAt: mock(() => {}),
+  setConversationHistoryStrippedAt: mock(() => {}),
   wipeConversation: mock(() => ({ memoryIds: [] })),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  extractImageSourcePaths: () => undefined,
 }));
 
 mock.module("../memory/conversation-title-service.js", () => ({
@@ -182,6 +178,7 @@ mock.module("../memory/jobs-store.js", () => ({
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
   hasActiveJobOfType: mock(() => false),
+  isMemoryEnabled: () => true,
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),