@vellumai/assistant 0.11.8-staging.1 → 0.11.8

package/src/messaging/providers/slack/approval-source.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, mock, test } from "bun:test";
+
+// Spread the actual modules so transitive importers of names these
+// factories do not stub keep resolving (a partial factory breaks at
+// import time when the graph gains a new named import).
+const actualDeliveryCrud =
+  await import("../../../persistence/delivery-crud.js");
+const actualBindingStore =
+  await import("../../../persistence/external-conversation-store.js");
+
+let bindingRow: {
+  sourceChannel: string;
+  externalChatId: string;
+  externalChatName: string | null;
+  conversationId: string;
+} | null = null;
+
+mock.module("../../../persistence/delivery-crud.js", () => ({
+  ...actualDeliveryCrud,
+  getLatestInboundEventReference: () => null,
+}));
+
+mock.module("../../../persistence/external-conversation-store.js", () => ({
+  ...actualBindingStore,
+  getBindingByConversation: () => bindingRow,
+}));
+
+const { resolveSlackApprovalSource } = await import("./approval-source.js");
+
+const HINT = {
+  requesterChatId: "C0123CHANNEL",
+  sourceMessageId: "1700000000.000100",
+};
+
+describe("resolveSlackApprovalSource chat names", () => {
+  test("the binding's chat name rides the reference", () => {
+    bindingRow = {
+      sourceChannel: "slack",
+      externalChatId: "C0123CHANNEL",
+      externalChatName: "user-feedback",
+      conversationId: "conv-1",
+    };
+    const reference = resolveSlackApprovalSource("conv-1", HINT);
+    expect(reference?.sourceChatId).toBe("C0123CHANNEL");
+    expect(reference?.sourceChatName).toBe("user-feedback");
+  });
+
+  test("a binding for a different chat never lends its name", () => {
+    bindingRow = {
+      sourceChannel: "slack",
+      externalChatId: "C0OTHER",
+      externalChatName: "somewhere-else",
+      conversationId: "conv-1",
+    };
+    const reference = resolveSlackApprovalSource("conv-1", HINT);
+    expect(reference?.sourceChatId).toBe("C0123CHANNEL");
+    expect(reference?.sourceChatName).toBeUndefined();
+  });
+
+  test("an unnamed binding leaves the reference nameless", () => {
+    bindingRow = {
+      sourceChannel: "slack",
+      externalChatId: "C0123CHANNEL",
+      externalChatName: null,
+      conversationId: "conv-1",
+    };
+    const reference = resolveSlackApprovalSource("conv-1", HINT);
+    expect(reference?.sourceChatName).toBeUndefined();
+  });
+});

package/src/messaging/providers/slack/approval-source.ts

@@ -26,16 +26,19 @@ import { isSlackTs } from "./message-metadata.js";
 
 function toReference(
   chatId: string,
+  chatName: string | null,
   messageTs: string | undefined,
   threadTs: string | undefined,
 ): ApprovalSourceReference {
+  const named = chatName ? { sourceChatName: chatName } : {};
   // Without a message ts, the thread root is still a valid anchor.
   const anchorTs = messageTs ?? threadTs;
   if (!anchorTs) {
-    return { sourceChatId: chatId };
+    return { sourceChatId: chatId, ...named };
   }
   return {
     sourceChatId: chatId,
+    ...named,
     sourceLink: {
       webUrl: buildSlackPermalink({
         channelId: chatId,
@@ -50,20 +53,30 @@ export function resolveSlackApprovalSource(
   conversationId: string,
   hint: ApprovalSourceHint | undefined,
 ): ApprovalSourceReference | null {
+  const rawBinding = getBindingByConversation(conversationId);
+  const binding = rawBinding?.sourceChannel === "slack" ? rawBinding : null;
+
+  // The chat's display name lives on the binding row, which ingress
+  // upserts from every inbound message. Matched by chat id so a binding
+  // that moved to another chat never lends its name.
+  const chatNameFor = (chatId: string): string | null =>
+    binding?.externalChatId === chatId
+      ? binding.externalChatName?.trim() || null
+      : null;
+
   // Exact provenance from the turn's trust context. An absent thread id here
   // is authoritative (the message arrived at the chat root), so no binding
-  // lookup is needed.
+  // lookup is needed for the reference itself.
   if (hint?.requesterChatId && isSlackTs(hint.sourceMessageId)) {
     return toReference(
       hint.requesterChatId,
+      chatNameFor(hint.requesterChatId),
       hint.sourceMessageId,
       isSlackTs(hint.sourceThreadId) ? hint.sourceThreadId : undefined,
     );
   }
 
   const inbound = getLatestInboundEventReference(conversationId, "slack");
-  const rawBinding = getBindingByConversation(conversationId);
-  const binding = rawBinding?.sourceChannel === "slack" ? rawBinding : null;
 
   const chatId =
     hint?.requesterChatId ?? inbound?.externalChatId ?? binding?.externalChatId;
@@ -83,5 +96,5 @@ export function resolveSlackApprovalSource(
     ? binding.externalThreadId
     : undefined;
 
-  return toReference(chatId, messageTs, threadTs);
+  return toReference(chatId, chatNameFor(chatId), messageTs, threadTs);
 }

package/src/notifications/__tests__/guardian-feed-projection.test.ts

@@ -48,7 +48,7 @@ const {
 } = await import("../guardian-feed-projection.js");
 const { appendFeedItem, bulkSetFeedItemStatus, getHomeFeedPath, readHomeFeed } =
   await import("../../home/feed-writer.js");
-const { isPendingGuardianFeedItem } =
+const { GUARDIAN_TERMINAL_REASON_SUPERSEDED, isPendingGuardianFeedItem } =
   await import("../../api/responses/home.js");
 type FeedItem = import("../../api/responses/home.js").FeedItem;
 
@@ -115,7 +115,7 @@ describe("buildPendingGuardianProjection", () => {
       requesterLabel: "Alice",
       toolName: "linear_graphql",
       sourceChannel: "slack",
-      sourceContextLabel: "Slack #C0123456789",
+      sourceContextLabel: "#C0123456789",
     });
   });
 
@@ -130,14 +130,12 @@ describe("buildPendingGuardianProjection", () => {
     expect(projection?.status).toBe("pending");
   });
 
-  test("a sent Slack delivery yields the card deep link", () => {
-    const projection = buildPendingGuardianProjection(toolApprovalPayload, {
-      channel: "slack",
-      destination: "D0AAAAAAAAA",
-      status: "sent",
-      messageId: "1725100000.000100",
+  test("a captured channel name becomes the source context label", () => {
+    const projection = buildPendingGuardianProjection({
+      ...toolApprovalPayload,
+      sourceChatName: "user-feedback",
     });
-    expect(projection?.slackCardUrl).toContain("D0AAAAAAAAA");
+    expect(projection?.sourceContextLabel).toBe("#user-feedback");
   });
 
   test("a payload without a requestId projects nothing", () => {
@@ -154,7 +152,6 @@ describe("buildPendingGuardianProjection", () => {
         sourceChannel: "telegram",
         senderIdentifier: "Alice",
       },
-      undefined,
       "access_request",
     );
     expect(projection).toMatchObject({
@@ -250,19 +247,21 @@ describe("writeGuardianFeedReceipt", () => {
     expect(item && isPendingGuardianFeedItem(item)).toBe(false);
   });
 
-  test("a superseded auto-deny carries its reason and no decider", async () => {
+  test("a superseded auto-deny carries its reason", async () => {
     await appendFeedItem(pendingGuardianItem("req-4"));
     await writeGuardianFeedReceipt({
       requestId: "req-4",
       status: "denied",
       decidedAction: "reject",
-      terminalReason: "superseded",
+      terminalReason: GUARDIAN_TERMINAL_REASON_SUPERSEDED,
     });
     const item = readHomeFeed().items.find(
       (i) => i.id === guardianFeedItemId("req-4"),
     );
-    expect(item?.guardianRequest?.terminalReason).toBe("superseded");
-    expect(item?.guardianRequest?.decidedByLabel).toBeUndefined();
+    expect(item?.guardianRequest?.terminalReason).toBe(
+      GUARDIAN_TERMINAL_REASON_SUPERSEDED,
+    );
+    expect(item?.guardianRequest?.status).toBe("denied");
   });
 
   test("a request with no item resolves true (nothing to retry)", async () => {

package/src/notifications/approval-card-data.ts

@@ -31,6 +31,7 @@ import {
   buildGuardianRequestCodeInstruction,
   buildQuestionDeliveryText,
   buildToolApprovalSourceView,
+  describeSlackChatLabel,
   type GuardianQuestionPayload,
   type LenientToolApprovalPayload,
   LenientToolApprovalPayloadSchema,
@@ -151,12 +152,17 @@ function sourceMetadataRow(
   channel: string | undefined,
   slackChatId: string | undefined,
   isSlackDm: boolean,
+  chatName?: string,
 ): { label: string; value: string } | undefined {
-  if (channel === "slack" && slackChatId) {
-    return {
-      label: "Source",
-      value: isSlackDm ? "Slack — Direct message" : `Slack — #${slackChatId}`,
-    };
+  if (channel === "slack") {
+    const chat = describeSlackChatLabel({
+      chatId: slackChatId,
+      chatName,
+      isSlackDm,
+    });
+    if (chat) {
+      return { label: "Source", value: `Slack · ${chat}` };
+    }
   }
   if (channel) {
     return { label: "Source", value: channel };
@@ -298,6 +304,7 @@ function extractToolApprovalCard(
     nonEmpty(p.sourceChannel),
     sourceView?.chatId,
     sourceView?.isSlackDm ?? false,
+    sourceView?.chatName,
   );
   if (sourceRow) {
     metadata.push(sourceRow);
@@ -364,6 +371,7 @@ function extractQuestionCard(
     nonEmpty(p.sourceChannel),
     sourceView?.chatId,
     sourceView?.isSlackDm ?? false,
+    sourceView?.chatName,
   );
   if (sourceRow) {
     metadata.push(sourceRow);

package/src/notifications/emit-signal.ts

@@ -547,14 +547,11 @@ export async function emitNotificationSignal<TEventName extends string>(
     const vellumDelivery = dispatchResult.deliveryResults.find(
       (r) => r.channel === "vellum",
     );
-    await writeHomeFeedItemForSignal(
-      signal,
-      decision,
-      vellumDelivery,
-      dispatchResult.deliveryResults,
-    ).catch((err) => {
-      log.warn({ err, signalId }, "writeHomeFeedItemForSignal threw");
-    });
+    await writeHomeFeedItemForSignal(signal, decision, vellumDelivery).catch(
+      (err) => {
+        log.warn({ err, signalId }, "writeHomeFeedItemForSignal threw");
+      },
+    );
 
     log.info(
       {

package/src/notifications/guardian-feed-projection.ts

@@ -28,27 +28,22 @@ import {
   type GuardianRequestWire,
   listGuardianRequests,
 } from "../channels/gateway-guardian-requests.js";
-import { getConfig } from "../config/loader.js";
 import {
   appendFeedItem,
   patchFeedItemContent,
   readHomeFeed,
 } from "../home/feed-writer.js";
-import { buildSlackMessageDeepLinks } from "../messaging/providers/slack/deep-link.js";
-import {
-  DEFAULT_USER_REFERENCE,
-  resolveGuardianName,
-} from "../prompts/user-reference.js";
 import { getLogger } from "../util/logger.js";
 import {
   buildToolApprovalSourceView,
+  describeSlackChatLabel,
   type GuardianQuestionRequestKind,
   LenientToolApprovalPayloadSchema,
   resolveGuardianInstructionModeFromFields,
   resolveGuardianQuestionInstructionMode,
+  type ToolApprovalSourceView,
 } from "./guardian-question-mode.js";
 import { readPayloadString } from "./notification-utils.js";
-import type { NotificationDeliveryResult } from "./types.js";
 
 const log = getLogger("guardian-feed-projection");
 
@@ -90,29 +85,13 @@ export function requestIdFromGuardianFeedItemId(itemId: string): string | null {
     : null;
 }
 
-/**
- * Guardian display name for receipt copy, or undefined when only the
- * prompt-voice fallback ("my human") is available. A receipt with no
- * decider label renders as the bare status word.
- */
-function guardianReceiptName(): string | undefined {
-  const name = resolveGuardianName();
-  return name === DEFAULT_USER_REFERENCE ? undefined : name;
-}
-
 /**
  * Build the pending `guardianRequest` projection for a `guardian.question`
  * signal's feed item. Returns null when the payload does not carry the
  * request id the projection is keyed by.
- *
- * `slackDelivery` is the signal's Slack delivery outcome, when one
- * shipped: its destination chat + message ts locate the guardian-DM
- * approval card, and the derived deep links are what the client's
- * "Open in Slack" affordance opens.
  */
 export function buildPendingGuardianProjection(
   contextPayload: unknown,
-  slackDelivery?: NotificationDeliveryResult,
   fallbackKind?: GuardianQuestionRequestKind,
 ): FeedItemGuardianRequest | null {
   // Access-request payloads predate the kind registry and carry no
@@ -140,7 +119,6 @@ export function buildPendingGuardianProjection(
   );
 
   const sourceView = buildToolApprovalSourceView(payload);
-  const slackLinks = buildSlackCardLinks(slackDelivery);
   // Access-request payloads name their requester differently.
   const requesterLabel =
     payload.requesterIdentifier?.trim() ||
@@ -159,8 +137,6 @@ export function buildPendingGuardianProjection(
       ? { sourceContextLabel: describeApprovalSourceContext(sourceView) }
       : {}),
     ...(sourceView?.permalink ? { sourceUrl: sourceView.permalink } : {}),
-    ...(slackLinks?.webUrl ? { slackCardUrl: slackLinks.webUrl } : {}),
-    ...(slackLinks?.appUrl ? { slackCardAppUrl: slackLinks.appUrl } : {}),
   };
 }
 
@@ -177,43 +153,18 @@ function intentFromInstructionMode(
 }
 
 /**
- * Display label for the originating chat, mirroring the wording the
- * in-app approval card's source row uses (`sourceMetadataRow` in
- * `approval-card-data.ts`): Slack chats are named, other channels fall
- * back to the channel id.
+ * Display label for the originating chat: the bare chat label from the
+ * shared derivation (the bell's context line joins it with the tool, so
+ * the channel word would be noise), or the channel id for channels the
+ * view carries no chat facts for.
  */
-function describeApprovalSourceContext(view: {
-  channel: string;
-  chatId?: string | null;
-  isSlackDm: boolean;
-}): string {
-  if (view.channel === "slack" && view.chatId) {
-    return view.isSlackDm ? "Slack direct message" : `Slack #${view.chatId}`;
+function describeApprovalSourceContext(view: ToolApprovalSourceView): string {
+  if (view.channel === "slack") {
+    return describeSlackChatLabel(view) || view.channel;
   }
   return view.channel;
 }
 
-/** Deep links to the Slack guardian-DM approval card, when one shipped. */
-function buildSlackCardLinks(
-  slackDelivery?: NotificationDeliveryResult,
-): { appUrl?: string; webUrl?: string } | undefined {
-  if (
-    !slackDelivery ||
-    slackDelivery.status !== "sent" ||
-    !slackDelivery.destination ||
-    !slackDelivery.messageId
-  ) {
-    return undefined;
-  }
-  const slackConfig = getConfig().slack;
-  return buildSlackMessageDeepLinks({
-    teamId: slackConfig?.teamId,
-    teamUrl: slackConfig?.teamUrl,
-    channelId: slackDelivery.destination,
-    messageTs: slackDelivery.messageId,
-  });
-}
-
 export interface GuardianFeedReceiptParams {
   requestId: string;
   status: GuardianRequestStatus;
@@ -267,13 +218,6 @@ export async function writeGuardianFeedReceipt(
         ...(params.decidedAction
           ? { decidedAction: params.decidedAction }
           : {}),
-        // A decider label only when a person decided: a non-decision
-        // terminal (superseded, expired) must not read as the guardian's
-        // own rejection.
-        ...((params.status === "approved" || params.status === "denied") &&
-        !params.terminalReason
-          ? decidedByLabelPatch()
-          : {}),
         decidedAt: new Date(params.decidedAtMs ?? Date.now()).toISOString(),
         ...(params.terminalReason
           ? { terminalReason: params.terminalReason }
@@ -297,15 +241,6 @@ export async function writeGuardianFeedReceipt(
   }
 }
 
-/** `{ decidedByLabel }` when a real display name exists, `{}` otherwise. */
-function decidedByLabelPatch(): Pick<
-  Partial<FeedItemGuardianRequest>,
-  "decidedByLabel"
-> {
-  const name = guardianReceiptName();
-  return name === undefined ? {} : { decidedByLabel: name };
-}
-
 /**
  * Rewrite a request's feed item into its receipt when the canonical row
  * is already terminal. Converges the write-vs-resolve race from the

package/src/notifications/guardian-question-mode.ts

@@ -99,6 +99,8 @@ export const PendingQuestionPayloadSchema =
 const sourceReferenceFields = {
   /** Channel-native chat/conversation id the request originated from. */
   sourceChatId: z.string().optional(),
+  /** Display name of the originating chat, when ingress captured one. */
+  sourceChatName: z.string().optional(),
   /** Deep link to the originating message/thread, when derivable. */
   sourceLink: externalSourceLinkSchema.optional(),
 };
@@ -162,6 +164,7 @@ export const LenientToolApprovalPayloadSchema = z.object({
   riskLevel: z.string().nullable().optional(),
   commandPreview: z.string().nullable().optional(),
   sourceChatId: z.string().nullable().optional(),
+  sourceChatName: z.string().nullable().optional(),
   sourceLink: sourceReferenceFields.sourceLink.nullable(),
 });
 
@@ -190,6 +193,8 @@ export const ToolApprovalSourceViewSchema = z.object({
   channel: z.string(),
   /** Channel-native chat id, when the payload carries one. */
   chatId: z.string().optional(),
+  /** Display name of the originating chat, when ingress captured one. */
+  chatName: z.string().optional(),
   /** Whether the source chat is a Slack direct message (`false` for other channels). */
   isSlackDm: z.boolean(),
   /** Link to the originating message/thread, when derivable. */
@@ -205,10 +210,36 @@ export type ToolApprovalSourceView = z.infer<
  * facts. Returns `undefined` when the payload names no chat and carries no
  * link — renderers then fall back to the plain channel label.
  */
+/**
+ * Bare display label for the source chat, derived once for every
+ * renderer: `Direct message` for a DM, `#name` for a named channel,
+ * `#<id>` when only the id is known, empty when the view names no chat.
+ * Slack-scoped like the facts it reads; surfaces add their own framing
+ * (the card prefixes the channel word, the bell uses it bare).
+ */
+export function describeSlackChatLabel(
+  view: Pick<ToolApprovalSourceView, "chatId" | "chatName" | "isSlackDm">,
+): string {
+  if (view.isSlackDm) {
+    return "Direct message";
+  }
+  if (view.chatName) {
+    return `#${view.chatName}`;
+  }
+  if (view.chatId) {
+    return `#${view.chatId}`;
+  }
+  return "";
+}
+
 export function buildToolApprovalSourceView(
   p: Pick<
     LenientToolApprovalPayload,
-    "sourceChannel" | "sourceChatId" | "sourceLink" | "requesterChatId"
+    | "sourceChannel"
+    | "sourceChatId"
+    | "sourceChatName"
+    | "sourceLink"
+    | "requesterChatId"
   >,
 ): ToolApprovalSourceView | undefined {
   const channel = nonEmpty(p.sourceChannel);
@@ -225,6 +256,7 @@ export function buildToolApprovalSourceView(
   return {
     channel,
     chatId,
+    chatName: nonEmpty(p.sourceChatName),
     isSlackDm:
       channel === "slack" && chatId != null && isSlackDmConversation(chatId),
     permalink,

package/src/notifications/home-feed-side-effect.ts

@@ -85,7 +85,6 @@ export async function writeHomeFeedItemForSignal(
   signal: NotificationSignal,
   decision: NotificationDecision,
   vellumDelivery?: NotificationDeliveryResult,
-  deliveryResults?: NotificationDeliveryResult[],
 ): Promise<FeedItem | null> {
   const { mirror, sourceConversationId, sourceScheduleJobId } =
     resolveHomeFeedMirror(signal, vellumDelivery?.conversationId);
@@ -178,9 +177,6 @@ export async function writeHomeFeedItemForSignal(
   )
     ? buildPendingGuardianProjection(
         signal.contextPayload,
-        deliveryResults?.find(
-          (r) => r.channel === "slack" && r.status === "sent",
-        ),
         signal.sourceEventName === "ingress.access_request"
           ? "access_request"
           : undefined,

package/src/persistence/external-conversation-store.ts

@@ -113,9 +113,13 @@ export function upsertBinding(input: UpsertBindingInput): void {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        // An absent chat name preserves the stored one only while the
+        // binding still addresses the same chat; a move to a chat that
+        // reported no name clears it, so the old chat's name can never
+        // label the new one.
         externalChatName:
           externalChatName ??
-          sql`${externalConversationBindings.externalChatName}`,
+          sql`CASE WHEN ${externalConversationBindings.sourceChannel} = ${input.sourceChannel} AND ${externalConversationBindings.externalChatId} = ${input.externalChatId} THEN ${externalConversationBindings.externalChatName} ELSE NULL END`,
         externalThreadId,
         // An omitted sender field keeps what is stored; an explicit value,
         // including null, replaces it. A caller that knows only the chat

package/src/providers/anthropic/client.ts

@@ -1056,7 +1056,7 @@ export class AnthropicProvider implements Provider {
         /claude-opus-4-[78]\b/.test(effectiveModel) ||
         /claude-opus-5\b/.test(effectiveModel) ||
         /claude-sonnet-5\b/.test(effectiveModel) ||
-        effectiveModel.startsWith("claude-fable-");
+        /claude-fable-/.test(effectiveModel);
       const mergedOutputConfig = {
         ...(output_config ?? {}),
         ...(effort && effort !== "none" && supportsEffort

package/src/providers/model-catalog.ts

@@ -193,6 +193,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Anthropic Console",
     },
     models: [
+      {
+        id: "claude-fable-5-1",
+        displayName: "Claude Fable 5.1",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 10,
+          outputPer1mTokens: 50,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 0.25,
+        },
+      },
       {
         id: "claude-fable-5",
         displayName: "Claude Fable 5",
@@ -1086,6 +1104,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // OpenRouter proxies anthropic/* through Anthropic's Messages API, so
       // prompt caching and cache TTL metadata pass through unchanged and
       // billing matches Anthropic's direct rates.
+      {
+        id: "anthropic/claude-fable-5.1",
+        displayName: "Claude Fable 5.1",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 10,
+          outputPer1mTokens: 50,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 0.25,
+        },
+      },
       {
         id: "anthropic/claude-fable-5",
         displayName: "Claude Fable 5",
@@ -1934,6 +1970,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // The gateway proxies anthropic/* through Anthropic's Messages API, so
       // prompt caching and cache TTL metadata pass through unchanged and
       // billing matches Anthropic's direct rates.
+      {
+        id: "anthropic/claude-fable-5.1",
+        displayName: "Claude Fable 5.1",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 10,
+          outputPer1mTokens: 50,
+          cacheWritePer1mTokens: 12.5,
+          cacheReadPer1mTokens: 0.25,
+        },
+      },
       {
         id: "anthropic/claude-fable-5",
         displayName: "Claude Fable 5",

package/src/providers/model-intents.ts

@@ -20,7 +20,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     balanced: "claude-sonnet-4-6",
     "cost-optimized": "claude-haiku-4-5-20251001",
     "latency-optimized": "claude-haiku-4-5-20251001",
-    "quality-optimized": "claude-fable-5",
+    "quality-optimized": "claude-fable-5-1",
     "vision-optimized": "claude-opus-4-6",
   },
   openai: {
@@ -55,14 +55,14 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     balanced: "anthropic/claude-sonnet-4.6",
     "cost-optimized": "deepseek/deepseek-v4-flash",
     "latency-optimized": "anthropic/claude-haiku-4.5",
-    "quality-optimized": "anthropic/claude-fable-5",
+    "quality-optimized": "anthropic/claude-fable-5.1",
     "vision-optimized": "anthropic/claude-opus-4.6",
   },
   "vercel-ai-gateway": {
     balanced: "anthropic/claude-sonnet-4.6",
     "cost-optimized": "deepseek/deepseek-v4-flash",
     "latency-optimized": "anthropic/claude-haiku-4.5",
-    "quality-optimized": "anthropic/claude-fable-5",
+    "quality-optimized": "anthropic/claude-fable-5.1",
     "vision-optimized": "anthropic/claude-opus-4.6",
   },
 };

package/src/runtime/approval-source-link.ts

@@ -45,6 +45,12 @@ const log = getLogger("approval-source-link");
 export interface ApprovalSourceReference {
   /** Channel-native chat/conversation id the request originated from. */
   sourceChatId: string;
+  /**
+   * Display name of the originating chat, when ingress captured one (a
+   * Slack channel's name, without the `#`). Renderers prefer it over the
+   * raw chat id and fall back when absent (DMs, pre-capture rows).
+   */
+  sourceChatName?: string;
   /** Deep link to the originating message/thread, when derivable. */
   sourceLink?: ExternalSourceLink;
 }