@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -12,9 +12,14 @@ import { findGuardianForChannel } from "../../../contacts/contact-store.js";
 import type { ServerMessage } from "../../../daemon/message-protocol.js";
 import type { TrustContext } from "../../../daemon/trust-context.js";
 import { updateDeliveredSegmentCount } from "../../../memory/delivery-channels.js";
-import { linkMessage } from "../../../memory/delivery-crud.js";
 import {
+  linkMessage,
+  storeReplyMessageId,
+} from "../../../memory/delivery-crud.js";
+import {
+  markDeliveryDelivered,
   markProcessed,
+  recordDeliveryFailure,
   recordProcessingFailure,
 } from "../../../memory/delivery-status.js";
 import {
@@ -76,7 +81,6 @@ export interface BackgroundProcessingParams {
   externalChatId: string;
   trustCtx: TrustContext;
   metadataHints: string[];
-  slackRuntimeContextNotice?: string;
   metadataUxBrief?: string;
   replyCallbackUrl?: string;
   assistantId?: string;
@@ -85,6 +89,8 @@ export interface BackgroundProcessingParams {
   sourceLanguageCode?: string;
   /** Chat type from the gateway (e.g. "private", "group", "supergroup"). */
   chatType?: string;
+  /** IANA timezone reported by the active client for the current turn. */
+  clientTimezone?: string;
   /** Slack app_mention/direct bot mention signal from the gateway. */
   slackBotMentioned?: boolean;
   /**
@@ -114,7 +120,6 @@ export function processChannelMessageInBackground(
     externalChatId,
     trustCtx,
     metadataHints,
-    slackRuntimeContextNotice,
     metadataUxBrief,
     replyCallbackUrl,
     assistantId,
@@ -122,6 +127,7 @@ export function processChannelMessageInBackground(
     commandIntent,
     sourceLanguageCode,
     chatType,
+    clientTimezone,
     slackBotMentioned,
     slackInbound,
   } = params;
@@ -190,8 +196,10 @@ export function processChannelMessageInBackground(
     // rejected as already-processing and our update would erase that
     // in-flight turn's mapping. Snapshot the prior state here and restore
     // it in the `already processing` rejection path below.
-    let priorSlackMapping: { threadTs: string; channelId: string } | null =
-      null;
+    let priorSlackMapping: {
+      threadTs: string;
+      channelId: string;
+    } | null = null;
     let slackMappingMutated = false;
     if (sourceChannel === "slack" && replyCallbackUrl) {
       priorSlackMapping = peekThreadMapping(conversationId);
@@ -219,76 +227,103 @@ export function processChannelMessageInBackground(
                 : {}),
             }
           : undefined;
-      const { messageId: userMessageId } = await processMessage(
-        conversationId,
-        content,
-        attachmentIds,
-        {
-          transport: {
-            channelId: sourceChannel,
-            hints: metadataHints.length > 0 ? metadataHints : undefined,
-            uxBrief: metadataUxBrief,
-            chatType,
-          },
-          assistantId,
-          trustContext: trustCtx,
-          isInteractive: resolveRoutingState(trustCtx).promptWaitingAllowed,
-          ...(displayContent !== undefined ? { displayContent } : {}),
-          ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
-          ...(slackRuntimeContextNotice ? { slackRuntimeContextNotice } : {}),
-          ...(slackInbound ? { slackInbound } : {}),
-          ...(slackThinkingStatus
-            ? {
-                onEvent: (msg: ServerMessage) =>
-                  slackThinkingStatus.observeEvent(msg),
-              }
-            : {}),
-        },
-        sourceChannel,
-        sourceInterface,
-      );
-      linkMessage(eventId, userMessageId);
-      markProcessed(eventId);
+      let replyMessageId: string | undefined;
+      const observeAgentEvent = (msg: ServerMessage): void => {
+        if (
+          msg.type === "message_complete" &&
+          (msg.source === undefined || msg.source === "main") &&
+          typeof msg.messageId === "string"
+        ) {
+          replyMessageId = msg.messageId;
+        }
+        slackThinkingStatus?.observeEvent(msg);
+      };
 
-      if (replyCallbackUrl) {
-        await deliverReplyViaCallback(
+      let userMessageId: string | undefined;
+      try {
+        const result = await processMessage(
           conversationId,
-          externalChatId,
-          replyCallbackUrl,
-          assistantId,
+          content,
+          attachmentIds,
           {
-            onSegmentDelivered: (count) =>
-              updateDeliveredSegmentCount(eventId, count),
+            transport: {
+              channelId: sourceChannel,
+              hints: metadataHints.length > 0 ? metadataHints : undefined,
+              uxBrief: metadataUxBrief,
+              chatType,
+              ...(clientTimezone ? { clientTimezone } : {}),
+            },
+            assistantId,
+            trustContext: trustCtx,
+            isInteractive: resolveRoutingState(trustCtx).promptWaitingAllowed,
+            ...(displayContent !== undefined ? { displayContent } : {}),
+            ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
+            ...(slackInbound ? { slackInbound } : {}),
+            onEvent: observeAgentEvent,
           },
+          sourceChannel,
+          sourceInterface,
+        );
+        userMessageId = result.messageId;
+        linkMessage(eventId, userMessageId);
+        markProcessed(eventId);
+        replyMessageId ??= result.assistantMessageId;
+        if (replyMessageId) {
+          storeReplyMessageId(eventId, replyMessageId);
+        }
+      } catch (err) {
+        // When another turn is already processing this conversation,
+        // `prepareConversationForMessage` throws before any of this turn's
+        // work runs. Our pre-await mapping update would otherwise stomp the
+        // in-flight turn's mapping, causing its outbound persistence to
+        // record `slackMeta` with the wrong (or missing) `threadTs`. Restore
+        // the snapshot so the in-flight turn sees the mapping it installed.
+        if (
+          slackMappingMutated &&
+          err instanceof Error &&
+          err.message.includes("already processing a message")
+        ) {
+          if (priorSlackMapping) {
+            setThreadTs(
+              conversationId,
+              priorSlackMapping.channelId,
+              priorSlackMapping.threadTs,
+            );
+          } else {
+            clearThreadTs(conversationId);
+          }
+        }
+        log.error(
+          { err, conversationId },
+          "Background channel message processing failed",
         );
+        recordProcessingFailure(eventId, err);
+        return;
       }
-    } catch (err) {
-      // When another turn is already processing this conversation,
-      // `prepareConversationForMessage` throws before any of this turn's
-      // work runs. Our pre-await mapping update would otherwise stomp the
-      // in-flight turn's mapping, causing its outbound persistence to
-      // record `slackMeta` with the wrong (or missing) `threadTs`. Restore
-      // the snapshot so the in-flight turn sees the mapping it installed.
-      if (
-        slackMappingMutated &&
-        err instanceof Error &&
-        err.message.includes("already processing a message")
-      ) {
-        if (priorSlackMapping) {
-          setThreadTs(
+
+      if (replyCallbackUrl) {
+        try {
+          await deliverReplyViaCallback(
             conversationId,
-            priorSlackMapping.channelId,
-            priorSlackMapping.threadTs,
+            externalChatId,
+            replyCallbackUrl,
+            assistantId,
+            {
+              messageId: replyMessageId,
+              sinceMessageId: userMessageId,
+              onSegmentDelivered: (count) =>
+                updateDeliveredSegmentCount(eventId, count),
+            },
+          );
+          markDeliveryDelivered(eventId);
+        } catch (err) {
+          log.error(
+            { err, conversationId },
+            "Background channel reply delivery failed",
           );
-        } else {
-          clearThreadTs(conversationId);
+          recordDeliveryFailure(eventId, err);
         }
       }
-      log.error(
-        { err, conversationId },
-        "Background channel message processing failed",
-      );
-      recordProcessingFailure(eventId, err);
     } finally {
       stopTypingHeartbeat?.();
       slackThinkingStatus?.stop();
@@ -363,6 +398,20 @@ type SlackThinkingStatusController = {
   stop: () => void;
 };
 
+type SlackThinkingStatusHandle = {
+  updateLoadingMessages: (loadingMessages?: string[]) => void;
+  clear: () => void;
+};
+
+type TaskProgressStep = {
+  label: string;
+  status: "pending" | "in_progress" | "completed" | "failed";
+};
+
+type TaskProgressData = {
+  steps: TaskProgressStep[];
+};
+
 const NO_RESPONSE_RE = /^\s*<no_response\s*\/?>\s*$/i;
 const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
 const NO_RESPONSE_SENTINEL_FORMS = [
@@ -431,16 +480,51 @@ function createSlackThinkingStatusController(params: {
   const callbackUrl = replyCallbackUrl;
 
   let stopped = false;
-  let clearSlackThinkingStatus: (() => void) | undefined;
+  let slackThinkingStatus: SlackThinkingStatusHandle | undefined;
   let observedAssistantText = "";
+  let currentLoadingMessages: string[] | undefined = startImmediately
+    ? [...SLACK_GENERIC_LOADING_MESSAGES]
+    : undefined;
+  let lastSentLoadingMessageKey: string | undefined;
+  const taskProgressBySurfaceId = new Map<string, TaskProgressData>();
 
   const start = (): void => {
-    if (stopped || clearSlackThinkingStatus) return;
-    clearSlackThinkingStatus = setSlackThinkingStatus(
+    if (stopped || slackThinkingStatus) return;
+    slackThinkingStatus = setSlackThinkingStatus(
       callbackUrl,
       chatId,
       assistantId,
+      currentLoadingMessages,
     );
+    lastSentLoadingMessageKey = getLoadingMessagesKey(currentLoadingMessages);
+  };
+
+  const maybeUpdateLoadingMessages = (): void => {
+    const nextLoadingMessageKey = getLoadingMessagesKey(currentLoadingMessages);
+    if (nextLoadingMessageKey === lastSentLoadingMessageKey) return;
+    lastSentLoadingMessageKey = nextLoadingMessageKey;
+    slackThinkingStatus?.updateLoadingMessages(currentLoadingMessages);
+  };
+
+  const observeTaskProgress = (msg: ServerMessage): void => {
+    if (msg.type === "ui_surface_show") {
+      const progress = getTaskProgressDataFromSurfaceData(msg.data);
+      if (!progress) return;
+      taskProgressBySurfaceId.set(msg.surfaceId, progress);
+    } else if (msg.type === "ui_surface_update") {
+      const existing = taskProgressBySurfaceId.get(msg.surfaceId);
+      const progress = mergeTaskProgressData(existing, msg.data);
+      if (!progress) return;
+      taskProgressBySurfaceId.set(msg.surfaceId, progress);
+    } else {
+      return;
+    }
+
+    currentLoadingMessages =
+      getTaskProgressLoadingMessage(
+        taskProgressBySurfaceId.get(msg.surfaceId),
+      ) ?? [];
+    maybeUpdateLoadingMessages();
   };
 
   if (startImmediately) {
@@ -449,8 +533,14 @@ function createSlackThinkingStatusController(params: {
 
   return {
     observeEvent(msg) {
-      if (stopped || clearSlackThinkingStatus) return;
-      if (msg.type !== "assistant_text_delta") return;
+      if (stopped) return;
+
+      if (msg.type === "ui_surface_show" || msg.type === "ui_surface_update") {
+        observeTaskProgress(msg);
+        return;
+      }
+
+      if (slackThinkingStatus || msg.type !== "assistant_text_delta") return;
 
       observedAssistantText += msg.text;
       if (shouldStartSlackThinkingStatusForText(observedAssistantText)) {
@@ -459,16 +549,91 @@ function createSlackThinkingStatusController(params: {
     },
     stop() {
       stopped = true;
-      clearSlackThinkingStatus?.();
+      slackThinkingStatus?.clear();
     },
   };
 }
 
 const SLACK_THINKING_MAX_DURATION_MS = 120_000;
+const SLACK_GENERIC_LOADING_MESSAGES = ["Working on it..."] as const;
+const SLACK_THINKING_STATUSES = ["is on it", "is working hard"] as const;
+
+function getRandomSlackThinkingStatus(): string {
+  return SLACK_THINKING_STATUSES[
+    Math.floor(Math.random() * SLACK_THINKING_STATUSES.length)
+  ]!;
+}
+
+function getLoadingMessagesKey(loadingMessages?: string[]): string | undefined {
+  return loadingMessages?.join("\n");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getTaskProgressDataFromSurfaceData(
+  data: unknown,
+): TaskProgressData | undefined {
+  if (!isRecord(data)) return undefined;
+  if (data.template !== "task_progress") return undefined;
+  return parseTaskProgressData(data.templateData);
+}
+
+function parseTaskProgressData(value: unknown): TaskProgressData | undefined {
+  if (!isRecord(value) || !Array.isArray(value.steps)) return undefined;
+
+  const steps = value.steps.flatMap((step): TaskProgressStep[] => {
+    if (!isRecord(step)) return [];
+    if (typeof step.label !== "string") return [];
+    if (
+      step.status !== "pending" &&
+      step.status !== "in_progress" &&
+      step.status !== "completed" &&
+      step.status !== "failed"
+    ) {
+      return [];
+    }
+    return [{ label: step.label, status: step.status }];
+  });
+
+  return steps.length > 0 ? { steps } : undefined;
+}
+
+function mergeTaskProgressData(
+  existing: TaskProgressData | undefined,
+  data: unknown,
+): TaskProgressData | undefined {
+  if (!isRecord(data)) return existing;
+  const update = getTaskProgressDataFromSurfaceData(data);
+  if (update) return update;
+  if (!existing || !("templateData" in data)) return existing;
+
+  return parseTaskProgressData({
+    steps: existing.steps,
+    ...(isRecord(data.templateData) ? data.templateData : {}),
+  });
+}
+
+function getTaskProgressLoadingMessage(
+  progress: TaskProgressData | undefined,
+): string[] | undefined {
+  if (!progress) return undefined;
+
+  const activeStepIndex = progress.steps.findIndex(
+    (step) => step.status === "in_progress",
+  );
+  if (activeStepIndex < 0) return undefined;
+
+  const activeStep = progress.steps[activeStepIndex]!;
+  return [
+    `In progress (${activeStepIndex + 1}/${progress.steps.length}): ${activeStep.label}`,
+  ];
+}
 
 /**
- * Set the Slack Assistants API "is thinking..." status on the thread and
- * return a cleanup function that clears it. Both operations are fire-and-forget.
+ * Set Slack Assistants API status on the thread and return a handle for
+ * updating loading messages or clearing the indicator.
  *
  * A safety timer auto-clears the status after {@link SLACK_THINKING_MAX_DURATION_MS}
  * to prevent a stuck indicator when `processMessage` hangs.
@@ -477,7 +642,8 @@ function setSlackThinkingStatus(
   callbackUrl: string,
   chatId: string,
   assistantId?: string,
-): () => void {
+  loadingMessages?: string[],
+): SlackThinkingStatusHandle {
   let cleared = false;
 
   // Extract the thread timestamp from the callback URL so we can target
@@ -487,7 +653,12 @@ function setSlackThinkingStatus(
   // For non-threaded DMs, fall back to emoji reaction on the original message.
   if (!threadTs) {
     const messageTs = extractMessageTsFromCallbackUrl(callbackUrl);
-    if (!messageTs) return () => {};
+    if (!messageTs) {
+      return {
+        updateLoadingMessages: () => {},
+        clear: () => {},
+      };
+    }
 
     const addPromise = deliverChannelReply(callbackUrl, {
       chatId,
@@ -500,7 +671,7 @@ function setSlackThinkingStatus(
       );
     });
 
-    const clearReaction = () => {
+    const clearReaction = (): void => {
       if (cleared) return;
       cleared = true;
       clearTimeout(safetyTimer);
@@ -524,28 +695,55 @@ function setSlackThinkingStatus(
     );
     (safetyTimer as { unref?: () => void }).unref?.();
 
-    return clearReaction;
+    return {
+      updateLoadingMessages: () => {},
+      clear: clearReaction,
+    };
   }
 
   // Track the set promise so clear waits for it to settle first,
   // preventing a race where clear arrives at Slack before set.
-  const setPromise = deliverChannelReply(callbackUrl, {
+  let statusPromise = deliverChannelReply(callbackUrl, {
     chatId,
     assistantId,
     assistantThreadStatus: {
       channel: chatId,
       threadTs,
-      status: "is thinking...",
+      status: getRandomSlackThinkingStatus(),
+      ...(loadingMessages ? { loadingMessages } : {}),
     },
   }).catch((err) => {
     log.debug({ err, chatId, threadTs }, "Failed to set Slack thinking status");
   });
 
-  const clearStatus = () => {
+  const updateLoadingMessages = (nextLoadingMessages?: string[]): void => {
+    if (cleared) return;
+    statusPromise = statusPromise.then(() =>
+      deliverChannelReply(callbackUrl, {
+        chatId,
+        assistantId,
+        assistantThreadStatus: {
+          channel: chatId,
+          threadTs,
+          status: getRandomSlackThinkingStatus(),
+          ...(nextLoadingMessages
+            ? { loadingMessages: nextLoadingMessages }
+            : {}),
+        },
+      }).catch((err) => {
+        log.debug(
+          { err, chatId, threadTs },
+          "Failed to update Slack thinking status",
+        );
+      }),
+    );
+  };
+
+  const clearStatus = (): void => {
     if (cleared) return;
     cleared = true;
     clearTimeout(safetyTimer);
-    void setPromise.then(() =>
+    void statusPromise.then(() =>
       deliverChannelReply(callbackUrl, {
         chatId,
         assistantId,
@@ -566,7 +764,10 @@ function setSlackThinkingStatus(
   const safetyTimer = setTimeout(clearStatus, SLACK_THINKING_MAX_DURATION_MS);
   (safetyTimer as { unref?: () => void }).unref?.();
 
-  return clearStatus;
+  return {
+    updateLoadingMessages,
+    clear: clearStatus,
+  };
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/routes/index.ts

@@ -29,10 +29,12 @@ import { ROUTES as CHANNEL_AVAILABILITY_ROUTES } from "./channel-availability-ro
 import { ROUTES as CHANNEL_READINESS_ROUTES } from "./channel-readiness-routes.js";
 import { CHANNEL_ROUTES } from "./channel-route-definitions.js";
 import { ROUTES as CHANNEL_VERIFICATION_ROUTES } from "./channel-verification-routes.js";
+import { ROUTES as CHATGPT_SUBSCRIPTION_AUTH_ROUTES } from "./chatgpt-subscription-auth-routes.js";
 import { ROUTES as CLIENT_ROUTES } from "./client-routes.js";
 import { ROUTES as CONSOLIDATION_ROUTES } from "./consolidation-routes.js";
 import { CONTACT_PROMPT_ROUTES } from "./contact-prompt-routes.js";
 import { ROUTES as CONTACT_ROUTES } from "./contact-routes.js";
+import { ROUTES as CONTENT_SOURCE_ROUTES } from "./content-source-routes.js";
 import { ROUTES as CONVERSATION_ANALYSIS_ROUTES } from "./conversation-analysis-routes.js";
 import { ROUTES as CONVERSATION_ATTENTION_ROUTES } from "./conversation-attention-routes.js";
 import { ROUTES as CONVERSATION_CLI_ROUTES } from "./conversation-cli-routes.js";
@@ -49,6 +51,7 @@ import { ROUTES as DEBUG_ROUTES } from "./debug-routes.js";
 import { ROUTES as DEFER_ROUTES } from "./defer-routes.js";
 import { ROUTES as DIAGNOSTICS_ROUTES } from "./diagnostics-routes.js";
 import { ROUTES as DISK_PRESSURE_ROUTES } from "./disk-pressure-routes.js";
+import { ROUTES as DOCUMENT_COMMENT_ROUTES } from "./document-comments-routes.js";
 import { ROUTES as DOCUMENT_ROUTES } from "./documents-routes.js";
 import { ROUTES as DOMAIN_ROUTES } from "./domain-routes.js";
 import { ROUTES as EMAIL_ROUTES } from "./email-routes.js";
@@ -72,12 +75,12 @@ import { ROUTES as IMAGE_GENERATION_ROUTES } from "./image-generation-routes.js"
 import { ROUTES as INFERENCE_PROFILE_SESSION_ROUTES } from "./inference-profile-session-routes.js";
 import { ROUTES as INFERENCE_PROVIDER_CONNECTION_ROUTES } from "./inference-provider-connection-routes.js";
 import { ROUTES as INFERENCE_SEND_ROUTES } from "./inference-send-routes.js";
-import { ROUTES as SLACK_CHANNEL_ROUTES } from "./integrations/slack/channel.js";
+import { ROUTES as A2A_ROUTES } from "./integrations/a2a.js";
+import { ROUTES as SLACK_CHANNEL_CONFIG_ROUTES } from "./integrations/slack/channel.js";
 import { ROUTES as SLACK_SHARE_ROUTES } from "./integrations/slack/share.js";
 import { ROUTES as TELEGRAM_ROUTES } from "./integrations/telegram.js";
 import { ROUTES as TWILIO_ROUTES } from "./integrations/twilio.js";
 import { ROUTES as VERCEL_ROUTES } from "./integrations/vercel.js";
-import { ROUTES as INTERFACE_ROUTES } from "./interface-routes.js";
 import { ROUTES as INTERNAL_OAUTH_ROUTES } from "./internal-oauth-routes.js";
 import { ROUTES as INTERNAL_TWILIO_ROUTES } from "./internal-twilio-routes.js";
 import { ROUTES as LLM_CALL_SITES_ROUTES } from "./llm-call-sites-routes.js";
@@ -101,11 +104,13 @@ import { ROUTES as PUBLISH_ROUTES } from "./publish-routes.js";
 import { ROUTES as QUESTION_ROUTES } from "./question-routes.js";
 import { ROUTES as RECORDING_ROUTES } from "./recording-routes.js";
 import { ROUTES as RENAME_CONVERSATION_ROUTES } from "./rename-conversation-routes.js";
+import { ROUTES as SANITY_ROUTES } from "./sanity-routes.js";
 import { ROUTES as SCHEDULE_ROUTES } from "./schedule-routes.js";
 import { ROUTES as SECRET_ROUTES } from "./secret-routes.js";
 import { ROUTES as SEQUENCE_ROUTES } from "./sequence-routes.js";
 import { ROUTES as SETTINGS_ROUTES } from "./settings-routes.js";
 import { ROUTES as SKILL_ROUTES } from "./skills-routes.js";
+import { ROUTES as SLACK_CHANNEL_RESOLVE_ROUTES } from "./slack-channel-routes.js";
 import { ROUTES as STT_ROUTES } from "./stt-routes.js";
 import { ROUTES as SUBAGENT_ROUTES } from "./subagents-routes.js";
 import { ROUTES as SUGGEST_TRUST_RULE_ROUTES } from "./suggest-trust-rule-routes.js";
@@ -145,6 +150,7 @@ export const ROUTES: RouteDefinition[] = [
   ...BOOKMARK_ROUTES,
   ...CACHE_ROUTES,
   ...CALL_ROUTES,
+  ...CHATGPT_SUBSCRIPTION_AUTH_ROUTES,
   ...CHANNEL_ROUTES,
   ...CHANNEL_VERIFICATION_ROUTES,
   ...CHANNEL_AVAILABILITY_ROUTES,
@@ -153,6 +159,7 @@ export const ROUTES: RouteDefinition[] = [
   ...BTW_ROUTES,
   ...BRAIN_GRAPH_ROUTES,
   ...CLIENT_ROUTES,
+  ...CONTENT_SOURCE_ROUTES,
   ...CONTACT_PROMPT_ROUTES,
   ...CONTACT_ROUTES,
   ...CONVERSATION_ANALYSIS_ROUTES,
@@ -173,6 +180,7 @@ export const ROUTES: RouteDefinition[] = [
   ...DIAGNOSTICS_ROUTES,
   ...DISK_PRESSURE_ROUTES,
   ...DOMAIN_ROUTES,
+  ...DOCUMENT_COMMENT_ROUTES,
   ...DOCUMENT_ROUTES,
   ...EMAIL_ROUTES,
   ...EVENTS_ROUTES,
@@ -195,7 +203,6 @@ export const ROUTES: RouteDefinition[] = [
   ...INFERENCE_PROFILE_SESSION_ROUTES,
   ...INFERENCE_PROVIDER_CONNECTION_ROUTES,
   ...INFERENCE_SEND_ROUTES,
-  ...INTERFACE_ROUTES,
   ...INTERNAL_OAUTH_ROUTES,
   ...MCP_AUTH_ROUTES,
   ...OAUTH_CONNECT_ROUTES,
@@ -220,10 +227,13 @@ export const ROUTES: RouteDefinition[] = [
   ...RECORDING_ROUTES,
   ...RENAME_CONVERSATION_ROUTES,
   ...SCHEDULE_ROUTES,
+  ...SANITY_ROUTES,
   ...SECRET_ROUTES,
   ...SETTINGS_ROUTES,
   ...SKILL_ROUTES,
-  ...SLACK_CHANNEL_ROUTES,
+  ...A2A_ROUTES,
+  ...SLACK_CHANNEL_CONFIG_ROUTES,
+  ...SLACK_CHANNEL_RESOLVE_ROUTES,
   ...SLACK_SHARE_ROUTES,
   ...STT_ROUTES,
   ...SUGGEST_TRUST_RULE_ROUTES,