@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/__tests__/media-stream-output.test.ts

@@ -26,6 +26,7 @@ import {
 } from "../calls/media-stream-audio-transcode.js";
 import { MediaStreamOutput } from "../calls/media-stream-output.js";
 import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const mockResolveCallTtsProvider = resolveCallTtsProvider as ReturnType<
   typeof jest.fn
@@ -1213,6 +1214,180 @@ describe("MediaStreamOutput", () => {
     });
   });
 
+  // ---------------------------------------------------------------------------
+  // Synthesis language hint
+  // ---------------------------------------------------------------------------
+
+  describe("synthesis language hint", () => {
+    /** Synthesize one turn and return the provider request it produced. */
+    async function synthesizeOneTurn(
+      output: MediaStreamOutput,
+    ): Promise<{ language?: string }> {
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+      output.sendTextToken("Hello caller.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+      return mockSynthesize.mock.calls[0][0] as { language?: string };
+    }
+
+    test("the resolver's language rides the provider request", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+      output.setSynthesisLanguageResolver(() => "es");
+
+      const request = await synthesizeOneTurn(output);
+
+      expect(request.language).toBe("es");
+    });
+
+    test("fixed system copy synthesizes without the caller-language hint while model text keeps it", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+      output.setSynthesisLanguageResolver(() => "ja");
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+
+      output.sendTextToken("Model reply.", true);
+      output.sendTextToken("Are you still there?", true, { systemCopy: true });
+      await drain(() => mockSynthesize.mock.calls.length >= 2);
+
+      const requests = mockSynthesize.mock.calls.map(
+        (call) => call[0] as { text: string; language?: string },
+      );
+      expect(requests[0]?.text).toBe("Model reply.");
+      expect(requests[0]?.language).toBe("ja");
+      expect(requests[1]?.text).toBe("Are you still there?");
+      expect(requests[1]?.language).toBeUndefined();
+    });
+
+    test("no language when nothing resolves (default multilingual pin)", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+
+      const request = await synthesizeOneTurn(output);
+
+      expect(request.language).toBeUndefined();
+    });
+
+    test("a monolingual pin on a manual-selection provider resolves as the hint", async () => {
+      setConfig("services", {
+        stt: { provider: "deepgram", language: "es-ES" },
+      });
+      try {
+        const { ws } = createMockWs();
+        const output = makeOutput(ws, "stream-lang");
+
+        const request = await synthesizeOneTurn(output);
+
+        expect(request.language).toBe("es");
+      } finally {
+        setConfig("services", {});
+      }
+    });
+
+    test("the pin is ignored for auto-detecting providers", async () => {
+      setConfig("services", {
+        stt: { provider: "openai-whisper", language: "es" },
+      });
+      try {
+        const { ws } = createMockWs();
+        const output = makeOutput(ws, "stream-lang");
+
+        const request = await synthesizeOneTurn(output);
+
+        expect(request.language).toBeUndefined();
+      } finally {
+        setConfig("services", {});
+      }
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Per-language voice override (languageVoices)
+  // ---------------------------------------------------------------------------
+
+  describe("per-language voice override", () => {
+    afterEach(() => {
+      setConfig("services", {});
+    });
+
+    /** Seed a deepgram languageVoices entry and resolve deepgram as the provider. */
+    function useDeepgramWithHindiVoice(): void {
+      setConfig("services", {
+        tts: {
+          provider: "deepgram",
+          providers: {
+            deepgram: { languageVoices: { hi: "aura-2-hindi-voice" } },
+          },
+        },
+      });
+      useProvider({
+        id: "deepgram",
+        capabilities: { supportsStreaming: false, supportedFormats: ["wav"] },
+        synthesize: mockSynthesize,
+      });
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+    }
+
+    test("a configured languageVoices entry for the resolved language rides the request as voiceId", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "hi");
+
+      output.sendTextToken("Namaste.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBe("hi");
+      expect(request.voiceId).toBe("aura-2-hindi-voice");
+    });
+
+    test("no voiceId when the map has no entry for the resolved language", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "es");
+
+      output.sendTextToken("Hola.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBe("es");
+      expect(request.voiceId).toBeUndefined();
+    });
+
+    test("system copy gets neither the language hint nor the language voice", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "hi");
+
+      output.sendTextToken("Are you still there?", true, { systemCopy: true });
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBeUndefined();
+      expect(request.voiceId).toBeUndefined();
+    });
+  });
+
   // ---------------------------------------------------------------------------
   // Streaming PCM synthesis (incremental transcode)
   // ---------------------------------------------------------------------------

package/src/__tests__/media-stream-server-integration.test.ts

@@ -406,6 +406,8 @@ mock.module("../calls/access-request-wait.js", () => ({
 // Now import the module under test.
 // ---------------------------------------------------------------------------
 
+import { GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE } from "@vellumai/service-contracts/ingress";
+
 import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approval-grants.js";
 import { CallController } from "../calls/call-controller.js";
 import { postPointerMessageSafe } from "../calls/call-pointer-messages.js";
@@ -746,6 +748,40 @@ describe("MediaStreamCallSession", () => {
       );
     });
 
+    test("tunnel-lost close code decodes to a readable failure detail", () => {
+      const mock = createMockWs();
+      mockSessions.set("call-1", {
+        id: "call-1",
+        conversationId: "conv-1",
+        status: "in_progress",
+        startedAt: Date.now() - 60000,
+        toNumber: "+16175550142",
+        initiatedFromConversationId: "conv-origin",
+      });
+
+      const session = new MediaStreamCallSession(mock.ws, "call-1");
+      // The gateway's close reason is dropped in relay, so only the code
+      // arrives; it must decode to something a human can act on.
+      session.handleTransportClosed(GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE);
+
+      expect(updateCallSession).toHaveBeenCalledWith(
+        "call-1",
+        expect.objectContaining({
+          status: "failed",
+          lastError:
+            "Media stream WebSocket closed unexpectedly: public ingress tunnel disconnected",
+        }),
+      );
+      expect(postPointerMessageSafe).toHaveBeenCalledWith(
+        "conv-origin",
+        "failed",
+        "+16175550142",
+        expect.objectContaining({
+          reason: "public ingress tunnel disconnected",
+        }),
+      );
+    });
+
     test("close on already-terminal session is a no-op", () => {
       const mock = createMockWs();
       mockSessions.set("call-1", {

package/src/__tests__/media-stream-stt-session.test.ts

@@ -897,6 +897,73 @@ describe("MediaStreamSttSession", () => {
       session.dispose();
     });
 
+    // ── Detected language (latest tagged utterance) ─────────────────
+
+    test("a language switch retargets on the first final in the new language", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      expect(session.currentLanguage()).toBeUndefined();
+
+      fake.emit({ type: "final", text: "hola", languages: ["es", "en"] });
+      fake.emit({ type: "final", text: "buenos dias", languages: ["es"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      // The first ja-tagged utterance wins immediately: the caller does
+      // not have to outvote the session's es history. The secondary "es"
+      // tag does not dilute the utterance's dominant tag.
+      fake.emit({ type: "final", text: "konnichiwa", languages: ["ja", "es"] });
+      expect(session.currentLanguage()).toBe("ja");
+
+      session.dispose();
+    });
+
+    test("regional variants normalize to their base subtag", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      fake.emit({ type: "final", text: "tudo bem", languages: ["pt-BR"] });
+
+      expect(session.currentLanguage()).toBe("pt");
+
+      session.dispose();
+    });
+
+    test("empty and untagged finals keep the previous value", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      // A silence final can carry container-level tags describing no
+      // emitted words; it must not update the language.
+      fake.emit({ type: "final", text: "   ", languages: ["fr"] });
+      expect(session.currentLanguage()).toBeUndefined();
+
+      fake.emit({ type: "final", text: "hola", languages: ["es"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      // A committed final without tags keeps the previous value.
+      fake.emit({ type: "final", text: "hello" });
+      expect(session.currentLanguage()).toBe("es");
+
+      // So does a tagged silence final after a language is established.
+      fake.emit({ type: "final", text: "   ", languages: ["fr"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      session.dispose();
+    });
+
+    test("falling back to batch mid-call clears the detected language", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      fake.emit({ type: "final", text: "konnichiwa", languages: ["ja"] });
+      expect(session.currentLanguage()).toBe("ja");
+
+      // Provider closes the stream unexpectedly: the session settles on
+      // batch, whose transcripts carry no language metadata. The stale ja
+      // detection must not keep hinting synthesis for English speech.
+      fake.emit({ type: "closed" });
+      expect(session.currentLanguage()).toBeUndefined();
+
+      session.dispose();
+    });
+
     test("local VAD turn end never triggers batch transcription in streaming mode", async () => {
       const onTranscriptFinal = jest.fn();
       const { session } = await startStreamingSession(

package/src/__tests__/migration-export-http.test.ts

@@ -563,7 +563,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-commit-http.test.ts

@@ -1171,7 +1171,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -737,7 +737,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-validate-http.test.ts

@@ -634,7 +634,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/mtime-cache.test.ts

@@ -14,6 +14,7 @@ import {
   mkdirSync,
   readFileSync,
   rmSync,
+  symlinkSync,
   utimesSync,
   writeFileSync,
 } from "node:fs";
@@ -507,17 +508,17 @@ describe("workspace hooks (<workspace>/hooks/)", () => {
     writePackageJson(dir, { ...SIMPLE_PKG, name: "ordering-plugin" });
     writeHook(
       dir,
-      "pre-model-call",
+      "conversation-deleted",
       `export default () => ({ tag: "plugin" });`,
     );
     writeWorkspaceHook(
-      "pre-model-call",
+      "conversation-deleted",
       `export default () => ({ tag: "workspace" });`,
     );
 
     await populateCacheAtBoot();
 
-    const hooks = await getUserHooksFor("pre-model-call");
+    const hooks = await getUserHooksFor("conversation-deleted");
     expect(hooks).toHaveLength(2);
     const results = hooks.map((fn) =>
       (fn as unknown as () => { tag: string })(),
@@ -1004,4 +1005,65 @@ describe("plugin root validation (ATL-983)", () => {
     // The evil plugin's init hook must NOT have run.
     expect(existsSync(evilMarker)).toBe(false);
   });
+
+  test("a symlinked plugin root escaping the plugins dir is not activated at boot", async () => {
+    // A real plugin outside the plugins directory, linked in under a name the
+    // boot scan reads. Hook resolution follows the link, so discovery is the
+    // only thing between boot and code from anywhere on disk.
+    const escapee = join(ROOT, "outside", "escapee");
+    mkdirSync(escapee, { recursive: true });
+    writePackageJson(escapee, { ...SIMPLE_PKG, name: "escapee" });
+    const escapeeMarker = join(ROOT, "escapee-init.log");
+    rmSync(escapeeMarker, { force: true });
+    writeMarkerHook(escapee, "init", escapeeMarker, "init");
+    writeHook(
+      escapee,
+      "user-prompt-submit",
+      `export default () => ({ tag: "escapee" });`,
+    );
+    symlinkSync(escapee, join(PLUGINS_DIR, "escapee"));
+
+    // A contained plugin in the same scan, so a boot that discovered nothing
+    // at all cannot pass this test.
+    const keeper = freshPluginDir("keeper");
+    writePackageJson(keeper, { ...SIMPLE_PKG, name: "keeper" });
+    writeHook(
+      keeper,
+      "user-prompt-submit",
+      `export default () => ({ tag: "keeper" });`,
+    );
+
+    await populateCacheAtBoot();
+
+    expect(
+      (await getUserHooksFor("user-prompt-submit")).map(
+        (fn) => (fn as unknown as () => { tag: string })().tag,
+      ),
+    ).toEqual(["keeper"]);
+    expect(existsSync(escapeeMarker)).toBe(false);
+  });
+
+  test("a symlinked plugin root staying inside the plugins dir is activated at boot", async () => {
+    // A symlinked plugin root is supported (see `plugins/source-fingerprint.ts`)
+    // as long as it resolves inside the plugins directory. The link target sits
+    // in a dot-prefixed store directory, which carries no package.json and is
+    // therefore not an install of its own.
+    const target = join(PLUGINS_DIR, ".store", "alias");
+    mkdirSync(target, { recursive: true });
+    writePackageJson(target, { ...SIMPLE_PKG, name: "alias" });
+    writeHook(
+      target,
+      "user-prompt-submit",
+      `export default () => ({ tag: "alias" });`,
+    );
+    symlinkSync(target, join(PLUGINS_DIR, "alias"));
+
+    await populateCacheAtBoot();
+
+    expect(
+      (await getUserHooksFor("user-prompt-submit")).map(
+        (fn) => (fn as unknown as () => { tag: string })().tag,
+      ),
+    ).toEqual(["alias"]);
+  });
 });

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

@@ -340,6 +340,110 @@ describe("PlatformPushAdapter", () => {
     expect(result.remotePushAccepted).toBeUndefined();
   });
 
+  // A lock screen renders no markdown, so any marker that survives to the
+  // dispatch body reads as literal punctuation. See `stripMarkdownForPreview`.
+  describe("markdown flattening", () => {
+    test("flattens markdown out of the dispatched title and body", async () => {
+      const adapter = new PlatformPushAdapter();
+      const payload = makePayload({
+        copy: {
+          title: "**Build** finished",
+          body: [
+            "Here is the clip: ![vellum scene](vellum://workspace/a.mp4)",
+            "```ts",
+            "const a = 1;",
+            "```",
+            "| name | value |",
+            "| --- | --- |",
+            "| a | 1 |",
+          ].join("\n"),
+        },
+      });
+
+      const result = await adapter.send(payload, makeDestination());
+
+      expect(result.success).toBe(true);
+      const dispatched = fetchCalls[0]!.body;
+      expect(dispatched.title).toBe("Build finished");
+      const dispatchedBody = dispatched.body as string;
+      expect(dispatchedBody).not.toContain("![");
+      expect(dispatchedBody).not.toContain("```");
+      expect(dispatchedBody).not.toContain("|");
+      expect(dispatchedBody).toContain("Here is the clip:");
+      expect(dispatchedBody).toContain("const a = 1;");
+      expect(dispatchedBody).toContain("name value");
+    });
+
+    // Guardian question copy joins its question and instruction with a blank
+    // line, and iOS renders the break, so flattening must not collapse it.
+    test("preserves newlines in the dispatched body", async () => {
+      const adapter = new PlatformPushAdapter();
+      const payload = makePayload({
+        copy: {
+          title: "Question",
+          body: "Should I book the flight?\n\nReply here to answer.",
+        },
+      });
+
+      const result = await adapter.send(payload, makeDestination());
+
+      expect(result.success).toBe(true);
+      expect(fetchCalls[0]!.body.body).toBe(
+        "Should I book the flight?\n\nReply here to answer.",
+      );
+    });
+
+    test("leaves plain prose untouched", async () => {
+      const adapter = new PlatformPushAdapter();
+      const result = await adapter.send(makePayload(), makeDestination());
+
+      expect(result.success).toBe(true);
+      expect(fetchCalls[0]!.body.title).toBe("Reminder");
+      expect(fetchCalls[0]!.body.body).toBe("Check the oven!");
+    });
+
+    // The pass-through path copies a verbatim `requestedMessage` into both the
+    // title and the body, so media-only copy flattens both to nothing. Every
+    // empty-copy guard in the pipeline runs upstream of this adapter, and the
+    // platform's serializer rejects a blank title, so an unrecovered field
+    // costs the whole notification.
+    describe("copy that flattens to nothing", () => {
+      test("names the media instead of dispatching blank fields", async () => {
+        const adapter = new PlatformPushAdapter();
+        const embed = "![clip](vellum://workspace/a.mp4)";
+        const payload = makePayload({ copy: { title: embed, body: embed } });
+
+        const result = await adapter.send(payload, makeDestination());
+
+        expect(result.success).toBe(true);
+        expect(fetchCalls[0]!.body.title).toBe("Sent clip");
+        expect(fetchCalls[0]!.body.body).toBe("Sent clip");
+      });
+
+      test("counts several embeds", async () => {
+        const adapter = new PlatformPushAdapter();
+        const embeds =
+          "![one](vellum://workspace/1.mp4) ![two](https://e.com/2.png)";
+        const payload = makePayload({ copy: { title: embeds, body: embeds } });
+
+        await adapter.send(payload, makeDestination());
+
+        expect(fetchCalls[0]!.body.title).toBe("Sent 2 attachments");
+      });
+
+      // Nothing nameable is left, so the original beats a blank field: ugly
+      // copy still delivers, an empty title is a 400.
+      test("keeps the original when there is no media to name", async () => {
+        const adapter = new PlatformPushAdapter();
+        const payload = makePayload({ copy: { title: "###", body: "###" } });
+
+        await adapter.send(payload, makeDestination());
+
+        expect(fetchCalls[0]!.body.title).toBe("###");
+      });
+    });
+  });
+
   test("omits optional fields when absent from payload", async () => {
     const adapter = new PlatformPushAdapter();
     const payload: ChannelDeliveryPayload = {

package/src/__tests__/notification-schedule-notify-dedup.test.ts

@@ -3,7 +3,7 @@
  * deduplicated against prior firings of the same schedule.
  *
  * The scheduler supplies a unique per-firing dedupeKey
- * (`schedule:notify:<id>:<timestamp>`) so `updateEventDedupeKey` is never
+ * (`schedule:notify:<id>:<timestamp>`) so `setEventDedupeKey` is never
  * called for schedule signals and `checkDedupe` never finds a matching
  * row when the LLM decision engine generates a stable key like
  * `schedule:notify:<id>`.

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

@@ -23,7 +23,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
     );
   });
 
-  test("google provider row contains bearer injection templates for 4 Google API hosts", () => {
+  test("google provider row contains bearer injection templates for 6 Google API hosts", () => {
     const provider = getProvider("google");
 
     expect(provider).toBeDefined();
@@ -36,7 +36,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
       valuePrefix: string;
     }>;
 
-    expect(templates).toHaveLength(4);
+    expect(templates).toHaveLength(6);
 
     const byHost = new Map(templates.map((t) => [t.hostPattern, t]));
 
@@ -45,6 +45,8 @@ describe("oauth provider profiles (DB-seeded)", () => {
       "www.googleapis.com",
       "people.googleapis.com",
       "docs.googleapis.com",
+      "tasks.googleapis.com",
+      "calendar.googleapis.com",
     ]) {
       const tpl = byHost.get(host);
       expect(tpl).toBeDefined();

package/src/__tests__/oauth-provider-seed-logos.test.ts

@@ -1,7 +1,44 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { PROVIDER_SEED_DATA } from "../oauth/seed-providers.js";
 
+const REPO_ROOT = dirname(dirname(dirname(import.meta.dir)));
+const WEB_PUBLIC_DIR = join(REPO_ROOT, "clients/web/public");
+const INTEGRATION_ICON_SOURCE = join(
+  REPO_ROOT,
+  "clients/web/src/components/integrations/integration-icon.tsx",
+);
+
+/**
+ * Provider keys the web client draws without a `BUNDLED_LOGO_URLS` entry.
+ * Google's mark is multi-colour, so it ships as the `GoogleLogo` component
+ * and is returned before the bundled-asset lookup runs.
+ */
+const COMPONENT_RENDERED_PROVIDERS = new Set(["google"]);
+
+/** `publicAsset("/images/...")` paths from `BUNDLED_LOGO_URLS`, by key. */
+function readBundledLogoMap(): Map<string, string> {
+  const source = readFileSync(INTEGRATION_ICON_SOURCE, "utf8");
+  const block = source.match(
+    /const BUNDLED_LOGO_URLS: Record<string, string> = \{([\s\S]*?)\n\};/,
+  );
+  if (!block) {
+    throw new Error(
+      `Could not find BUNDLED_LOGO_URLS in ${INTEGRATION_ICON_SOURCE}. If it ` +
+        `was renamed or restructured, update this test rather than deleting it.`,
+    );
+  }
+  const entries = new Map<string, string>();
+  for (const [, key, path] of block[1]!.matchAll(
+    /(\w+):\s*publicAsset\("([^"]+)"\)/g,
+  )) {
+    entries.set(key!, path!);
+  }
+  return entries;
+}
+
 /**
  * Allowed CDN prefixes for the ``logoUrl`` field on ``PROVIDER_SEED_DATA``
  * (``assistant/src/oauth/seed-providers.ts``):
@@ -41,3 +78,31 @@ describe("PROVIDER_SEED_DATA logo URLs", () => {
     expect(invalid).toEqual([]);
   });
 });
+
+/**
+ * The `logoUrl` above is a fallback for providers registered at runtime. Every
+ * provider we seed ourselves must draw from an asset we ship, because an icon
+ * CDN can drop a brand at any time and the client then degrades to an initials
+ * avatar with nothing in CI to notice: the prefix check above passes just as
+ * happily for a URL that 404s. Simple Icons hosts no Microsoft mark and no
+ * Slack mark, so the seeded URLs for those brands do not resolve there.
+ */
+describe("PROVIDER_SEED_DATA bundled logo coverage", () => {
+  test("every seeded provider renders from a bundled asset", () => {
+    const bundled = readBundledLogoMap();
+    const uncovered = Object.keys(PROVIDER_SEED_DATA).filter(
+      (provider) =>
+        !bundled.has(provider) && !COMPONENT_RENDERED_PROVIDERS.has(provider),
+    );
+
+    expect(uncovered).toEqual([]);
+  });
+
+  test("every bundled logo path resolves to a file on disk", () => {
+    const missingFiles = [...readBundledLogoMap()]
+      .filter(([, path]) => !existsSync(join(WEB_PUBLIC_DIR, path)))
+      .map(([provider, path]) => ({ provider, path }));
+
+    expect(missingFiles).toEqual([]);
+  });
+});