@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/__tests__/model-intents.test.ts

@@ -28,6 +28,9 @@ describe("model intents", () => {
     expect(resolveModelIntent("openai", "latency-optimized")).toBe(
       "gpt-5.6-luna",
     );
+    expect(resolveModelIntent("gemini", "cost-optimized")).toBe(
+      "gemini-3.1-flash-lite",
+    );
     expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
       "gemini-3.1-flash-lite",
     );

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -3,6 +3,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // ── Mocks: declared before imports that depend on them ──────────────
 
 let updateMessageContentShouldThrow = false;
+let assistantName: string | null = null;
+
+mock.module("../daemon/identity-helpers.js", () => ({
+  getAssistantName: () => assistantName,
+}));
 
 const updateMessageContentMock = mock(
   (_messageId: string, _content: string) => {
@@ -55,12 +60,21 @@ function makeDestination(
 function captureBroadcast(): {
   adapter: VellumAdapter;
   sent: AssistantEvent[];
+  conversationIds: Array<string | undefined>;
 } {
   const sent: AssistantEvent[] = [];
-  const adapter = new VellumAdapter((msg) => sent.push(msg));
-  return { adapter, sent };
+  const conversationIds: Array<string | undefined> = [];
+  const adapter = new VellumAdapter((msg, conversationId) => {
+    sent.push(msg);
+    conversationIds.push(conversationId);
+  });
+  return { adapter, sent, conversationIds };
 }
 
+beforeEach(() => {
+  assistantName = null;
+});
+
 describe("VellumAdapter silent flag", () => {
   test("non-urgent (low) urgency broadcasts silent: true", async () => {
     const { adapter, sent } = captureBroadcast();
@@ -181,6 +195,75 @@ describe("VellumAdapter remotePushDispatched pass-through", () => {
   });
 });
 
+describe("VellumAdapter assistant name", () => {
+  test("broadcasts the current verified assistant name after trimming it", async () => {
+    assistantName = "  Example Assistant  ";
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBe("Example Assistant");
+  });
+
+  test("omits the assistant name when it is unavailable", async () => {
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBeUndefined();
+    expect("assistantName" in intent).toBe(false);
+  });
+
+  test("omits a blank assistant name", async () => {
+    assistantName = " \t\n ";
+    const { adapter, sent } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    const intent = sent[0] as Extract<
+      AssistantEvent,
+      { type: "notification_intent" }
+    >;
+    expect(intent.assistantName).toBeUndefined();
+    expect("assistantName" in intent).toBe(false);
+  });
+
+  test("reflects a renamed assistant on the next intent", async () => {
+    assistantName = "Assistant A";
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload(), makeDestination());
+
+    assistantName = "Assistant B";
+    await adapter.send(makePayload(), makeDestination());
+
+    const intents = sent as Array<
+      Extract<AssistantEvent, { type: "notification_intent" }>
+    >;
+    expect(intents.map((intent) => intent.assistantName)).toEqual([
+      "Assistant A",
+      "Assistant B",
+    ]);
+  });
+
+  test("keeps notification intents outside conversation replay scope", async () => {
+    assistantName = "Example Assistant";
+    const { adapter, sent, conversationIds } = captureBroadcast();
+
+    await adapter.send(makePayload(), makeDestination());
+
+    expect(conversationIds).toEqual([undefined]);
+    expect("conversationId" in sent[0]!).toBe(false);
+  });
+});
+
 describe("VellumAdapter update", () => {
   beforeEach(() => {
     updateMessageContentMock.mockClear();

package/src/__tests__/oauth-commands-routes.test.ts

@@ -25,6 +25,9 @@ interface MockProviderRow {
   managedServiceConfigKey: string | null;
   baseUrl: string | null;
   injectionTemplates: string | null;
+  defaultScopes?: string;
+  authorizeParams?: string | null;
+  scopeSeparator?: string;
   pingUrl: string | null;
   pingMethod: string | null;
   pingHeaders: string | null;
@@ -109,10 +112,15 @@ mock.module("../oauth/oauth-store.js", () => ({
   listActiveConnectionsByProvider: (provider: string) =>
     mockActiveConnectionsByProvider[provider] ?? [],
   listConnections: (provider: string) => mockAllConnections[provider] ?? [],
+  // Imported by seed-providers.js at module load; the seed data is read here,
+  // never written.
+  migrateProviderBaseUrl: () => {},
+  seedProviders: () => {},
 }));
 
 mock.module("../oauth/connection-resolver.js", () => {
   const makeConnection = () => ({
+    id: "conn-1",
     accountInfo: "user@example.com",
     request: async (req: unknown) => {
       mockResolveRequests.push(req);
@@ -155,6 +163,7 @@ mock.module("../security/token-manager.js", () => ({
 }));
 
 import { loadRawConfig } from "../config/loader.js";
+import { PROVIDER_SEED_DATA } from "../oauth/seed-providers.js";
 import {
   BadRequestError,
   InternalError,
@@ -899,6 +908,110 @@ describe("POST oauth/request", () => {
     ]);
   });
 
+  /** The provider row exactly as seeding writes it, so the seed data is what the guard reads. */
+  function seededProvider(provider: keyof typeof PROVIDER_SEED_DATA) {
+    const seed = PROVIDER_SEED_DATA[provider];
+    return {
+      ...baseProvider,
+      provider,
+      managedServiceConfigKey: null,
+      baseUrl: seed.baseUrl ?? null,
+      injectionTemplates: JSON.stringify(seed.injectionTemplates),
+    };
+  }
+
+  test("admits a Slack file URL on both seeded Slack providers", async () => {
+    // Each Slack credential reads messages, and a file shared in a message is
+    // fetched from its `url_private_download` on files.slack.com with the
+    // same token.
+    for (const provider of ["slack", "slack_channel"] as const) {
+      mockProviders[provider] = seededProvider(provider);
+      mockResolveRequests = [];
+
+      await getRoute("POST", "oauth/request").handler(
+        makeArgs({
+          body: {
+            provider,
+            url: "https://files.slack.com/files-pri/T0123-F0456/download/shot.png",
+          },
+        }),
+      );
+
+      expect(mockResolveRequests).toEqual([
+        {
+          method: "GET",
+          path: "/files-pri/T0123-F0456/download/shot.png",
+          baseUrl: "https://files.slack.com",
+        },
+      ]);
+    }
+  });
+
+  test("the seeded Slack host policy admits nothing beyond the documented hosts", async () => {
+    mockProviders.slack_channel = seededProvider("slack_channel");
+
+    // A lookalike, an unrelated host, and the CDN host Slack redirects file
+    // downloads to: the guard sees only the URL the caller names, and that
+    // URL is the documented file host or nothing.
+    for (const url of [
+      "https://files.slack.com.attacker.example/files-pri/T0123-F0456/x.png",
+      "https://attacker.example/files-pri/T0123-F0456/x.png",
+      "https://files-origin.slack.com/files-pri/T0123-F0456/x.png",
+    ]) {
+      await expect(
+        getRoute("POST", "oauth/request").handler(
+          makeArgs({ body: { provider: "slack_channel", url } }),
+        ),
+      ).rejects.toBeInstanceOf(BadRequestError);
+    }
+    expect(mockResolveRequests).toHaveLength(0);
+  });
+
+  test("names the required scopes a stored grant lacks on the request itself", async () => {
+    // A connection made before a scope was required keeps working for every
+    // call that does not need it, so the caller must be told on the request,
+    // not only by the next health check.
+    const seed = PROVIDER_SEED_DATA.slack;
+    mockProviders.slack = {
+      ...seededProvider("slack"),
+      defaultScopes: JSON.stringify(seed.defaultScopes),
+      authorizeParams: JSON.stringify(seed.authorizeParams),
+      scopeSeparator: " ",
+    };
+    const grantedBeforeFilesRead = seed
+      .authorizeParams!.user_scope.split(",")
+      .filter((scope) => scope !== "files:read");
+    mockAllConnections.slack = [
+      {
+        id: "conn-1",
+        provider: "slack",
+        grantedScopes: JSON.stringify(grantedBeforeFilesRead),
+      },
+    ];
+
+    const stale = (await getRoute("POST", "oauth/request").handler(
+      makeArgs({ body: { provider: "slack", url: "/conversations.history" } }),
+    )) as { ok: boolean; hint?: string };
+
+    expect(stale.ok).toBe(true);
+    expect(stale.hint).toContain("files:read");
+    expect(stale.hint).toContain("oauth connect slack");
+
+    mockAllConnections.slack = [
+      {
+        id: "conn-1",
+        provider: "slack",
+        grantedScopes: JSON.stringify(
+          seed.authorizeParams!.user_scope.split(","),
+        ),
+      },
+    ];
+    const current = (await getRoute("POST", "oauth/request").handler(
+      makeArgs({ body: { provider: "slack", url: "/conversations.history" } }),
+    )) as { hint?: string };
+    expect(current.hint).toBeUndefined();
+  });
+
   test("allows cross-host absolute URLs declared by provider injection templates", async () => {
     mockProviders.google = {
       ...baseProvider,
@@ -1052,6 +1165,33 @@ describe("POST oauth/managed-connect/start", () => {
     expect(result.connect_url).toBe("https://app.vellum.ai/connect/abc");
   });
 
+  test("forwards tenant_host to the platform only when one is supplied", async () => {
+    // Shopify's endpoints live on the merchant's host, which the platform
+    // substitutes into its templates; other providers must not see the key.
+    const bodies: Array<Record<string, unknown>> = [];
+    mockFetchImpl = async (_path, init) => {
+      bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          connect_url: "https://app.vellum.ai/connect/abc",
+        }),
+        text: async () => "",
+      };
+    };
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({
+        body: { provider: "shopify", tenant_host: " my-store.myshopify.com " },
+      }),
+    );
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({ body: { provider: "google", tenant_host: "   " } }),
+    );
+    expect(bodies[0]?.tenant_host).toBe("my-store.myshopify.com");
+    expect(bodies[1]).not.toHaveProperty("tenant_host");
+  });
+
   test("raises InternalError when platform returns 401", async () => {
     mockFetchImpl = async () => ({
       ok: false,
@@ -1115,6 +1255,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: string;
         account_label: string | null;
         scopes_granted: string[];
+        provider_params: Record<string, string>;
       }>;
     };
     expect(result.ok).toBe(true);
@@ -1123,6 +1264,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: "conn-1",
         account_label: "alice@example.com",
         scopes_granted: ["email"],
+        provider_params: {},
       },
     ]);
   });
@@ -1135,4 +1277,30 @@ describe("GET oauth/managed-connect/poll", () => {
       ),
     ).rejects.toBeInstanceOf(BadRequestError);
   });
+
+  test("passes through the provider params a connection is scoped by", async () => {
+    // QuickBooks pins the company (realm) the user picked to the connection;
+    // a caller addressing /companyinfo/<realmId> needs it back.
+    mockFetchImpl = async () => ({
+      ok: true,
+      status: 200,
+      json: async () => [
+        {
+          id: "conn-qb",
+          account_label: "Acme Widgets",
+          scopes_granted: ["com.intuit.quickbooks.accounting"],
+          provider_params: { realm_id: "9130357849012345" },
+        },
+      ],
+      text: async () => "",
+    });
+    const result = (await getRoute("GET", "oauth/managed-connect/poll").handler(
+      makeArgs({ queryParams: { provider: "quickbooks" } }),
+    )) as {
+      connections: Array<{ provider_params: Record<string, string> }>;
+    };
+    expect(result.connections[0]?.provider_params).toEqual({
+      realm_id: "9130357849012345",
+    });
+  });
 });

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -7,6 +7,7 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 import { getProvider } from "../oauth/oauth-store.js";
+import { expectedScopesForStoredToken } from "../oauth/scope-utils.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
 import { initializeDb } from "../persistence/db-init.js";
 
@@ -22,6 +23,23 @@ describe("oauth provider profiles (DB-seeded)", () => {
     expect(scopes).toContain("https://www.googleapis.com/auth/drive");
   });
 
+  test("slack provider row requests files:read for the token it stores", () => {
+    // The flow persists the authed_user token, and credential health measures
+    // its grant through the same function used here, so this is the scope set
+    // an integration connection must carry to fetch a file from files.slack.com.
+    const provider = getProvider("slack");
+
+    expect(provider).toBeDefined();
+    const expected = expectedScopesForStoredToken(
+      JSON.parse(provider!.defaultScopes) as string[],
+      provider!.authorizeParams
+        ? (JSON.parse(provider!.authorizeParams) as Record<string, string>)
+        : undefined,
+      provider!.scopeSeparator ?? undefined,
+    );
+    expect(expected).toContain("files:read");
+  });
+
   test("google provider row contains bearer injection templates for 8 Google API hosts", () => {
     const provider = getProvider("google");
 

package/src/__tests__/oauth-provider-serializer.test.ts

@@ -291,10 +291,32 @@ describe("serializeProviderSummary", () => {
       supports_managed_mode: true,
       managed_service_is_paid: false,
       feature_flag: null,
+      tenant_host: null,
       acts_as: "user",
     });
   });
 
+  test("exposes the tenant host a per-tenant provider needs at connect", () => {
+    // Shopify's OAuth endpoints live on the merchant's own host, so a client
+    // has to collect it before the managed flow can start. The summary is the
+    // only provider metadata the web client reads, so it carries the ask.
+    const shopify = serializeProviderSummary(makeRow({ provider: "shopify" }))!;
+    expect(shopify.tenant_host).toEqual({
+      pattern: "^[a-z0-9][a-z0-9-]*\\.myshopify\\.com$",
+      label: "Shop domain",
+      placeholder: "your-store.myshopify.com",
+    });
+    expect(
+      new RegExp(shopify.tenant_host!.pattern).test("my-store.myshopify.com"),
+    ).toBe(true);
+    expect(new RegExp(shopify.tenant_host!.pattern).test("evil.com")).toBe(
+      false,
+    );
+    expect(
+      serializeProviderSummary(makeRow({ provider: "github" }))!.tenant_host,
+    ).toBeNull();
+  });
+
   test("names which sense of connected a provider represents", () => {
     // The provider key does not say, and the naming actively misleads:
     // `slack` is the user integration while its bot is `slack_channel`, but

package/src/__tests__/oauth-providers-routes.test.ts

@@ -178,6 +178,7 @@ describe("GET /v1/oauth/providers", () => {
       "supports_managed_mode",
       "managed_service_is_paid",
       "feature_flag",
+      "tenant_host",
       "acts_as",
     ];
 

package/src/__tests__/openai-provider.test.ts

@@ -982,6 +982,7 @@ describe("OpenAIProvider", () => {
     );
 
     expect(lastCreateParams!.max_completion_tokens).toBe(64000);
+    expect(lastCreateParams).not.toHaveProperty("max_tokens");
   });
 
   // -----------------------------------------------------------------------

package/src/__tests__/outlook-messaging-provider.test.ts

@@ -429,7 +429,7 @@ describe("Outlook messaging provider", () => {
   describe("sendMessage", () => {
     test("sends a new message with correct recipient, subject, and body", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -452,7 +452,7 @@ describe("Outlook messaging provider", () => {
 
     test("uses empty string for subject when not provided", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -471,7 +471,7 @@ describe("Outlook messaging provider", () => {
 
     test("calls replyToMessage when inReplyTo is provided", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply text",
@@ -493,7 +493,7 @@ describe("Outlook messaging provider", () => {
 
     test("attaches files to a new message as Graph file attachments", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "See attached",
@@ -530,7 +530,7 @@ describe("Outlook messaging provider", () => {
 
     test("forwards attachments to replyToMessage when replying", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply body",
@@ -563,7 +563,7 @@ describe("Outlook messaging provider", () => {
 
     test("throws when connection is undefined", async () => {
       await expect(
-        outlookMessagingProvider.sendMessage(
+        outlookMessagingProvider.sendMessage!(
           undefined,
           "recipient@example.com",
           "Hello!",

package/src/__tests__/platform-callback-registration.test.ts

@@ -110,8 +110,7 @@ describe("platform callback registration", () => {
   test("resolves managed callback context from stored credentials", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -129,8 +128,7 @@ describe("platform callback registration", () => {
     mockIsPlatform = false;
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -161,8 +159,7 @@ describe("platform callback registration", () => {
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -209,8 +206,7 @@ describe("platform callback registration", () => {
     };
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -251,8 +247,7 @@ describe("platform callback registration", () => {
     setIngressPublicBaseUrl("https://detected.example.com/");
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -292,8 +287,7 @@ describe("platform callback registration", () => {
     mockConfig = {};
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "22222222-3333-4444-8555-666666666666";
+    mockPlatformAssistantId = "22222222-3333-4444-8555-666666666666";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-self-hosted-key";
 
@@ -334,8 +328,7 @@ describe("platform callback registration", () => {
     mockConfig = { ingress: { publicBaseUrl: "https://velay.example.com" } };
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
 
@@ -396,8 +389,7 @@ describe("resolveCallbackUrl resolution order", () => {
   function seedPlatformCredentials(): void {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";
-    mockSecureKeys[credentialKey("vellum", "platform_assistant_id")] =
-      "11111111-2222-4333-8444-555555555555";
+    mockPlatformAssistantId = "11111111-2222-4333-8444-555555555555";
     mockSecureKeys[credentialKey("vellum", "assistant_api_key")] =
       "ast-managed-key";
   }

package/src/__tests__/platform-client-verify-credential.test.ts

@@ -19,7 +19,9 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   }),
 }));
 
+const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...actualEnv,
   getPlatformAssistantId: () => platformAssistantId,
 }));
 

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -129,6 +129,9 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/embedding-reconcile.js",
     "../../../../daemon/trust-context.js",
     "../../../../daemon/turn-latency-sub-spans.js",
+    // mcp-setup capability cards list configured server names from the
+    // workspace mcp.json document. No plugin-api equivalent.
+    "../../../../mcp/workspace-mcp-config.js",
     "../../../../notifications/background-failure-signal.js",
     "../../../../persistence/checkpoints.js",
     "../../../../persistence/conversation-types.js",
@@ -210,6 +213,16 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/job-handlers/message-lexical.js",
     "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
+    // The retrospective cursor is a `(createdAt, id)` bound that must keep
+    // working after its message row is deleted. The resolver lives beside
+    // the persistence after-reads it also drives, so the plugin's
+    // accounting imports it rather than re-deriving the bound. No
+    // plugin-api equivalent.
+    "../../../persistence/message-cursor.js",
+    // Named any-state `createdAt` lookup the cursor bookkeeping uses for
+    // forks and the timestamp backfill; the messages-read boundary guard
+    // requires the read to live in persistence. No plugin-api equivalent.
+    "../../../persistence/message-reads.js",
     "../../../persistence/raw-query.js",
     "../../../persistence/schema/index.js",
     "../../../prompts/persona-resolver.js",
@@ -235,6 +248,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/sqlite-retry.js",
     "../../../util/strip-comment-lines.js",
     "../../../util/truncate.js",
+    "../../../util/unicode.js",
     "../../../util/worker-compute.js",
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",