@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/build-persisted-content.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for `buildPersistedAssistantContent` stamping native web-search
+ * activity (`_activityMetadata`) onto `server_tool_use` blocks at persist time.
+ *
+ * Native Anthropic web_search resolves mid-stream — `server_tool_complete`
+ * fires before `message_complete` — so the captured activity is available when
+ * the content is persisted. Unlike external provider tools, a pure-native turn
+ * has no `tool_result` and never runs `annotatePersistedAssistantMessage`, so
+ * stamping must happen here or the WebSearchProgressCard is lost on a history
+ * reopen. Read-side coverage 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: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import { buildPersistedAssistantContent } from "../daemon/conversation-agent-loop-handlers.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import type { ContentBlock } from "../providers/types.js";
+
+const webSearchActivity: ToolActivityMetadata = {
+  webSearch: {
+    query: "vellum docs",
+    provider: "anthropic-native",
+    resultCount: 1,
+    durationMs: 88,
+    results: [
+      {
+        rank: 1,
+        title: "Vellum",
+        url: "https://vellum.ai",
+        domain: "vellum.ai",
+      },
+    ],
+  },
+};
+
+function findBlockById(
+  blocks: ContentBlock[],
+  id: string,
+): Record<string, unknown> {
+  const block = (blocks as unknown as Array<Record<string, unknown>>).find(
+    (b) => b.id === id,
+  );
+  if (!block) throw new Error(`block ${id} not found`);
+  return block;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("buildPersistedAssistantContent — native activityMetadata", () => {
+  let activity: Map<string, ToolActivityMetadata>;
+
+  beforeEach(() => {
+    activity = new Map();
+  });
+
+  test("stamps captured activity onto a pure-native server_tool_use block", () => {
+    // GIVEN a turn whose only tool is a native server_tool_use whose activity
+    // was captured at server_tool_complete (no external tool_result, so the
+    // annotate pass never runs for this turn)
+    const nativeId = "srvtu_native_search";
+    activity.set(nativeId, webSearchActivity);
+    const rawBlocks = [
+      { type: "text", text: "Let me search." },
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the server_tool_use block carries the native activity verbatim so it
+    // survives a history reopen
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toEqual(webSearchActivity);
+  });
+
+  test("leaves a server_tool_use block untouched when no activity was captured", () => {
+    // GIVEN a native server_tool_use with no entry in the activity map
+    const nativeId = "srvtu_no_activity";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp external tool_use blocks (handled by the annotate pass)", () => {
+    // GIVEN an external tool_use block whose id happens to have captured
+    // activity (external activity is stamped later in handleToolResult, not here)
+    const externalId = "tu_external_search";
+    activity.set(externalId, webSearchActivity);
+    const rawBlocks = [
+      {
+        type: "tool_use",
+        id: externalId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the tool_use block is left untouched by this function
+    const block = findBlockById(built, externalId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp when no activity map is provided", () => {
+    // GIVEN a native server_tool_use block AND no activity map argument
+    const nativeId = "srvtu_no_map";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence without the optional map
+    const built = buildPersistedAssistantContent(rawBlocks, []);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/call-pointer-messages.test.ts

@@ -314,7 +314,7 @@ describe("addPointerMessage", () => {
     ensureConversation(convId);
     // Add a user message with guardian provenance metadata
     await addMessage(convId, "user", "hello", {
-      provenanceTrustClass: "guardian",
+      metadata: { provenanceTrustClass: "guardian" },
     });
 
     let processorCalled = false;
@@ -331,7 +331,7 @@ describe("addPointerMessage", () => {
     ensureConversation(convId);
     // Add a user message with trusted_contact provenance metadata
     await addMessage(convId, "user", "hello", {
-      provenanceTrustClass: "trusted_contact",
+      metadata: { provenanceTrustClass: "trusted_contact" },
     });
 
     let processorCalled = false;
@@ -346,7 +346,9 @@ describe("addPointerMessage", () => {
   test("unknown provenance trust class does not grant trusted audience", () => {
     const convId = "conv-ptr-unknown-provenance";
     ensureConversation(convId);
-    addMessage(convId, "user", "hello", { provenanceTrustClass: "unknown" });
+    addMessage(convId, "user", "hello", {
+      metadata: { provenanceTrustClass: "unknown" },
+    });
 
     const processorCalled = { value: false };
     setPointerMessageProcessor(async () => {

package/src/__tests__/call-site-routing-provider.test.ts

@@ -58,7 +58,7 @@ function makeProvider(
 ): Provider {
   return {
     name,
-    async sendMessage(_messages, _tools, _systemPrompt, options) {
+    async sendMessage(_messages: Message[], options?: SendMessageOptions) {
       onCall(options);
       return makeResponse(name);
     },
@@ -118,10 +118,7 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      // No callSite — must hit default even though `memoryRetrieval` is
+      DUMMY_MESSAGES, // No callSite — must hit default even though `memoryRetrieval` is
       // configured for openai.
       { config: {} },
     );
@@ -154,7 +151,7 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -190,12 +187,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(calls.default).toBe(0);
     expect(calls.alt).toBe(1);
@@ -229,12 +223,9 @@ describe("CallSiteRoutingProvider", () => {
       async () => null,
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(calls.default).toBe(1);
     expect(response.model).toBe("anthropic");
@@ -265,7 +256,7 @@ describe("CallSiteRoutingProvider", () => {
 
     let caught: unknown;
     try {
-      await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      await wrapped.sendMessage(DUMMY_MESSAGES, {
         config: { callSite: "memoryRetrieval" },
       });
     } catch (err) {
@@ -301,12 +292,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     // actualProvider must reflect the alternative, not the default, so that
     // loop.ts / emitUsage / llm_call_finished log and bill the correct
@@ -346,12 +334,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(response.actualProvider).toBe("openai-via-proxy");
   });
@@ -368,12 +353,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({}),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     // No alternative was resolved — actualProvider should stay unset.
     expect(response.actualProvider).toBeUndefined();
@@ -434,7 +416,7 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     expect(wrapped.name).toBe("anthropic"); // idle → default
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
     expect(namesDuringCall).toEqual(["openai"]); // mid-call → routed provider
@@ -511,10 +493,10 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     // Start both calls concurrently (do not await yet).
-    const callA = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    const callA = wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" }, // → openai
     });
-    const callB = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    const callB = wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "conversationTitle" }, // → fireworks
     });
 

package/src/__tests__/catalog-files.test.ts

@@ -963,6 +963,7 @@ describe("createVellumCatalogProvider", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.origin).toBe("vellum");
     expect(slim!.status).toBe("available");
+    expect(slim!.category).toBe("system");
   });
 
   test("toSlimSkill returns null for unknown skill", async () => {

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

@@ -16,7 +16,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
@@ -325,7 +325,9 @@ describe("inbound callback metadata triggers decision handling", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cb-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-cb-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -362,7 +364,9 @@ describe("inbound callback metadata triggers decision handling", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cb-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cb-2", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -410,7 +414,9 @@ describe("inbound text matching approval phrases triggers decision handling", ()
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-txt-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-txt-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -554,7 +560,9 @@ describe("empty content with callbackData bypasses validation", () => {
     const body = (await res.json()) as Record<string, unknown>;
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-empty-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-empty-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -696,7 +704,9 @@ describe("callback requestId validation", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-match", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-match", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -730,7 +740,9 @@ describe("callback requestId validation", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-plaintext", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-plaintext", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -933,7 +945,9 @@ describe("plain-text channel approval decisions", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-pt-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-pt-1", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -966,7 +980,9 @@ describe("plain-text channel approval decisions", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-pt-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-pt-2", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1098,7 +1114,9 @@ describe("guardian decision scoping — multiple pending approvals", () => {
     expect(body.approval).toBe("guardian_decision_applied");
 
     // The older request's session should have been called
-    expect(olderSession).toHaveBeenCalledWith("req-older", "allow");
+    expect(olderSession).toHaveBeenCalledWith("req-older", "allow", {
+      decisionContext: undefined,
+    });
 
     // The newer request's session should NOT have been called
     expect(newerSession).not.toHaveBeenCalled();
@@ -1244,7 +1262,9 @@ describe("expired guardian approval auto-denies via sweep", () => {
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     // The session should have been denied
-    expect(sessionMock).toHaveBeenCalledWith("req-exp-1", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-exp-1", "deny", {
+      decisionContext: undefined,
+    });
 
     // Both requester and guardian should have been notified
     const requesterNotify = deliverSpy.mock.calls.filter(
@@ -1457,7 +1477,9 @@ describe("conversational approval engine — standard path", () => {
     expect(body.approval).toBe("decision_applied");
 
     // The session should have received an allow decision
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-2", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-2", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1504,7 +1526,9 @@ describe("conversational approval engine — standard path", () => {
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
 
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-3", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-3", "deny", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1556,7 +1580,9 @@ describe("conversational approval engine — standard path", () => {
 
     // The callback button should have been used directly, not the engine
     expect(mockConversationGenerator).not.toHaveBeenCalled();
-    expect(sessionMock).toHaveBeenCalledWith("req-conv-4", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-conv-4", "allow", {
+      decisionContext: undefined,
+    });
 
     deliverSpy.mockRestore();
   });
@@ -1705,7 +1731,9 @@ describe("guardian conversational approval via conversation engine", () => {
     expect(body.approval).toBe("guardian_decision_applied");
 
     // The session should have received an 'allow' decision
-    expect(sessionMock).toHaveBeenCalledWith("req-gnlp-1", "allow");
+    expect(sessionMock).toHaveBeenCalledWith("req-gnlp-1", "allow", {
+      decisionContext: undefined,
+    });
 
     // The approval record should have been updated (no longer pending)
     const pending = getAllPendingApprovalsByGuardianChat(
@@ -2097,7 +2125,9 @@ describe("requester cancel of guardian-gated pending request", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cancel-1", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cancel-1", "deny", {
+      decisionContext: undefined,
+    });
 
     // Requester should have been notified
     const requesterReply = deliverSpy.mock.calls.find(
@@ -2178,7 +2208,9 @@ describe("requester cancel of guardian-gated pending request", () => {
 
     expect(body.accepted).toBe(true);
     expect(body.approval).toBe("decision_applied");
-    expect(sessionMock).toHaveBeenCalledWith("req-cancel-2", "deny");
+    expect(sessionMock).toHaveBeenCalledWith("req-cancel-2", "deny", {
+      decisionContext: undefined,
+    });
 
     // Engine should have been called with reject-only allowed actions
     expect(mockConversationGenerator).toHaveBeenCalledTimes(1);
@@ -2605,7 +2637,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2666,7 +2697,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2724,7 +2754,6 @@ describe("background channel processing approval prompts", () => {
       async (
         _conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });
@@ -2765,7 +2794,6 @@ describe("background channel processing approval prompts", () => {
       async (
         conversationId: string,
         _content: string,
-        _attachmentIds?: string[],
         options?: Record<string, unknown>,
       ) => {
         processCalls.push({ options });

package/src/__tests__/channel-approvals.test.ts

@@ -11,7 +11,7 @@ mock.module("../util/logger.js", () => ({
 
 // Map conversationId → mock session so findConversation returns the right mock.
 const conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversationMocks.get(id),
 }));
 
@@ -240,6 +240,7 @@ describe("handleChannelDecision", () => {
     expect(mockConv.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-1",
       "allow",
+      { decisionContext: undefined },
     );
   });
 
@@ -257,6 +258,7 @@ describe("handleChannelDecision", () => {
     expect(mockConv.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-1",
       "deny",
+      { decisionContext: undefined },
     );
   });
 
@@ -277,6 +279,7 @@ describe("handleChannelDecision", () => {
     expect(newerMock.handleConfirmationResponse).toHaveBeenCalledWith(
       "req-newer",
       "allow",
+      { decisionContext: undefined },
     );
     expect(olderMock.handleConfirmationResponse).not.toHaveBeenCalled();
   });
@@ -293,7 +296,6 @@ describe("handleChannelDecision", () => {
     expect(result.applied).toBe(false);
     expect(result.requestId).toBeUndefined();
   });
-
 });
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/__tests__/channel-invite-transport.test.ts

@@ -7,11 +7,7 @@
  * canonical registry APIs (`createInviteAdapterRegistry`,
  * `getInviteAdapterRegistry`) that replaced the deprecated shims.
  */
-import { describe, expect, mock, test } from "bun:test";
-
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => true,
-}));
+import { describe, expect, test } from "bun:test";
 
 import {
   type ChannelInviteAdapter,

package/src/__tests__/channel-readiness-routes.test.ts

@@ -58,10 +58,6 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
 }));
 
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => true,
-}));
-
 // ---------------------------------------------------------------------------
 // Import under test
 // ---------------------------------------------------------------------------

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -47,10 +47,6 @@ mock.module("../calls/twilio-config.js", () => ({
   resolveTwilioPhoneNumber: () => undefined,
 }));
 
-mock.module("../email/feature-gate.js", () => ({
-  isEmailEnabled: () => false,
-}));
-
 mock.module("./channel-invite-transports/whatsapp.js", () => ({
   resolveWhatsAppDisplayNumber: () => undefined,
 }));
@@ -83,9 +79,8 @@ afterEach(() => {
 });
 
 async function runSlackRemoteProbe() {
-  const { createReadinessService } = await import(
-    "../runtime/channel-readiness-service.js"
-  );
+  const { createReadinessService } =
+    await import("../runtime/channel-readiness-service.js");
   const service = createReadinessService();
   return service.getReadiness("slack", true);
 }