@vellumai/assistant 0.9.0-dev.202606182147.d5eebd3 → 0.9.0-dev.202606182256.609733d

package/openapi.yaml

@@ -16239,6 +16239,7 @@ paths:
                                           - brave
                                           - perplexity
                                           - tavily
+                                          - firecrawl
                                       resultCount:
                                         type: number
                                       durationMs:
@@ -16286,6 +16287,11 @@ paths:
                                         type: string
                                       finalUrl:
                                         type: string
+                                      provider:
+                                        type: string
+                                        enum:
+                                          - default
+                                          - firecrawl
                                       status:
                                         type: number
                                       contentType:
@@ -16621,6 +16627,7 @@ paths:
                                                   - brave
                                                   - perplexity
                                                   - tavily
+                                                  - firecrawl
                                               resultCount:
                                                 type: number
                                               durationMs:
@@ -16668,6 +16675,11 @@ paths:
                                                 type: string
                                               finalUrl:
                                                 type: string
+                                              provider:
+                                                type: string
+                                                enum:
+                                                  - default
+                                                  - firecrawl
                                               status:
                                                 type: number
                                               contentType:
@@ -28733,6 +28745,10 @@ components:
               anyOf:
                 - type: string
                 - type: "null"
+            advisorProfile:
+              anyOf:
+                - type: string
+                - type: "null"
             callSites:
               type: object
               propertyNames:
@@ -28768,6 +28784,16 @@ components:
                       type: string
                   additionalProperties: {}
                 - type: "null"
+            web-fetch:
+              anyOf:
+                - type: object
+                  properties:
+                    mode:
+                      $ref: "#/components/schemas/ServiceMode"
+                    provider:
+                      type: string
+                  additionalProperties: {}
+                - type: "null"
             image-generation:
               anyOf:
                 - type: object
@@ -28963,6 +28989,12 @@ components:
                 - $ref: "#/components/schemas/ProfileStatus"
                 - type: "null"
             - type: "null"
+        advisorEnabled:
+          anyOf:
+            - anyOf:
+                - type: boolean
+                - type: "null"
+            - type: "null"
         mix:
           anyOf:
             - minItems: 2
@@ -29354,6 +29386,8 @@ components:
                 type: string
             activeProfile:
               type: string
+            advisorProfile:
+              type: string
             callSites:
               type: object
               propertyNames:
@@ -29504,6 +29538,14 @@ components:
                 provider:
                   type: string
               additionalProperties: {}
+            web-fetch:
+              type: object
+              properties:
+                mode:
+                  $ref: "#/components/schemas/ServiceMode"
+                provider:
+                  type: string
+              additionalProperties: {}
             image-generation:
               type: object
               properties:
@@ -29653,6 +29695,10 @@ components:
           anyOf:
             - $ref: "#/components/schemas/ProfileStatus"
             - type: "null"
+        advisorEnabled:
+          anyOf:
+            - type: boolean
+            - type: "null"
         mix:
           minItems: 2
           type: array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0-dev.202606182147.d5eebd3",
+  "version": "0.9.0-dev.202606182256.609733d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -236,7 +236,7 @@ describe("channel inbound disk pressure gate", () => {
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 
-  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+  test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
     upsertContact({
       displayName: "Example Slack User",
       channels: [
@@ -274,18 +274,10 @@ describe("channel inbound disk pressure gate", () => {
       reason: "trusted-contact",
     });
     expect(processMessage).not.toHaveBeenCalled();
-    expect(deliverChannelReplyMock.mock.calls).toEqual([
-      [
-        "https://gateway.test/deliver/slack",
-        {
-          chatId: "slack-channel-1",
-          text: expectedRemoteBlockReply,
-          assistantId: "self",
-          ephemeral: true,
-          user: "slack-user-1",
-        },
-      ],
-    ]);
+    // Reactions are blocked silently during disk pressure: a passive signal
+    // has nothing to "try again", so no block reply is delivered (unlike the
+    // message path, which does reply).
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
 
     const db = getDb();
     const event = db

package/src/__tests__/config-schema.test.ts

@@ -145,6 +145,40 @@ describe("AssistantConfigSchema", () => {
     expect(result.services["web-search"].mode).toBe("your-own");
   });
 
+  test("accepts Firecrawl as a web search provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "web-search": { mode: "your-own", provider: "firecrawl" },
+      },
+    });
+
+    expect(result.services["web-search"].provider).toBe("firecrawl");
+    expect(result.services["web-search"].mode).toBe("your-own");
+  });
+
+  test("defaults the web-fetch provider to the built-in fetcher", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.services["web-fetch"].provider).toBe("default");
+  });
+
+  test("accepts Firecrawl as a web fetch provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "web-fetch": { mode: "your-own", provider: "firecrawl" },
+      },
+    });
+
+    expect(result.services["web-fetch"].provider).toBe("firecrawl");
+  });
+
+  test("rejects an unknown web-fetch provider", () => {
+    expect(() =>
+      AssistantConfigSchema.parse({
+        services: { "web-fetch": { provider: "nope" } },
+      }),
+    ).toThrow();
+  });
+
   test("accepts valid complete config", () => {
     const input = {
       llm: {

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

@@ -158,6 +158,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "credential-execution/prompted-credential.ts", // shared prompt-action persistence (stores secret via setSecureKeyAsync)
       "tools/credentials/broker.ts", // brokered credential access
       "tools/network/web-search.ts", // web search API key lookup
+      "tools/network/web-fetch.ts", // web fetch provider (Firecrawl) API key lookup
       "daemon/handlers/config-telegram.ts", // Telegram bot token management
       "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)

package/src/__tests__/reaction-persistence.test.ts

@@ -59,7 +59,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import {
   isSlackReactionEvent,
   parseSlackReactionCallbackData,
-} from "../runtime/routes/inbound-message-handler.js";
+} from "../runtime/routes/inbound-stages/reaction-intercept.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
@@ -575,3 +575,112 @@ describe("guardian approval-by-reaction integration via handleChannelInbound", (
     expect(reactionRows.length).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Reaction access-control regression (LUM-2489)
+// ---------------------------------------------------------------------------
+//
+// A reaction is a passive signal, not an access attempt. Because reactions are
+// dispatched before the ingress pipeline, an unknown user's 👍 must never run
+// ACL (no trusted-contact verification handshake), create a conversation, or
+// write a binding — it is dropped as channel noise. A known contact's reaction
+// is recorded; neither triggers a verification challenge.
+
+describe("reaction access control (no verification handshake)", () => {
+  const STRANGER_USER_ID = "U_REACTION_STRANGER";
+  const CONTACT_USER_ID = "U_REACTION_CONTACT";
+  // Guardian's approval channel is a DM, distinct from the public channel the
+  // reaction lands in (mirroring production). Reusing the public channel id
+  // would let a reactor match the guardian's channel via findContactChannel's
+  // externalChatId fallback and mask the bug.
+  const GUARDIAN_DM_CHAT = "D_GUARDIAN_DM";
+
+  function tableCount(table: string): number {
+    return (
+      getDb().$client.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as {
+        n: number;
+      }
+    ).n;
+  }
+
+  beforeEach(() => {
+    resetState();
+    getDb().run("DELETE FROM channel_verification_sessions");
+    // The assistant has a guardian (as in production); the reactors below are
+    // different users.
+    createGuardianBinding({
+      channel: "slack",
+      guardianExternalUserId: GUARDIAN_USER_ID,
+      guardianDeliveryChatId: GUARDIAN_DM_CHAT,
+      guardianPrincipalId: GUARDIAN_USER_ID,
+    });
+    msgCounter = 0;
+  });
+
+  test("stranger's reaction is dropped — no challenge, session, conversation, or row", async () => {
+    let agentDispatched = false;
+    const processMessage = async (): Promise<{ messageId: string }> => {
+      agentDispatched = true;
+      return { messageId: "should-not-be-called" };
+    };
+
+    const req = buildReactionRequest("reaction:thumbsup", {
+      actorExternalId: STRANGER_USER_ID,
+      actorDisplayName: "Outside Reactor",
+      actorUsername: "outsider",
+    });
+    const resp = await handleChannelInbound(
+      req,
+      processMessage,
+      TEST_BEARER_TOKEN,
+    );
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    // Accepted as a passive signal — never denied or turned into a challenge.
+    expect(json.accepted).toBe(true);
+    expect(json.denied).not.toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(json.verificationSessionId).toBeUndefined();
+    expect(agentDispatched).toBe(false);
+
+    // No verification handshake, and no side effects: a dropped reaction leaves
+    // no transcript row, no conversation, and no binding.
+    expect(tableCount("channel_verification_sessions")).toBe(0);
+    expect(readPersistedMessages().length).toBe(0);
+    expect(tableCount("conversations")).toBe(0);
+    expect(tableCount("external_conversation_bindings")).toBe(0);
+  });
+
+  test("known contact's reaction is recorded — no challenge", async () => {
+    // A pending contact classifies as `unverified_contact` — a known tier, so
+    // its reactions are recorded. On a real message it would be re-challenged,
+    // but a reaction must not trigger that.
+    upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: CONTACT_USER_ID,
+      externalChatId: SLACK_CHANNEL_ID,
+      status: "pending",
+      policy: "allow",
+      displayName: "Pending Contact",
+    });
+
+    const req = buildReactionRequest("reaction:tada", {
+      actorExternalId: CONTACT_USER_ID,
+      actorDisplayName: "Pending Contact",
+      actorUsername: "pending_contact",
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.denied).not.toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(tableCount("channel_verification_sessions")).toBe(0);
+
+    const rows = readPersistedMessages();
+    expect(rows.length).toBe(1);
+    const envelope = JSON.parse(rows[0].metadata!) as Record<string, unknown>;
+    const slackMeta = readSlackMetadata(envelope.slackMeta as string);
+    expect(slackMeta?.eventKind).toBe("reaction");
+    expect(slackMeta?.reaction?.emoji).toBe("tada");
+  });
+});

package/src/api/events/tool-result.ts

@@ -47,10 +47,15 @@ export const WebSearchProviderIdSchema = z.enum([
   "brave",
   "perplexity",
   "tavily",
+  "firecrawl",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
 
+export const WebFetchProviderIdSchema = z.enum(["default", "firecrawl"]);
+
+export type WebFetchProviderId = z.infer<typeof WebFetchProviderIdSchema>;
+
 export const WebSearchResultItemSchema = z.object({
   rank: z.number(),
   title: z.string(),
@@ -78,6 +83,7 @@ export type WebSearchMetadata = z.infer<typeof WebSearchMetadataSchema>;
 export const WebFetchMetadataSchema = z.object({
   url: z.string(),
   finalUrl: z.string(),
+  provider: WebFetchProviderIdSchema.optional(),
   status: z.number(),
   contentType: z.string().optional(),
   byteCount: z.number(),

package/src/config/call-site-defaults.ts

@@ -69,6 +69,9 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   meetConsentMonitor: { profile: "cost-optimized" },
   meetChatOpportunity: { profile: "cost-optimized" },
   inference: { profile: "cost-optimized" },
+  // The advisor consults the strongest managed profile by default; a workspace
+  // overrides this via `llm.advisorProfile` (which floats above this).
+  advisor: { profile: "quality-optimized" },
 
   heartbeatAgent: {
     profile: "cost-optimized",

package/src/config/llm-resolver.ts

@@ -366,6 +366,9 @@ function profileConfigFragment(profile: ProfileEntry): Mergeable {
     // lower-precedence (e.g. active) profile into one that merely inherited it.
     // `RetryProvider` resolves it from the applied profile, not the merge.
     logitBias: _logitBias,
+    // Per-profile advisor toggle is profile identity, not inheritable model
+    // config — strip it so it can't leak into the merged `LLMConfigBase`.
+    advisorEnabled: _advisorEnabled,
     ...config
   } = profile;
   return config as Mergeable;

package/src/config/schemas/call-site-catalog.ts

@@ -300,6 +300,13 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "General-purpose LLM inference call site for skill use.",
     domain: "skills",
   },
+  advisor: {
+    id: "advisor",
+    displayName: "Advisor",
+    description:
+      "Stronger reviewer model consulted mid-task to shape or pressure-test the plan.",
+    domain: "skills",
+  },
   homeGreeting: {
     id: "homeGreeting",
     displayName: "Home Greeting",

package/src/config/schemas/llm.ts

@@ -78,6 +78,7 @@ export const LLMCallSiteEnum = z.enum([
   "meetConsentMonitor",
   "meetChatOpportunity",
   "inference",
+  "advisor",
   "trustRuleSuggestion",
   "homeGreeting",
   "homeSuggestedPrompts",
@@ -432,6 +433,13 @@ export const ProfileEntry = LLMConfigFragment.extend({
    * #30362 even though the schema didn't accept it until now.
    */
   status: ProfileStatusSchema.nullable().optional(),
+  /**
+   * Whether the advisor is active while this profile is the chat profile.
+   * Absent/null means enabled (default on); only an explicit `false` disables
+   * it. `.nullable()` matches `status`/`label` so the PUT route's "send null
+   * to clear" sentinel resets it back to the default-on state.
+   */
+  advisorEnabled: z.boolean().nullable().optional(),
   /**
    * When present, this profile is a "mix": it carries no model config and
    * instead references a weighted list of standard profiles. The resolver
@@ -475,6 +483,11 @@ export const LLMSchema = z
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
     activeProfile: z.string().min(1).optional(),
+    // The profile the advisor consults (chosen under Models & Services). It is
+    // excluded from the chat-profile pickers so it can't be selected as the
+    // assistant's chat model. Absent falls back to the `advisor` call-site
+    // default (`quality-optimized`).
+    advisorProfile: z.string().min(1).optional(),
     // TTL bounds for inference profile sessions. `defaultTtlSeconds` is read by
     // the CLI to apply when `--ttl` is omitted; the daemon handler itself only
     // reads `maxTtlSeconds` (to clamp caller-supplied values).
@@ -508,6 +521,16 @@ export const LLMSchema = z
         message: `Profile "${config.activeProfile}" referenced by llm.activeProfile is not defined in llm.profiles`,
       });
     }
+    if (
+      config.advisorProfile != null &&
+      !profileNames.has(config.advisorProfile)
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["advisorProfile"],
+        message: `Profile "${config.advisorProfile}" referenced by llm.advisorProfile is not defined in llm.profiles`,
+      });
+    }
 
     // --- Mix profile validation --------------------------------------------
     // Config keys a mix profile must NOT also set (a mix only references other

package/src/config/schemas/services.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { DEFAULT_IMAGE_MODEL } from "../../media/image-models.js";
+import { FETCH_PROVIDER_IDS } from "../../providers/fetch-provider-catalog.js";
 import { SEARCH_PROVIDER_IDS } from "../../providers/search-provider-catalog.js";
 import { SttServiceSchema } from "./stt.js";
 import { TtsServiceSchema } from "./tts.js";
@@ -28,6 +29,13 @@ const VALID_IMAGE_GEN_PROVIDERS = ["gemini", "openai"] as const;
  */
 const VALID_WEB_SEARCH_PROVIDERS = SEARCH_PROVIDER_IDS;
 
+/**
+ * Derived from `FETCH_PROVIDER_CATALOG`. Adding a new web-fetch provider
+ * to the catalog automatically extends the config-schema enum — no edit
+ * here required.
+ */
+const VALID_WEB_FETCH_PROVIDERS = FETCH_PROVIDER_IDS;
+
 const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
 });
@@ -58,6 +66,15 @@ const WebSearchServiceSchema = BaseServiceSchema.extend({
     .default("inference-provider-native"),
 });
 
+const WebFetchServiceSchema = BaseServiceSchema.extend({
+  // Provider that backs the `web_fetch` tool. `default` is the daemon's
+  // built-in HTTP fetch + extract path (no key). BYOK providers (e.g.
+  // `firecrawl`) scrape via their hosted API and reuse the same stored key as
+  // their web-search counterpart. The `mode` field is inherited from
+  // `BaseServiceSchema` for symmetry; web-fetch has no managed proxy today.
+  provider: z.enum(VALID_WEB_FETCH_PROVIDERS).default("default"),
+});
+
 const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("managed"),
 });
@@ -142,6 +159,7 @@ export const ServicesSchema = z.object({
   "web-search": WebSearchServiceSchema.default(
     WebSearchServiceSchema.parse({}),
   ),
+  "web-fetch": WebFetchServiceSchema.default(WebFetchServiceSchema.parse({})),
   stt: SttServiceSchema.default({
     mode: "your-own" as const,
     provider: "deepgram" as const,

package/src/config/seed-inference-profiles.ts

@@ -61,6 +61,9 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     effort: "high",
     thinking: { enabled: true, streamThinking: true },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+    // This is the advisor's own (strongest) profile: when it's also the chat
+    // profile there's nothing stronger to consult, so the advisor defaults off.
+    advisorEnabled: false,
   },
   "cost-optimized": {
     intent: "latency-optimized",
@@ -286,6 +289,12 @@ export function seedInferenceProfiles(
             : previous.label;
       }
       if ("status" in previous) next.status = previous.status;
+      // The per-profile advisor toggle is a user override — preserve it across
+      // reseeds so a user's choice survives reboots (the template value only
+      // seeds the initial default, e.g. off for quality-optimized).
+      if ("advisorEnabled" in previous) {
+        next.advisorEnabled = previous.advisorEnabled;
+      }
     }
     profiles[name] = next as ProfileEntry;
   }
@@ -369,6 +378,17 @@ export function seedInferenceProfiles(
     }
   }
 
+  // Advisor profile: default to the strongest managed profile when unset, so
+  // the advisor consults `quality-optimized` out of the box. Guarded on
+  // existence so it never names a missing profile (superRefine rejects that);
+  // off-platform/BYOK installs can repoint it at one of their own profiles.
+  if (
+    readString(llm.advisorProfile) === undefined &&
+    readObject(profiles["quality-optimized"]) !== null
+  ) {
+    llm.advisorProfile = "quality-optimized";
+  }
+
   // Profile ordering — ensure all seeded profiles appear in the order array.
   // "auto" is prepended so it appears first in the picker.
   const profileOrder = Array.isArray(llm.profileOrder)

package/src/daemon/message-types/web-activity.ts

@@ -9,7 +9,11 @@ export type WebSearchProviderId =
   | "anthropic-native"
   | "brave"
   | "perplexity"
-  | "tavily";
+  | "tavily"
+  | "firecrawl";
+
+/** Provider that backed a `web_fetch` call. `default` is the built-in fetcher. */
+export type WebFetchProviderId = "default" | "firecrawl";
 
 export interface WebSearchResultItem {
   rank: number; // 1-indexed
@@ -35,6 +39,8 @@ export interface WebSearchMetadata {
 export interface WebFetchMetadata {
   url: string;
   finalUrl: string;
+  /** Provider that served the fetch. Defaults to the built-in fetcher. */
+  provider?: WebFetchProviderId;
   status: number;
   contentType?: string;
   byteCount: number;

package/src/messaging/providers/slack/send.test.ts

@@ -20,12 +20,19 @@ mock.module("./api.js", () => ({
   callSlackApiForm: async () => ({}),
   completeSlackUpload: async () => {},
   SlackApiError: class SlackApiError extends Error {
-    slackError?: string;
+    readonly slackError: string | undefined;
+
+    constructor(slackError: string | undefined) {
+      super(slackError ?? "unknown");
+      this.slackError = slackError;
+    }
   },
   uploadToSlackUrl: async () => {},
 }));
 
-import { sendSlackAssistantThreadStatus } from "./send.js";
+const { SlackApiError } = await import("./api.js");
+const { sendSlackAssistantThreadStatus, sendSlackReply } =
+  await import("./send.js");
 
 describe("sendSlackAssistantThreadStatus", () => {
   beforeEach(() => {
@@ -75,3 +82,108 @@ describe("sendSlackAssistantThreadStatus", () => {
     });
   });
 });
+
+describe("sendSlackReply update path", () => {
+  const messageTs = "1700000000.000100";
+  const blocks = [
+    { type: "section", text: { type: "mrkdwn", text: "Final reply" } },
+  ];
+
+  beforeEach(() => {
+    callSlackApiMock.mockReset();
+    callSlackApiMock.mockImplementation(async () => ({ ok: true }));
+  });
+
+  test("retries chat.update without blocks on invalid_blocks instead of posting a duplicate", async () => {
+    callSlackApiMock
+      .mockImplementationOnce(async () => {
+        throw new SlackApiError("invalid_blocks");
+      })
+      .mockImplementationOnce(async () => ({ ok: true, ts: messageTs }));
+
+    const result = await sendSlackReply("C123", "Final reply", {
+      messageTs,
+      threadTs: "1700000000.000001",
+      blocks,
+    });
+
+    expect(result).toEqual({ ok: true, ts: messageTs });
+    // Two chat.update calls (with then without blocks); never chat.postMessage,
+    // so the placeholder is edited in place rather than duplicated.
+    expect(callSlackApiMock).toHaveBeenCalledTimes(2);
+    expect(callSlackApiMock).toHaveBeenNthCalledWith(1, "chat.update", {
+      channel: "C123",
+      text: "Final reply",
+      ts: messageTs,
+      blocks,
+    });
+    expect(callSlackApiMock).toHaveBeenNthCalledWith(2, "chat.update", {
+      channel: "C123",
+      text: "Final reply",
+      ts: messageTs,
+    });
+    const postMessageCalls = callSlackApiMock.mock.calls.filter(
+      (call) => call[0] === "chat.postMessage",
+    );
+    expect(postMessageCalls).toHaveLength(0);
+  });
+
+  test("falls back to chat.postMessage only after the no-block update retry also fails", async () => {
+    callSlackApiMock
+      .mockImplementationOnce(async () => {
+        throw new SlackApiError("invalid_blocks");
+      })
+      .mockImplementationOnce(async () => {
+        throw new SlackApiError("message_not_found");
+      })
+      .mockImplementationOnce(async () => ({
+        ok: true,
+        ts: "1700000000.000200",
+      }));
+
+    const result = await sendSlackReply("C123", "Final reply", {
+      messageTs,
+      threadTs: "1700000000.000001",
+      blocks,
+    });
+
+    expect(result).toEqual({ ok: true, ts: "1700000000.000200" });
+    expect(callSlackApiMock).toHaveBeenCalledTimes(3);
+    expect(callSlackApiMock.mock.calls[0]?.[0]).toBe("chat.update");
+    expect(callSlackApiMock.mock.calls[1]?.[0]).toBe("chat.update");
+    // The post fallback drops the rejected blocks.
+    expect(callSlackApiMock).toHaveBeenNthCalledWith(3, "chat.postMessage", {
+      channel: "C123",
+      text: "Final reply",
+      thread_ts: "1700000000.000001",
+    });
+  });
+
+  test("non-invalid_blocks update failure still falls back to chat.postMessage", async () => {
+    callSlackApiMock
+      .mockImplementationOnce(async () => {
+        throw new SlackApiError("internal_error");
+      })
+      .mockImplementationOnce(async () => ({
+        ok: true,
+        ts: "1700000000.000200",
+      }));
+
+    const result = await sendSlackReply("C123", "Final reply", {
+      messageTs,
+      threadTs: "1700000000.000001",
+      blocks,
+    });
+
+    expect(result).toEqual({ ok: true, ts: "1700000000.000200" });
+    // One failed chat.update, then a single chat.postMessage (no extra retry).
+    expect(callSlackApiMock).toHaveBeenCalledTimes(2);
+    expect(callSlackApiMock.mock.calls[0]?.[0]).toBe("chat.update");
+    expect(callSlackApiMock).toHaveBeenNthCalledWith(2, "chat.postMessage", {
+      channel: "C123",
+      text: "Final reply",
+      thread_ts: "1700000000.000001",
+      blocks,
+    });
+  });
+});