@vellumai/assistant 0.11.8-staging.1 → 0.11.8-staging.2

package/docs/guardian-request-flow.md

@@ -64,9 +64,9 @@ it end to end:
   `guardian:<requestId>`, so the feed's replace-in-place merge keeps one
   item per request. Its typed `guardianRequest` field
   (`FeedItemGuardianRequestSchema` in `api/responses/home.ts`) is a read
-  projection of the gateway row: intent, status, requester, tool, source
-  reference, and the Slack-DM card deep links. It is never a delivery
-  row of its own; clients derive every affordance from `status`.
+  projection of the gateway row: intent, status, requester, tool, and
+  source reference. It is never a delivery row of its own; clients
+  derive every affordance from `status`.
 - `withdrawGuardianRequestCards` rewrites it into a terminal receipt as
   one of the surfaces it settles, and its failure gates `complete` the
   same way a failed card edit does. The write-vs-resolve race converges

package/openapi.yaml

@@ -13792,14 +13792,8 @@ paths:
                               type: string
                             sourceUrl:
                               type: string
-                            slackCardUrl:
-                              type: string
-                            slackCardAppUrl:
-                              type: string
                             decidedAction:
                               type: string
-                            decidedByLabel:
-                              type: string
                             decidedAt:
                               type: string
                             terminalReason:
@@ -14033,14 +14027,8 @@ paths:
                         type: string
                       sourceUrl:
                         type: string
-                      slackCardUrl:
-                        type: string
-                      slackCardAppUrl:
-                        type: string
                       decidedAction:
                         type: string
-                      decidedByLabel:
-                        type: string
                       decidedAt:
                         type: string
                       terminalReason:
@@ -14368,14 +14356,8 @@ paths:
                               type: string
                             sourceUrl:
                               type: string
-                            slackCardUrl:
-                              type: string
-                            slackCardAppUrl:
-                              type: string
                             decidedAction:
                               type: string
-                            decidedByLabel:
-                              type: string
                             decidedAt:
                               type: string
                             terminalReason:
@@ -23005,14 +22987,8 @@ paths:
                             type: string
                           sourceUrl:
                             type: string
-                          slackCardUrl:
-                            type: string
-                          slackCardAppUrl:
-                            type: string
                           decidedAction:
                             type: string
-                          decidedByLabel:
-                            type: string
                           decidedAt:
                             type: string
                           terminalReason:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.8-staging.1",
+  "version": "0.11.8-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -90,7 +90,7 @@ describe("buildAccessRequestSeedContentBlocks", () => {
     });
     expect(data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — #C01ABC",
+      value: "Slack · #C01ABC",
     });
   });
 
@@ -101,7 +101,7 @@ describe("buildAccessRequestSeedContentBlocks", () => {
     });
     expect(surfaceOf(blocks).data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });
 

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

@@ -3602,6 +3602,8 @@ describe("AnthropicProvider — deprecated sampling params (temperature / top_p
     "claude-sonnet-5",
     "anthropic/claude-sonnet-5",
     "claude-fable-5",
+    "claude-fable-5-1",
+    "anthropic/claude-fable-5.1",
   ]) {
     test(`strips temperature, top_p, and top_k for ${model}`, async () => {
       const provider = new AnthropicProvider("sk-ant-test", model);

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

@@ -13,6 +13,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { CHANNEL_METADATA } from "../channels/types.js";
+import { credentialKey } from "../security/credential-key.js";
 
 // ---------------------------------------------------------------------------
 // Mock state — flipped per-test
@@ -29,6 +30,11 @@ let mockEmailAddressesResponse: {
   body: { count: 0, results: [] },
 };
 let mockFetchThrows = false;
+let mockSecureKeys: Record<string, string> = {};
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
+}));
 
 mock.module("../platform/client.js", () => ({
   VellumPlatformClient: {
@@ -83,6 +89,7 @@ describe("channels/available", () => {
       body: { count: 0, results: [] },
     };
     mockFetchThrows = false;
+    mockSecureKeys = {};
   });
 
   test("base list only when no email address registered", async () => {
@@ -126,6 +133,14 @@ describe("channels/available", () => {
     expect(result.channels.map((c) => c.id)).toContain("email");
   });
 
+  test("appends email when a your-own provider credential is stored", async () => {
+    mockSecureKeys[credentialKey("resend", "api_key")] = "stored";
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toContain("email");
+  });
+
   test("base list only when platform returns non-ok", async () => {
     mockEmailAddressesResponse = {
       ok: false,

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

@@ -10,9 +10,11 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // ---------------------------------------------------------------------------
 // Mocks — must be set up before importing the service
 // ---------------------------------------------------------------------------
+import type { RegisteredInboxState } from "../email/registered-inbox.js";
 
 let mockSecureKeys: Record<string, string>;
 let mockHasTwilioCredentials: boolean;
+let mockRegisteredInbox: RegisteredInboxState;
 
 mock.module("../calls/twilio-rest.js", () => ({
   hasTwilioCredentials: () => mockHasTwilioCredentials,
@@ -25,6 +27,11 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (key: string) => mockSecureKeys[key] ?? null,
 }));
 
+mock.module("../email/registered-inbox.js", () => ({
+  resolveRegisteredInbox: async () => mockRegisteredInbox,
+  invalidateRegisteredInboxCache: () => {},
+}));
+
 // ---------------------------------------------------------------------------
 // Import under test
 // ---------------------------------------------------------------------------
@@ -45,6 +52,7 @@ describe("channel readiness routes — email and WhatsApp probes", () => {
     setConfig("email", {});
     mockSecureKeys = {};
     mockHasTwilioCredentials = false;
+    mockRegisteredInbox = { status: "none" };
   });
 
   // -------------------------------------------------------------------------
@@ -102,12 +110,15 @@ describe("channel readiness routes — email and WhatsApp probes", () => {
       expect(ingressCheck!.passed).toBe(false);
     });
 
-    test("ready when all prerequisites are met (including inbox)", async () => {
+    test("ready when the platform reports a registered inbox", async () => {
       setConfig("ingress", {
         publicBaseUrl: "https://example.com",
         enabled: true,
       });
-      setConfig("email", { address: "user@example.com" });
+      mockRegisteredInbox = {
+        status: "registered",
+        address: "assistant@example.com",
+      };
       const service = createReadinessService();
       const [snapshot] = await service.getReadiness("email", true);
 
@@ -115,7 +126,26 @@ describe("channel readiness routes — email and WhatsApp probes", () => {
       expect(snapshot.reasons).toHaveLength(0);
     });
 
-    test("not ready when inbox is missing (remote check)", async () => {
+    test("platform registration decides the check; local config cannot", async () => {
+      // Registration lives on the platform. A stray local `email.address`
+      // config value (a key nothing writes) must not make an unregistered
+      // inbox pass.
+      setConfig("ingress", {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+      });
+      setConfig("email", { address: "stale@example.com" });
+      mockRegisteredInbox = { status: "none" };
+      const service = createReadinessService();
+      const [snapshot] = await service.getReadiness("email", true);
+
+      expect(snapshot.ready).toBe(false);
+      expect(snapshot.reasons.some((r) => r.code === "inbox_configured")).toBe(
+        true,
+      );
+    });
+
+    test("not ready when the platform reports no inbox (remote check)", async () => {
       setConfig("ingress", {
         publicBaseUrl: "https://example.com",
         enabled: true,
@@ -129,6 +159,69 @@ describe("channel readiness routes — email and WhatsApp probes", () => {
       );
     });
 
+    test("missing platform credentials fail the inbox check", async () => {
+      setConfig("ingress", {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+      });
+      mockRegisteredInbox = { status: "no_platform" };
+      const service = createReadinessService();
+      const [snapshot] = await service.getReadiness("email", true);
+
+      expect(snapshot.ready).toBe(false);
+      expect(snapshot.reasons.some((r) => r.code === "inbox_configured")).toBe(
+        true,
+      );
+    });
+
+    test("a your-own provider credential passes the inbox check", async () => {
+      setConfig("ingress", {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+      });
+      mockRegisteredInbox = { status: "none" };
+      mockSecureKeys[credentialKey("resend", "api_key")] = "stored";
+      const service = createReadinessService();
+      const [snapshot] = await service.getReadiness("email", true);
+
+      expect(snapshot.ready).toBe(true);
+      expect(snapshot.reasons).toHaveLength(0);
+    });
+
+    test("a your-own credential decides even when the platform is unreachable", async () => {
+      setConfig("ingress", {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+      });
+      mockRegisteredInbox = { status: "unavailable", detail: "HTTP 503" };
+      mockSecureKeys[credentialKey("mailgun", "api_key")] = "stored";
+      const service = createReadinessService();
+      const [snapshot] = await service.getReadiness("email", true);
+
+      expect(snapshot.ready).toBe(true);
+    });
+
+    test("unreachable platform is indeterminate, not a fault", async () => {
+      setConfig("ingress", {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+      });
+      mockRegisteredInbox = { status: "unavailable", detail: "HTTP 503" };
+      const service = createReadinessService();
+      const [snapshot] = await service.getReadiness("email", true);
+
+      // No positive confirmation, so the channel cannot report ready, but an
+      // unanswerable question is not a fault and must not be listed as one.
+      expect(snapshot.ready).toBe(false);
+      expect(snapshot.reasons.some((r) => r.code === "inbox_configured")).toBe(
+        false,
+      );
+      const remoteCheck = snapshot.remoteChecks?.find(
+        (c) => c.name === "inbox_configured",
+      );
+      expect(remoteCheck?.indeterminate).toBe(true);
+    });
+
     test("local-only readiness still passes without inbox check", async () => {
       setConfig("ingress", {
         publicBaseUrl: "https://example.com",

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

@@ -369,18 +369,33 @@ describe("ChannelReadinessService", () => {
     });
   });
 
-  test("email readiness ignores platform connectivity", async () => {
-    // Email passes `allowManagedCallbacks: false`, so the managed tiers are
-    // not offered to it and only a real ingress URL counts.
+  test("email readiness accepts a platform-connected assistant with no ingress", async () => {
+    // Inbound email arrives through the platform callback route the gateway
+    // registers (`registerEmailCallbackRoute`, the same pattern as Telegram),
+    // so a platform-connected assistant with no public ingress URL still
+    // receives email and must not report missing ingress.
     mockPlatformConnected = true;
 
     const readiness = createReadinessService();
     const [snapshot] = await readiness.getReadiness("email");
 
+    expect(snapshot.localChecks).toContainEqual({
+      name: "ingress",
+      passed: true,
+      message: "Managed platform callback routing is configured",
+    });
+  });
+
+  test("email readiness reports missing ingress when nothing can route inbound", async () => {
+    mockPlatformConnected = false;
+
+    const readiness = createReadinessService();
+    const [snapshot] = await readiness.getReadiness("email");
+
     expect(snapshot.localChecks).toContainEqual({
       name: "ingress",
       passed: false,
-      message: "Public ingress URL is not configured or disabled",
+      message: "No public ingress URL or managed callback route is configured",
     });
   });
 

package/src/__tests__/config-loader-backfill.test.ts

@@ -1564,7 +1564,7 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     );
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Cost");
+    expect(effective["cost-optimized"]?.label).toBe("Budget");
     expect("status" in (effective.balanced ?? {})).toBe(false);
     expect("status" in (effective["quality-optimized"] ?? {})).toBe(false);
     expect("status" in (effective["cost-optimized"] ?? {})).toBe(false);
@@ -1834,7 +1834,7 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     const effective = getEffectiveProfiles(raw.llm.profiles);
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Cost");
+    expect(effective["cost-optimized"]?.label).toBe("Budget");
   });
 
   test("a managed key missing from profileOrder lands beside its siblings", () => {

package/src/__tests__/credential-security-invariants.test.ts

@@ -238,6 +238,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "providers/inference/connection-availability.ts", // shared (provider, connection) availability status (credential presence check only; value never leaves the helper)
       "plugin-api/resolve-credential.ts", // plugin-facing resolveCredential: reveal-equivalent plaintext read, scoped to the in-context plugin's own service
       "tools/credentials/store.ts", // shared credential write path (setSecureKeyAsync only; no reads) behind credentials/set and plugin-facing storeCredential
+      "email/byo-email-credential.ts", // BYO email provider configuration check (credential presence only; value never leaves the helper)
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));
@@ -486,7 +487,6 @@ describe("Invariant 4: credentials only used for allowed purpose", () => {
   });
 });
 
-
 // ---------------------------------------------------------------------------
 // Invariant 6 — oauth2ClientSecret never in plaintext metadata
 // ---------------------------------------------------------------------------

package/src/__tests__/email-invite-adapter.test.ts

@@ -1,11 +1,27 @@
 /**
  * Tests for the email invite adapter.
  *
- * Verifies that the email adapter resolves the assistant's email address
- * from workspace config and falls back to `undefined` when no address
- * is configured.
+ * Verifies that the email adapter resolves the assistant's address from the
+ * shared registered-inbox reader (the platform is the only writer of managed
+ * inbox registrations) and falls back to `undefined` when no address is
+ * registered or the platform cannot be asked.
  */
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { RegisteredInboxState } from "../email/registered-inbox.js";
+
+let mockInboxState: RegisteredInboxState;
+let mockResolveThrows: boolean;
+
+mock.module("../email/registered-inbox.js", () => ({
+  resolveRegisteredInbox: async () => {
+    if (mockResolveThrows) {
+      throw new Error("resolver unavailable");
+    }
+    return mockInboxState;
+  },
+  invalidateRegisteredInboxCache: () => {},
+}));
 
 import { resolveAdapterHandle } from "../runtime/channel-invite-transport.js";
 import { emailInviteAdapter } from "../runtime/channel-invite-transports/email.js";
@@ -17,30 +33,55 @@ import { setConfig } from "./helpers/set-config.js";
 
 describe("emailInviteAdapter", () => {
   beforeEach(() => {
-    // The adapter reads the raw workspace config; reset the `email` key so
-    // each test starts without a configured address.
-    setConfig("email", {});
+    mockInboxState = { status: "none" };
+    mockResolveThrows = false;
   });
 
-  test("returns configured email address via resolveChannelHandleAsync", async () => {
-    setConfig("email", { address: "user@example.com" });
+  test("returns the registered address via resolveChannelHandleAsync", async () => {
+    mockInboxState = { status: "registered", address: "user@example.com" };
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
     expect(handle).toBe("user@example.com");
   });
 
-  test("returns undefined when no address is configured", async () => {
+  test("returns undefined when no inbox is registered", async () => {
     const handle = await resolveAdapterHandle(emailInviteAdapter);
     expect(handle).toBeUndefined();
   });
 
-  test("returns undefined when email.address is empty string", async () => {
-    setConfig("email", { address: "" });
+  test("returns undefined when the platform is not connected", async () => {
+    mockInboxState = { status: "no_platform" };
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
     expect(handle).toBeUndefined();
   });
 
+  test("returns undefined when the platform cannot be asked", async () => {
+    mockInboxState = { status: "unavailable", detail: "HTTP 503" };
+
+    const handle = await resolveAdapterHandle(emailInviteAdapter);
+    expect(handle).toBeUndefined();
+  });
+
+  test("returns undefined when the resolver throws", async () => {
+    mockResolveThrows = true;
+
+    const handle = await resolveAdapterHandle(emailInviteAdapter);
+    expect(handle).toBeUndefined();
+  });
+
+  test("a local email.address config value cannot supply the handle", async () => {
+    // Registration lives on the platform; a stray config value (a key
+    // nothing writes) must not surface as the assistant's address.
+    setConfig("email", { address: "stale@example.com" });
+    mockInboxState = { status: "none" };
+
+    const handle = await resolveAdapterHandle(emailInviteAdapter);
+    expect(handle).toBeUndefined();
+
+    setConfig("email", {});
+  });
+
   test("adapter channel is email", () => {
     expect(emailInviteAdapter.channel).toBe("email");
   });

package/src/__tests__/external-binding-chat-name.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+
+import { createConversation } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getBindingByConversation,
+  upsertBinding,
+} from "../persistence/external-conversation-store.js";
+
+await initializeDb();
+
+async function boundConversation(): Promise<string> {
+  const conversation = await createConversation({ title: "t" });
+  upsertBinding({
+    conversationId: conversation.id,
+    sourceChannel: "slack",
+    externalChatId: "C0123CHANNEL",
+    externalChatName: "user-feedback",
+  });
+  return conversation.id;
+}
+
+describe("upsertBinding chat-name preservation", () => {
+  test("a nameless upsert for the same chat keeps the stored name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123CHANNEL",
+    });
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      "user-feedback",
+    );
+  });
+
+  test("a move to a nameless chat clears the stored name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "D0MOVEDHERE",
+    });
+    const binding = getBindingByConversation(conversationId);
+    expect(binding?.externalChatId).toBe("D0MOVEDHERE");
+    expect(binding?.externalChatName ?? null).toBeNull();
+  });
+
+  test("a move that reports a name takes the new name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0ELSEWHERE",
+      externalChatName: "new-home",
+    });
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      "new-home",
+    );
+  });
+});

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -147,6 +147,34 @@ describe("guardian-verify-setup skill: proactive auto-check polling", () => {
   });
 });
 
+describe("guardian-verify-setup skill: Discord DM code wording", () => {
+  /**
+   * A plain DM containing the code completes verification; Discord's reply
+   * affordance is not required, and instructions that say "reply" made a
+   * live-QA user hesitate over whether a plain message would count.
+   */
+  const discordBullets = (body: string) =>
+    body.split("\n").filter((line) => /^\s*-\s+\*\*Discord\*\*/.test(line));
+
+  for (const [step, from, to] of [
+    ["Step 3", "## Step 3", "## Step 4"],
+    ["Step 4", "## Step 4", "## Step 5"],
+  ] as const) {
+    test(`${step}'s Discord bullets say to send the code, not reply with it`, () => {
+      const bullets = discordBullets(section(from, to));
+      expect(bullets.length).toBeGreaterThanOrEqual(1);
+      for (const bullet of bullets) {
+        expect(bullet).toContain("send that 6-digit code in this DM");
+        // The instruction forms are what misled: "reply with the code" /
+        // "reply to the DM". Prose *about* the reply feature ("reply feature
+        // is not required") is the clarification and stays.
+        expect(bullet.toLowerCase()).not.toContain("reply with");
+        expect(bullet.toLowerCase()).not.toContain("reply to the dm");
+      }
+    });
+  }
+});
+
 describe("guardian-verify-setup skill: channel coverage", () => {
   test("every channel the CLI accepts is offered in Step 1", () => {
     const step1 = section("## Step 1", "## Step 2");

package/src/__tests__/managed-profile-guard.test.ts

@@ -264,7 +264,7 @@ describe("PUT /v1/config/llm/profiles/:name — managed profile guard", () => {
   });
 
   test("PUT on the code-owned latency profile is rejected, status re-enable included", async () => {
-    // Speed fronts live voice, so it takes no writes at all: the re-enable
+    // Fast fronts live voice, so it takes no writes at all: the re-enable
     // escape hatch the other managed profiles keep would persist a stub that
     // never governs what the name resolves to.
     seedRawConfig({ llm: { profiles: {} } });

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

@@ -20,7 +20,7 @@ describe("model intents", () => {
       "claude-haiku-4-5-20251001",
     );
     expect(resolveModelIntent("anthropic", "quality-optimized")).toBe(
-      "claude-fable-5",
+      "claude-fable-5-1",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
       "claude-opus-4-6",
@@ -47,7 +47,7 @@ describe("model intents", () => {
       "anthropic/claude-haiku-4.5",
     );
     expect(resolveModelIntent("vercel-ai-gateway", "quality-optimized")).toBe(
-      "anthropic/claude-fable-5",
+      "anthropic/claude-fable-5.1",
     );
     expect(resolveModelIntent("vercel-ai-gateway", "vision-optimized")).toBe(
       "anthropic/claude-opus-4.6",

package/src/__tests__/pricing.test.ts

@@ -450,6 +450,19 @@ describe("resolvePricingForUsage", () => {
     expect(result.estimatedCostUsd).toBeCloseTo(57.4, 10);
   });
 
+  test("bills Fable 5.1 cache reads at the catalog rate", () => {
+    const result = resolvePricingForUsage("anthropic", "claude-fable-5-1", {
+      directInputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 1_000_000,
+      anthropicCacheCreation: null,
+    });
+
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBeCloseTo(0.25, 10);
+  });
+
   test("returns unpriced with null cost for unknown provider", () => {
     const usage: PricingUsage = {
       directInputTokens: 10,

package/src/__tests__/tool-approval-seed-content-blocks.test.ts

@@ -214,7 +214,7 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     );
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });
 
@@ -232,7 +232,20 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     );
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — #C01ABC",
+      value: "Slack · #C01ABC",
+    });
+  });
+
+  test("Slack channel source prefers the captured channel name", () => {
+    const payload = {
+      ...toolApprovalPayload,
+      sourceChatId: "C01ABC",
+      sourceChatName: "user-feedback",
+    };
+    const surface = surfaceBlock(buildToolApprovalSeedContentBlocks(payload)!);
+    expect(surface.data.metadata).toContainEqual({
+      label: "Source",
+      value: "Slack · #user-feedback",
     });
   });
 
@@ -245,7 +258,7 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     expect(surface.data.body).not.toContain("[View message]");
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });