@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/runtime/__tests__/agent-wake.test.ts

@@ -18,9 +18,10 @@
  * route captured calls back to the originating conversation's probe arrays.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
+import { desktopAutomationLease } from "../../desktop/desktop-automation-lease.js";
 
 // ── Per-conversation capture registry ────────────────────────────────
 //
@@ -501,6 +502,13 @@ function makeWakeConversation(options: {
         `tools:${snapshotAllowedTools()?.join(",") ?? "all"}`,
       );
     },
+    // Mirrors Conversation.setPreactivatedSkillIds; the wake's tool-scope
+    // restore calls it, and a double without it throws inside the restore
+    // closure, leaving every field restored after it untouched.
+    preactivatedSkillIds: undefined as string[] | undefined,
+    setPreactivatedSkillIds(ids: string[] | undefined) {
+      this.preactivatedSkillIds = ids;
+    },
     get wakePersonaOverride() {
       return wakePersonaOverride;
     },
@@ -1357,6 +1365,50 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.toolContextPin).toBeUndefined();
   });
 
+  test("applies wireToolDefinitions and the delegation state alongside the allowlist and restores both after the wake", async () => {
+    const replay = [
+      { name: "remember", description: "Save", input_schema: {} },
+      { name: "bell_jingle", description: "Ring", input_schema: {} },
+    ];
+    let replayDuringRun: unknown;
+    let delegationDuringRun: unknown;
+    const conversation = makeWakeConversation({
+      runImpl: async (input) => {
+        replayDuringRun = conversation.wireToolReplay;
+        delegationDuringRun = conversation.delegateIndependentTasksReplay;
+        return runResult([
+          ...input,
+          { role: "assistant", content: [{ type: "text", text: "Saved." }] },
+        ]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: conversation.conversationId,
+        hint: "review for memories",
+        source: "memory-retrospective",
+        allowedTools: ["remember"],
+        toolGateMode: "execution",
+        wireToolDefinitions: replay,
+        delegateIndependentTasks: true,
+      },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    // The replay array is live on the conversation for the duration of the
+    // run (the tool resolver returns it as the wire array), as is the
+    // delegation-section state the source's prompt rendered (the prompt
+    // build reads it)...
+    expect(replayDuringRun).toEqual(replay);
+    expect(delegationDuringRun).toBe(true);
+    // ...and both are cleared alongside the allowlist + gate mode after the
+    // wake.
+    expect(conversation.wireToolReplay).toBeUndefined();
+    expect(conversation.delegateIndependentTasksReplay).toBeUndefined();
+  });
+
   test("defaults to the wire gate mode when toolGateMode is absent", async () => {
     let gateModeDuringRun: string | undefined;
     const conversation = makeWakeConversation({
@@ -1517,6 +1569,47 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.pushedMessages[2]).toEqual(followupAssistant);
   });
 
+  for (const fails of [false, true]) {
+    test(`releases desktop control before a ${fails ? "failed" : "completed"} wake drains the queue`, async () => {
+      const conversation = makeWakeConversation({
+        scriptedAssistant: {
+          role: "assistant",
+          content: [{ type: "text", text: "reply" }],
+        },
+        ...(fails
+          ? {
+              runImpl: async () => {
+                throw new Error("wake failed");
+              },
+            }
+          : {}),
+      });
+      const release = spyOn(desktopAutomationLease, "releaseForConversation");
+      const setProcessing = conversation.setProcessing.bind(conversation);
+      conversation.setProcessing = (processing) => {
+        if (!processing) {
+          expect(release).toHaveBeenCalledWith(conversation.conversationId);
+        }
+        setProcessing(processing);
+      };
+      try {
+        const result = await wakeAgentForOpportunity(
+          {
+            conversationId: conversation.conversationId,
+            hint: "x",
+            source: "unit-test",
+          },
+          { resolveTarget: async () => conversation },
+        );
+        expect(result.invoked).toBe(!fails);
+        expect(release).toHaveBeenCalledTimes(1);
+        expect(conversation.drainQueueCalls).toBe(1);
+      } finally {
+        release.mockRestore();
+      }
+    });
+  }
+
   test("marks processing true during the run and false afterwards", async () => {
     const conversation = makeWakeConversation({
       baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],

package/src/runtime/agent-wake.ts

@@ -107,6 +107,7 @@ import {
   persistWakeTriggerMessage,
   scopeWakeAllowedTools,
 } from "../daemon/wake-conversation-ops.js";
+import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import {
   recordCompactionEndBestEffort,
   recordCompactionStartBestEffort,
@@ -118,7 +119,7 @@ import {
   setAgentLoopExitReasonOnLatestLog,
 } from "../persistence/llm-request-log-store.js";
 import type { SystemPromptPersonaOverride } from "../prompts/system-prompt.js";
-import type { Message } from "../providers/types.js";
+import type { Message, ToolDefinition } from "../providers/types.js";
 import {
   type UntrustedContentSource,
   wrapUntrustedContent,
@@ -350,6 +351,27 @@ export interface WakeOptions {
    * skill-management authoring tools callable directly.
    */
   preactivateSkillIds?: readonly string[];
+  /**
+   * Tool definitions to send verbatim as the wake's wire tool array, in place
+   * of the ones the conversation would resolve for itself. Used by fork-based
+   * memory retrospectives to replay the SOURCE conversation's recorded surface
+   * (`getRecordedConversationToolSurface`) so the provider prompt-cache prefix matches
+   * the source's live turns byte for byte. Definitions only: what may execute
+   * is still decided by `allowedTools` and the turn's own active set. Applied
+   * and restored alongside `allowedTools`; ignored when `allowedTools` is
+   * absent.
+   */
+  wireToolDefinitions?: readonly ToolDefinition[];
+  /**
+   * Whether the source's recorded surface rendered the system prompt's
+   * parallel-delegation section, replayed into the wake's prompt so that
+   * tier of the provider cache prefix matches the source's too (the wake's
+   * own scope cannot spawn, so deriving it would render the section off where
+   * an interactive source rendered it on). Prompt only: a spawn attempt is
+   * still rejected at execution. Applied and restored alongside
+   * `allowedTools`; ignored when `allowedTools` is absent.
+   */
+  delegateIndependentTasks?: boolean;
   /**
    * Explicit persona/channel slugs for the wake's system-prompt build,
    * applied to the conversation for the duration of the run and restored
@@ -1410,6 +1432,7 @@ export async function wakeAgentForOpportunity(
      * is one function rather than a rebuild bolted onto either half.
      */
     const restoreWakeTurnScope = (): void => {
+      desktopAutomationLease.releaseForConversation(conversationId);
       restoreWakeAllowedTools();
       clearWakePersonaOverride();
       syncWakeLoopSystemPrompt();
@@ -1422,9 +1445,13 @@ export async function wakeAgentForOpportunity(
         restoreWakeToolScope = scopeWakeAllowedTools(
           conversation,
           new Set(opts.allowedTools),
-          opts.toolGateMode,
-          opts.toolContextPin,
-          opts.preactivateSkillIds,
+          {
+            gateMode: opts.toolGateMode,
+            toolContextPin: opts.toolContextPin,
+            preactivateSkillIds: opts.preactivateSkillIds,
+            wireToolDefinitions: opts.wireToolDefinitions,
+            delegateIndependentTasks: opts.delegateIndependentTasks,
+          },
         );
         return true;
       } catch (err) {

package/src/runtime/guardian-action-service.ts

@@ -16,21 +16,6 @@ import {
   isApprovalAction,
 } from "./channel-approval-types.js";
 
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/**
- * Legacy actions that map to canonical ones during client rollout.
- * All temporal/persistent approval variants collapse to approve_once.
- * Keep until all clients are updated and no in-flight buttons remain.
- */
-const LEGACY_ACTION_MAP: Record<string, string> = {
-  approve_10m: "approve_once",
-  approve_conversation: "approve_once",
-  approve_always: "approve_once",
-};
-
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -98,8 +83,8 @@ export async function processGuardianDecision(
 ): Promise<ProcessGuardianDecisionResult> {
   const { requestId, conversationId, channel, actorContext } = params;
 
-  // 1. Canonicalize legacy actions, then validate
-  const action = LEGACY_ACTION_MAP[params.action] ?? params.action;
+  // 1. Validate the action
+  const action = params.action;
   if (!isApprovalAction(action)) {
     return {
       ok: false,

package/src/runtime/guardian-reply-router.ts

@@ -153,12 +153,6 @@ export interface GuardianReplyResult {
 // Callback data parser — format: "apr:<requestId>:<action>"
 // ---------------------------------------------------------------------------
 
-const LEGACY_CALLBACK_MAP: Record<string, string> = {
-  approve_10m: "approve_once",
-  approve_conversation: "approve_once",
-  approve_always: "approve_once",
-};
-
 interface ParsedCallback {
   requestId: string;
   action: ApprovalAction;
@@ -170,8 +164,7 @@ function parseCallbackAction(data: string): ParsedCallback | null {
     return null;
   }
   const requestId = parts[1];
-  const rawAction = parts.slice(2).join(":");
-  const action = LEGACY_CALLBACK_MAP[rawAction] ?? rawAction;
+  const action = parts.slice(2).join(":");
   if (!requestId || !isApprovalAction(action)) {
     return null;
   }

package/src/runtime/http-server.ts

@@ -254,9 +254,9 @@ type AllWebSocketData =
 
 function virtualDesktopEnabled(): boolean {
   try {
-    return isVirtualDesktopEnabled(getConfig());
+    return isVirtualDesktopEnabled();
   } catch (err) {
-    log.warn({ err }, "Failed to read config for desktop stream gate");
+    log.warn({ err }, "Failed to check desktop stream gate");
     return false;
   }
 }

package/src/runtime/migrations/__tests__/vbundle-import-policy.test.ts

@@ -15,6 +15,7 @@ import {
   isConfigArchivePath,
   isCredentialMetadataArchivePath,
   isLegacyPersonaArchivePath,
+  isLocalDevRuntimeVersion,
   isWorkspaceNamespacedArchivePath,
   LEGACY_USER_MD_ARCHIVE_PATH,
   partitionWorkspacePreserveSkipDirs,
@@ -257,4 +258,92 @@ describe("evaluateRuntimeCompatibility", () => {
       ),
     ).toEqual({ ok: true });
   });
+
+  // A `vel up` minikube assistant image is stamped
+  // `<pkg.version>-local.<ts>.<sha>` from the checkout's package.json,
+  // which only moves on release cuts, so the minimum bound cannot be
+  // decided from it; the explicit maximum ceiling still applies.
+  test("local dev runtime build skips the minimum bound", () => {
+    expect(
+      evaluateRuntimeCompatibility(
+        { min_runtime_version: "0.12.2-staging.4", max_runtime_version: null },
+        "0.12.1-local.20260916144827.2f409056e6",
+      ),
+    ).toEqual({ ok: true });
+  });
+
+  test("local dev runtime build within an explicit range passes", () => {
+    expect(
+      evaluateRuntimeCompatibility(
+        { min_runtime_version: "0.12.2", max_runtime_version: "0.12.5" },
+        "0.12.1-local.20260916144827.2f409056e6",
+      ),
+    ).toEqual({ ok: true });
+  });
+
+  test("local dev runtime build above max still fails", () => {
+    const compat = {
+      min_runtime_version: "0.7.0",
+      max_runtime_version: "0.7.5",
+    };
+    const runtime = "0.12.1-local.20260916144827.2f409056e6";
+    expect(evaluateRuntimeCompatibility(compat, runtime)).toEqual({
+      ok: false,
+      reason: "version_incompatible",
+      bundle_compat: compat,
+      runtime_version: runtime,
+    });
+  });
+
+  test("local dev runtime build with unparsable max fails open", () => {
+    expect(
+      evaluateRuntimeCompatibility(
+        { min_runtime_version: "0.7.0", max_runtime_version: "garbage" },
+        "0.12.1-local.20260916144827.2f409056e6",
+      ),
+    ).toEqual({ ok: true });
+  });
+
+  test("other prerelease builds are still gated", () => {
+    const compat = {
+      min_runtime_version: "0.12.2-staging.4",
+      max_runtime_version: null,
+    };
+    for (const runtime of [
+      "0.12.1-dev.202609151913.a151da3",
+      "0.12.1-staging.9",
+      "0.12.1",
+    ]) {
+      expect(evaluateRuntimeCompatibility(compat, runtime)).toEqual({
+        ok: false,
+        reason: "version_incompatible",
+        bundle_compat: compat,
+        runtime_version: runtime,
+      });
+    }
+  });
+});
+
+describe("isLocalDevRuntimeVersion", () => {
+  test("matches the local hatch / minikube version stamp", () => {
+    expect(
+      isLocalDevRuntimeVersion("0.12.1-local.20260916144827.2f409056e6"),
+    ).toBe(true);
+    expect(isLocalDevRuntimeVersion("0.0.0-local.1789584535000")).toBe(true);
+  });
+
+  test("rejects release, dev and staging builds and lookalikes", () => {
+    for (const version of [
+      "0.12.1",
+      "0.12.1-dev.202609151913.a151da3",
+      "0.12.2-staging.4",
+      "0.0.0-dev",
+      "0.0.0-legacy",
+      "0.12.1-localhost.1",
+      "local.0.12.1",
+      "",
+    ]) {
+      expect(isLocalDevRuntimeVersion(version)).toBe(false);
+    }
+  });
 });

package/src/runtime/migrations/vbundle-import-policy.ts

@@ -172,6 +172,20 @@ export function formatRuntimeCompatibilityMessage(
   return `Cannot import: bundle requires runtime ${range}, but this runtime is ${runtimeVersion}. Update your runtime before importing.`;
 }
 
+/**
+ * Whether `version` names a runtime built from a source checkout: the
+ * `<pkg.version>-local.<timestamp>.<sha>` `APP_VERSION` that the platform
+ * repo's `vel up` stamps on the assistant images it builds for its local
+ * minikube cluster. The triple is the checkout's package.json version,
+ * which only moves on release cuts, so it says nothing about whether the
+ * checkout is newer or older than a release. A CLI hatch from a checkout
+ * without an explicit `APP_VERSION` runs as the plain package version and
+ * is not covered.
+ */
+export function isLocalDevRuntimeVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+-local\./.test(version);
+}
+
 export function evaluateRuntimeCompatibility(
   compat: RuntimeCompatibility,
   runtimeVersion: string,
@@ -179,17 +193,25 @@ export function evaluateRuntimeCompatibility(
   if (compat.min_runtime_version === LEGACY_RUNTIME_VERSION_SENTINEL) {
     return { ok: true };
   }
-  const minCmp = compareSemver(runtimeVersion, compat.min_runtime_version);
-  if (minCmp === null) {
-    return { ok: true };
-  }
-  if (minCmp < 0) {
-    return {
-      ok: false,
-      reason: "version_incompatible",
-      bundle_compat: compat,
-      runtime_version: runtimeVersion,
-    };
+  // A local dev build skips the minimum bound, like an unparsable version
+  // does below: its triple is not comparable to release versions (see
+  // isLocalDevRuntimeVersion), so "runtime older than the bundle" cannot be
+  // decided from it. The maximum bound still applies: it is an explicit
+  // ceiling the bundle's producer recorded, and a local triple above it is
+  // as good a signal as any release's.
+  if (!isLocalDevRuntimeVersion(runtimeVersion)) {
+    const minCmp = compareSemver(runtimeVersion, compat.min_runtime_version);
+    if (minCmp === null) {
+      return { ok: true };
+    }
+    if (minCmp < 0) {
+      return {
+        ok: false,
+        reason: "version_incompatible",
+        bundle_compat: compat,
+        runtime_version: runtimeVersion,
+      };
+    }
   }
   if (compat.max_runtime_version !== null) {
     const maxCmp = compareSemver(runtimeVersion, compat.max_runtime_version);

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -123,8 +123,7 @@ function seedVellumConnection(): void {
 
 function persistedProfiles(): Record<string, unknown> {
   const llm = loadRawConfig().llm as
-    | { profiles?: Record<string, unknown> }
-    | undefined;
+    { profiles?: Record<string, unknown> } | undefined;
   return llm?.profiles ?? {};
 }
 
@@ -923,6 +922,29 @@ describe("PUT inference/active-profile validation", () => {
     ).rejects.toThrow(/disabled/);
   });
 
+  test("rejects a profile whose catalog model does not produce chat text", async () => {
+    setConfig("llm", {
+      profiles: {
+        jev: {
+          source: "user",
+          provider: "jev",
+          model: "jev-latest",
+          status: "active",
+        },
+      },
+    });
+    const promise = call("inference_profiles_set_active", {
+      body: { name: "jev" },
+    });
+    await expect(promise).rejects.toBeInstanceOf(BadRequestError);
+    await expect(promise).rejects.toThrow(
+      /structured answers rather than chat text/,
+    );
+    expect(
+      (loadRawConfig().llm as { activeProfile?: string }).activeProfile,
+    ).toBeUndefined();
+  });
+
   test("rejects a profile that cannot serve requests — no escape hatch", async () => {
     setConfig("llm", {
       profiles: {

package/src/runtime/routes/channel-route-shared.ts

@@ -29,13 +29,6 @@ export function requiredDecisionKeywords(
 // Callback data parser — format: "apr:<requestId>:<action>"
 // ---------------------------------------------------------------------------
 
-/** Map legacy callback actions to canonical ones for in-flight buttons. */
-const LEGACY_CALLBACK_MAP: Record<string, string> = {
-  approve_10m: "approve_once",
-  approve_conversation: "approve_once",
-  approve_always: "approve_once",
-};
-
 export function parseCallbackData(
   data: string,
   sourceChannel?: string,
@@ -45,8 +38,7 @@ export function parseCallbackData(
     return null;
   }
   const requestId = parts[1];
-  const rawAction = parts.slice(2).join(":");
-  const action = LEGACY_CALLBACK_MAP[rawAction] ?? rawAction;
+  const action = parts.slice(2).join(":");
   if (!requestId || !isApprovalAction(action)) {
     return null;
   }

package/src/runtime/routes/conversation-routes.ts

@@ -113,7 +113,7 @@ import { recordOnboardingEvent } from "../../onboarding/onboarding-events-store.
 import {
   classifyKind,
   getAttachmentById,
-  getAttachmentMetadataForMessage,
+  getAttachmentMetadataForMessages,
   getAttachmentsByIds,
   resolveAttachmentsForPersist,
 } from "../../persistence/attachments-store.js";
@@ -132,6 +132,7 @@ import {
   isSuppressedQueuedMessage,
   isSystemCardMetadata,
   type MessageRow,
+  parseMessageMetadata,
   recordConversationPersistedSeq,
   setConversationInferenceProfile,
 } from "../../persistence/conversation-crud.js";
@@ -141,6 +142,7 @@ import {
 } from "../../persistence/conversation-key-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
 import {
+  computerUseScreenshotAttachmentIdsFromMetadata,
   isNoResponseMetadata,
   messageMetadataIsAmbientSightKeep,
 } from "../../persistence/conversation-types.js";
@@ -1180,9 +1182,29 @@ export async function handleListMessages({
       let msgAttachments: RuntimeAttachmentMetadata[] = [];
       if (m.id) {
         const idsToQuery = [m.id, ...mergedMessageIds];
-        const linked = idsToQuery.flatMap((id) =>
-          getAttachmentMetadataForMessage(id),
-        );
+        const linkedRows = getAttachmentMetadataForMessages(idsToQuery);
+        const computerUseScreenshotIdsByMessage = new Map<
+          string,
+          Set<string>
+        >();
+        const linked = linkedRows.map((row) => {
+          let screenshotIds = computerUseScreenshotIdsByMessage.get(
+            row.messageId,
+          );
+          if (!screenshotIds) {
+            screenshotIds = new Set(
+              computerUseScreenshotAttachmentIdsFromMetadata(
+                parseMessageMetadata(row.messageMetadata),
+              ),
+            );
+            computerUseScreenshotIdsByMessage.set(row.messageId, screenshotIds);
+          }
+          return {
+            ...row.attachment,
+            computerUseScreenshot:
+              screenshotIds.has(row.attachment.id) || undefined,
+          };
+        });
         if (linked.length > 0) {
           msgAttachments = await Promise.all(
             linked.map(async (a) => {
@@ -1221,6 +1243,9 @@ export async function handleListMessages({
                   ? { thumbnailData: a.thumbnailBase64 }
                   : {}),
                 fileBacked: true,
+                ...(a.computerUseScreenshot
+                  ? { computerUseScreenshot: true }
+                  : {}),
               };
             }),
           );

package/src/runtime/routes/desktop-setup-routes.test.ts

@@ -79,8 +79,8 @@ describe("desktop setup route feature gate", () => {
       setOverridesForTesting({ "assistant-desktop": true });
       expect(route.handler({})).toEqual(
         route.method === "GET"
-          ? { state: "required" }
-          : { state: "installing", stage: "packages" },
+          ? { state: "required", automationActive: false }
+          : { state: "installing", stage: "packages", automationActive: false },
       );
       expect(route.method === "GET" ? status : start).toHaveBeenCalledTimes(1);
       expect(route.method === "GET" ? start : status).not.toHaveBeenCalled();

package/src/runtime/routes/desktop-setup-routes.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { getConfig } from "../../config/loader.js";
+import { desktopAutomationLease } from "../../desktop/desktop-automation-lease.js";
 import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
 import { isVirtualDesktopEnabled } from "../../desktop/virtual-desktop-feature.js";
 import { GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
@@ -9,6 +9,7 @@ import type { RouteDefinition } from "./types.js";
 
 const statusSchema = z.object({
   state: z.enum(["required", "installing", "ready", "failed", "unsupported"]),
+  automationActive: z.boolean().optional(),
   stage: z.enum(["packages", "chrome", "checking"]).optional(),
 });
 
@@ -19,14 +20,16 @@ export const ROUTES: RouteDefinition[] = ["GET", "POST"].map((method) => ({
   method,
   policy: { requiredScopes: [], allowedPrincipalTypes: GATEWAY_PRINCIPALS },
   handler: () => {
-    if (!isVirtualDesktopEnabled(getConfig())) {
+    if (!isVirtualDesktopEnabled()) {
       throw new NotFoundError(
         "Virtual desktop is available only on enabled platform-hosted assistants",
       );
     }
-    return method === "GET"
-      ? desktopDependencyInstaller.getStatus()
-      : desktopDependencyInstaller.start();
+    const status =
+      method === "GET"
+        ? desktopDependencyInstaller.getStatus()
+        : desktopDependencyInstaller.start();
+    return { ...status, automationActive: desktopAutomationLease.isActive };
   },
   summary:
     method === "GET"

package/src/runtime/routes/guardian-approval-interception.ts

@@ -299,6 +299,30 @@ export async function handleApprovalInterception(
 
       return { handled: true, type: "stale_ignored" };
     }
+
+    // An approval callback that names no approval action is a button press
+    // the daemon does not serve (an id outside the decision vocabulary, or an
+    // answer token aimed at a card this rail does not resolve). It is never
+    // text: the channel normalizers copy callback data into `content`, so
+    // letting it fall through would hand the raw callback to the
+    // conversational and natural-language parsers, which can read a token
+    // like `approve_always` as an approval. Consume it as a stale button.
+    if (callbackData.startsWith("apr:")) {
+      log.warn(
+        { conversationId, callbackData },
+        "Approval callback carries no approval action, ignoring stale button press",
+      );
+      if (approvalMessageId) {
+        editStaleApprovalMessage({
+          replyCallbackUrl,
+          chatId: conversationExternalId,
+          messageId: approvalMessageId,
+          assistantId,
+          conversationId,
+        });
+      }
+      return { handled: true, type: "stale_ignored" };
+    }
   }
 
   // ── Conversational approval engine for plain-text messages ──

package/src/runtime/routes/inbound-message-handler.ts

@@ -1531,8 +1531,7 @@ export async function handleChannelInbound({
         sourceMetadata.account.length > 0
           ? sourceMetadata.account
           : undefined;
-      const slackBotMentioned =
-        sourceChannel === "slack" && sourceMetadata?.slackBotMentioned === true;
+      const botMentioned = sourceMetadata?.botMentioned === true;
 
       // ── DM cold-start backfill ──
       // First time a Slack DM without thread_ts lands in a conversation that
@@ -1625,7 +1624,7 @@ export async function handleChannelInbound({
         approvalCopyGenerator,
         chatType: sourceChatType,
         clientTimezone: inboundClientTimezone,
-        slackBotMentioned,
+        botMentioned,
         slackInbound,
         channelInbound,
       });

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

@@ -1169,7 +1169,7 @@ describe("channel activity timing", () => {
       externalChatId: channelId,
       trustCtx,
       metadataHints: [],
-      slackBotMentioned: true,
+      botMentioned: true,
       replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
     });