@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/annotate-risk-options.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for `annotatePersistedAssistantMessage` persisting the 3 risk-option
+ * arrays alongside the existing `_risk*` scalars.
+ *
+ * Phase B of the conflation track. Without these annotations, the Rule Editor
+ * Modal's chip ladder loses its scope/allowlist/directory options on chat-
+ * history reload and falls back to the synthesized `*` allowlist.
+ *
+ * The test exercises the full populate → annotate → persist round-trip:
+ *   handleToolResult(event with 3 arrays)
+ *     → state.toolRiskOutcomes captures them
+ *     → annotatePersistedAssistantMessage writes _risk*Options onto the row
+ *     → updateMessageContent receives the JSON-serialized output
+ *
+ * Read-side coverage (renderHistoryContent in handlers/shared.ts) lives in
+ * server-history-render.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+let mockedRowContent = "";
+const updates: Array<{ id: string; content: string }> = [];
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: (id: string) =>
+    mockedRowContent ? { id, content: mockedRowContent } : null,
+  updateMessageContent: (id: string, content: string) => {
+    updates.push({ id, content });
+  },
+  provenanceFromTrustContext: () => ({}),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleToolResult,
+} from "../daemon/conversation-agent-loop-handlers.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: "test-conv",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "test-req",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as unknown as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    } as unknown as EventHandlerDeps["turnInterfaceContext"],
+  };
+}
+
+function setupState(toolUseId: string): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "msg-1";
+  state.toolUseIdToName.set(toolUseId, "bash");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: Date.now() });
+  state.currentTurnToolUseIds.push(toolUseId);
+  return state;
+}
+
+function findPersistedToolUse(
+  rawContent: string,
+  toolUseId: string,
+): Record<string, unknown> {
+  const parsed = JSON.parse(rawContent) as Array<Record<string, unknown>>;
+  const block = parsed.find(
+    (b) => b.type === "tool_use" && b.id === toolUseId,
+  );
+  if (!block) throw new Error(`tool_use block ${toolUseId} not found`);
+  return block;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("annotatePersistedAssistantMessage — risk-option arrays (Phase B)", () => {
+  beforeEach(() => {
+    updates.length = 0;
+    mockedRowContent = "";
+  });
+
+  test("persists all 3 risk-option arrays from the live tool_result event", () => {
+    const toolUseId = "tu_persist_full";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "bash",
+        input: { command: "rm -rf /tmp" },
+      },
+    ]);
+
+    const scopeOptions = [
+      { pattern: "exact", label: "exact: rm -rf /tmp" },
+      { pattern: "by-program", label: "All rm" },
+    ];
+    const allowlistOptions = [
+      { label: "exact", description: "exact match", pattern: "rm -rf /tmp" },
+      { label: "All rm", description: "All rm commands", pattern: "rm *" },
+    ];
+    const directoryScopeOptions = [
+      { scope: "/Users/me/code", label: "in code/" },
+      { scope: "everywhere", label: "Everywhere" },
+    ];
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "high",
+      riskReason: "Modifies state",
+      matchedTrustRuleId: "rule_42",
+      riskScopeOptions: scopeOptions,
+      riskAllowlistOptions: allowlistOptions,
+      riskDirectoryScopeOptions: directoryScopeOptions,
+      approvalMode: "prompted",
+      approvalReason: "user_approved",
+      riskThreshold: "relaxed",
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    // Existing scalars still flow through.
+    expect(block._riskLevel).toBe("high");
+    expect(block._riskReason).toBe("Modifies state");
+    expect(block._matchedTrustRuleId).toBe("rule_42");
+    expect(block._approvalMode).toBe("prompted");
+    expect(block._approvalReason).toBe("user_approved");
+    expect(block._riskThreshold).toBe("relaxed");
+    // New: 3 risk-option arrays persisted verbatim.
+    expect(block._riskScopeOptions).toEqual(scopeOptions);
+    expect(block._riskAllowlistOptions).toEqual(allowlistOptions);
+    expect(block._riskDirectoryScopeOptions).toEqual(directoryScopeOptions);
+  });
+
+  test("omits empty arrays from the persisted block (saves DB space)", () => {
+    const toolUseId = "tu_persist_empty";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "bash",
+        input: { command: "ls" },
+      },
+    ]);
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "low",
+      riskScopeOptions: [],
+      riskAllowlistOptions: [],
+      riskDirectoryScopeOptions: [],
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("low");
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskAllowlistOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+
+  test("omits absent (undefined) arrays from the persisted block", () => {
+    // Mirrors classic bash/file tools that don't always emit all 3 arrays —
+    // e.g. recall, file_read with riskLevel=low and no allowlist coverage.
+    const toolUseId = "tu_persist_absent";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "recall",
+        input: { query: "anything" },
+      },
+    ]);
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "low",
+      // No risk-option arrays passed at all.
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("low");
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskAllowlistOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+
+  test("partial coverage — only allowlist options present (e.g. tools with classifier but no scope ladder)", () => {
+    const toolUseId = "tu_partial";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "file_write",
+        input: { path: "/tmp/foo.txt" },
+      },
+    ]);
+
+    const allowlistOptions = [
+      { label: "exact", description: "exact match", pattern: "/tmp/foo.txt" },
+    ];
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "medium",
+      riskAllowlistOptions: allowlistOptions,
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("medium");
+    expect(block._riskAllowlistOptions).toEqual(allowlistOptions);
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+});

package/src/__tests__/app-control-flow.test.ts

@@ -13,8 +13,9 @@
  * differs in two notable ways:
  *  1. Result payloads carry `pngBase64` (not screenshots-as-strings) and
  *     surface as image content blocks with `media_type: "image/png"`.
- *  2. A module-level singleton lock guards `app_control_start` — only one
- *     conversation may hold an active session at a time.
+ *  2. A module-level session lock binds `(conversationId, app)` — only
+ *     one conversation may hold an active session at a time, and non-start
+ *     tools must target the same `app` the user approved at start time.
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -87,8 +88,9 @@ mock.module("../runtime/pending-interactions.js", () => ({
 
 const {
   HostAppControlProxy,
-  _getActiveAppControlConversationId,
-  _resetActiveAppControlConversationId,
+  _getActiveAppControlSession,
+  _resetActiveAppControlSession,
+  _setActiveAppControlSession,
 } = await import("../daemon/host-app-control-proxy.js");
 const { ROUTES } = await import("../runtime/routes/host-app-control-routes.js");
 const { surfaceProxyResolver } =
@@ -176,11 +178,11 @@ describe("app-control end-to-end flow", () => {
     pending.clear();
     clearConversations();
     mockHasClient = true;
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
   });
 
   afterEach(() => {
-    _resetActiveAppControlConversationId();
+    _resetActiveAppControlSession();
     clearConversations();
   });
 
@@ -238,8 +240,10 @@ describe("app-control end-to-end flow", () => {
       },
     });
 
-    // Singleton lock is held by this conversation now.
-    expect(_getActiveAppControlConversationId()).toBe(conversationId);
+    // Session lock is held by this conversation now, bound to the started app.
+    const session = _getActiveAppControlSession();
+    expect(session?.conversationId).toBe(conversationId);
+    expect(session?.app).toBe("com.example.app");
 
     proxy.dispose();
   });
@@ -253,6 +257,12 @@ describe("app-control end-to-end flow", () => {
     const proxy = new HostAppControlProxy(conversationId);
     const ctx = buildContext(proxy, conversationId);
     registerConversation(conversationId, proxy);
+    // Prime a session so observe passes the auth gate. This test exercises
+    // the result-formatting path, not the start flow.
+    _setActiveAppControlSession({
+      conversationId,
+      app: "com.example.app",
+    });
 
     const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
       tool: "observe",
@@ -306,7 +316,7 @@ describe("app-control end-to-end flow", () => {
     });
     await postResult({ state: "running", pngBase64: TINY_PNG_B64 });
     await startPromise;
-    expect(_getActiveAppControlConversationId()).toBe(conversationId);
+    expect(_getActiveAppControlSession()?.conversationId).toBe(conversationId);
 
     // Wrap dispose to verify it was called by the resolver.
     let disposeCalls = 0;
@@ -328,7 +338,7 @@ describe("app-control end-to-end flow", () => {
     expect(sentMessages).toHaveLength(0);
     expect(disposeCalls).toBe(1);
     // Lock released.
-    expect(_getActiveAppControlConversationId()).toBeUndefined();
+    expect(_getActiveAppControlSession()).toBeUndefined();
   });
 
   // -------------------------------------------------------------------------
@@ -347,7 +357,7 @@ describe("app-control end-to-end flow", () => {
     await postResult({ state: "running", pngBase64: TINY_PNG_B64 });
     const resultA = await startA;
     expect(resultA.isError).toBe(false);
-    expect(_getActiveAppControlConversationId()).toBe("conv-a");
+    expect(_getActiveAppControlSession()?.conversationId).toBe("conv-a");
 
     // Second conversation tries to start while conv-a holds the lock.
     sentMessages.length = 0;

package/src/__tests__/approval-cascade.test.ts

@@ -291,21 +291,13 @@ function seedPendingConfirmation(
   conversation: Conversation,
   requestId: string,
 ): void {
+  // Access private ownedIds so denyAllPending/dispose can find this request.
+  // promptResolve/promptReject callbacks are stored in pendingInteractions via
+  // registerPendingInteraction, which is called separately in each test.
   const prompter = conversation["prompter"] as unknown as {
-    pending: Map<
-      string,
-      {
-        resolve: (...args: unknown[]) => void;
-        reject: (...args: unknown[]) => void;
-        timer: ReturnType<typeof setTimeout>;
-      }
-    >;
+    ownedIds: Set<string>;
   };
-  prompter.pending.set(requestId, {
-    resolve: () => {},
-    reject: () => {},
-    timer: setTimeout(() => {}, 60_000),
-  });
+  prompter.ownedIds.add(requestId);
 }
 
 /**
@@ -439,12 +431,12 @@ describe("approval cascading", () => {
       makeConfirmationDetails(["bash:echo stale"]),
     );
 
-    // Remove req-stale from the prompter's pending map (simulating it was
+    // Remove req-stale from the prompter's ownedIds (simulating it was
     // already resolved by another path before cascade reaches it)
     const prompter = conversationObj["prompter"] as unknown as {
-      pending: Map<string, unknown>;
+      ownedIds: Set<string>;
     };
-    prompter.pending.delete("req-stale");
+    prompter.ownedIds.delete("req-stale");
 
     // This should not throw — cascade should skip req-stale gracefully
     expect(() => {

package/src/__tests__/approval-routes-http.test.ts

@@ -192,6 +192,8 @@ function makeIdleSession(opts?: {
       processing = false;
     },
     handleConfirmationResponse: (requestId: string, decision: string) => {
+      // Simulate PermissionPrompter.resolveConfirmation(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onConfirmation?.(requestId, decision);
     },
     handleSecretResponse: (
@@ -199,6 +201,8 @@ function makeIdleSession(opts?: {
       value?: string,
       delivery?: string,
     ) => {
+      // Simulate SecretPrompter.resolveSecret(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onSecret?.(requestId, value, delivery);
     },
   } as unknown as Conversation;
@@ -285,6 +289,8 @@ function makeConfirmationEmittingSession(opts?: {
       await new Promise<void>(() => {});
     },
     handleConfirmationResponse: (requestId: string, decision: string) => {
+      // Simulate PermissionPrompter.resolveConfirmation(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onConfirmation?.(requestId, decision);
     },
     handleSecretResponse: () => {},

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

@@ -356,6 +356,54 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
   });
 });
 
+// ── ClientEntry actorPrincipalId capture ────────────────────────────────────
+
+describe("AssistantEventHub — actorPrincipalId on ClientEntry", () => {
+  test("stores actorPrincipalId provided at subscribe time", () => {
+    const hub = new AssistantEventHub();
+
+    hub.subscribe({
+      type: "client" as const,
+      clientId: "client-with-principal",
+      interfaceId: "macos",
+      capabilities: ["host_bash"],
+      actorPrincipalId: "user-A",
+      callback: () => {},
+    });
+
+    expect(hub.getClientById("client-with-principal")?.actorPrincipalId).toBe(
+      "user-A",
+    );
+    expect(hub.getActorPrincipalIdForClient("client-with-principal")).toBe(
+      "user-A",
+    );
+  });
+
+  test("actorPrincipalId is undefined when omitted at subscribe time", () => {
+    const hub = new AssistantEventHub();
+
+    hub.subscribe({
+      type: "client" as const,
+      clientId: "client-no-principal",
+      interfaceId: "macos",
+      capabilities: ["host_bash"],
+      callback: () => {},
+    });
+
+    expect(
+      hub.getClientById("client-no-principal")?.actorPrincipalId,
+    ).toBeUndefined();
+    expect(
+      hub.getActorPrincipalIdForClient("client-no-principal"),
+    ).toBeUndefined();
+  });
+
+  test("getActorPrincipalIdForClient returns undefined for unknown clientId", () => {
+    const hub = new AssistantEventHub();
+    expect(hub.getActorPrincipalIdForClient("does-not-exist")).toBeUndefined();
+  });
+});
+
 // ── capabilityForMessageType — host-prefix routing ───────────────────────────
 
 describe("capabilityForMessageType — host-prefix routing", () => {

package/src/__tests__/assistant-event.test.ts

@@ -4,7 +4,6 @@ import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   formatSseFrame,
   formatSseHeartbeat,
-  formatSseHeartbeatWithData,
 } from "../runtime/assistant-event.js";
 
 // ── Type / shape tests ────────────────────────────────────────────────────────
@@ -126,12 +125,3 @@ describe("formatSseHeartbeat", () => {
     expect(formatSseHeartbeat().startsWith(":")).toBe(true);
   });
 });
-
-describe("formatSseHeartbeatWithData", () => {
-  test("includes both a comment and a data-bearing event", () => {
-    const hb = formatSseHeartbeatWithData();
-    expect(hb).toContain(": heartbeat\n\n");
-    expect(hb).toContain("event: assistant_event\n");
-    expect(hb).toContain('data: {"type":"heartbeat"}\n');
-  });
-});

package/src/__tests__/assistant-events-sse-hardening.test.ts

@@ -261,8 +261,7 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     const text = new TextDecoder().decode(value);
-    expect(text).toContain(": heartbeat");
-    expect(text).toContain('{"type":"heartbeat"}');
+    expect(text).toBe(": heartbeat\n\n");
   });
 
   test("emits multiple heartbeats over time", async () => {
@@ -298,11 +297,7 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     expect(chunks.length).toBeGreaterThan(0);
-    expect(
-      chunks.every(
-        (c) => c.includes(": heartbeat") && c.includes('{"type":"heartbeat"}'),
-      ),
-    ).toBe(true);
+    expect(chunks.every((c) => c === ": heartbeat\n\n")).toBe(true);
   });
 });
 

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

@@ -14,6 +14,7 @@ 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 } =
   await import("../config/assistant-feature-flags.js");
@@ -62,6 +63,23 @@ describe("isAssistantFeatureFlagEnabled", () => {
     );
   });
 
+  test("safe-storage-limits defaults to disabled", () => {
+    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;
 

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

@@ -389,13 +389,19 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
   const originalExtractionBatch = TEST_CONFIG.memory.extraction.batchSize;
   const originalAnalysisBatch = TEST_CONFIG.analysis.batchSize;
 
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
   beforeEach(() => {
     _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;
     TEST_CONFIG.memory.extraction.batchSize = 2;
     TEST_CONFIG.analysis.batchSize = 5;
   });
 
   afterEach(() => {
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
     TEST_CONFIG.memory.extraction.batchSize = originalExtractionBatch;
     TEST_CONFIG.analysis.batchSize = originalAnalysisBatch;
   });
@@ -537,3 +543,45 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
     expect(row.runAfter).toBeLessThanOrEqual(after + 1_000);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────
+// Indexer v1/v2 mutual exclusion: when memory.v2.enabled is on, the
+// v1 graph_extract enqueue is suppressed (v2 reads from buffer.md,
+// so v1 graph data is unread). When v2 is disabled, v1 graph_extract
+// fires.
+// ─────────────────────────────────────────────────────────────────
+
+describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
+  // Force the v1 batch trigger so any enqueued row is observable.
+  const originalExtractionBatch = TEST_CONFIG.memory.extraction.batchSize;
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
+  beforeEach(() => {
+    TEST_CONFIG.memory.extraction.batchSize = 1;
+  });
+
+  afterEach(() => {
+    TEST_CONFIG.memory.extraction.batchSize = originalExtractionBatch;
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
+  });
+
+  test("v2 active (config on) → graph_extract not enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = true;
+
+    const source = createConversation("v2-active");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("graph_extract", source.id)).toBe(0);
+  });
+
+  test("config gate off → graph_extract enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = false;
+
+    const source = createConversation("v2-config-off");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("graph_extract", source.id)).toBeGreaterThanOrEqual(
+      1,
+    );
+  });
+});