@openclaw/feishu 2026.3.13 → 2026.5.1-beta.1

package/src/monitor.acp-init-failure.lifecycle.test-support.ts

@@ -0,0 +1,219 @@
+import "./lifecycle.test-support.js";
+import { createRuntimeEnv } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClawdbotConfig } from "../runtime-api.js";
+import {
+  getFeishuLifecycleTestMocks,
+  resetFeishuLifecycleTestMocks,
+} from "./lifecycle.test-support.js";
+import {
+  createFeishuLifecycleFixture,
+  createFeishuTextMessageEvent,
+  expectFeishuSingleEffectAcrossReplay,
+  installFeishuLifecycleReplyRuntime,
+  restoreFeishuLifecycleStateDir,
+  setFeishuLifecycleStateDir,
+  setupFeishuLifecycleHandler,
+} from "./test-support/lifecycle-test-support.js";
+import type { ResolvedFeishuAccount } from "./types.js";
+
+const {
+  createEventDispatcherMock,
+  dispatchReplyFromConfigMock,
+  ensureConfiguredBindingRouteReadyMock,
+  finalizeInboundContextMock,
+  resolveAgentRouteMock,
+  resolveBoundConversationMock,
+  resolveConfiguredBindingRouteMock,
+  sendMessageFeishuMock,
+  withReplyDispatcherMock,
+} = getFeishuLifecycleTestMocks();
+
+let _handlers: Record<string, (data: unknown) => Promise<void>> = {};
+let lastRuntime = createRuntimeEnv();
+const originalStateDir = process.env.OPENCLAW_STATE_DIR;
+const { cfg: lifecycleConfig, account: lifecycleAccount } = createFeishuLifecycleFixture({
+  accountId: "acct-acp",
+  appId: "cli_test",
+  appSecret: "secret_test",
+  channelConfig: {
+    groupPolicy: "open",
+    allowFrom: ["ou_sender_1"],
+  },
+  accountConfig: {
+    groupPolicy: "open",
+    groups: {
+      oc_group_topic: {
+        requireMention: false,
+        groupSessionScope: "group_topic",
+        replyInThread: "enabled",
+      },
+    },
+  },
+  extraConfig: {
+    session: { mainKey: "main", scope: "per-sender" },
+  },
+}) as {
+  cfg: ClawdbotConfig;
+  account: ResolvedFeishuAccount;
+};
+
+async function setupLifecycleMonitor() {
+  lastRuntime = createRuntimeEnv();
+  return setupFeishuLifecycleHandler({
+    createEventDispatcherMock,
+    onRegister: (registered) => {
+      _handlers = registered;
+    },
+    runtime: lastRuntime,
+    cfg: lifecycleConfig,
+    account: lifecycleAccount,
+    handlerKey: "im.message.receive_v1",
+    missingHandlerMessage: "missing im.message.receive_v1 handler",
+  });
+}
+
+describe("Feishu ACP-init failure lifecycle", () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+    resetFeishuLifecycleTestMocks();
+    _handlers = {};
+    lastRuntime = createRuntimeEnv();
+    setFeishuLifecycleStateDir("openclaw-feishu-acp-failure");
+
+    resolveBoundConversationMock.mockReturnValue(null);
+    resolveAgentRouteMock.mockReturnValue({
+      agentId: "main",
+      channel: "feishu",
+      accountId: "acct-acp",
+      sessionKey: "agent:main:feishu:group:oc_group_topic",
+      mainSessionKey: "agent:main:main",
+      matchedBy: "default",
+    });
+    resolveConfiguredBindingRouteMock.mockReturnValue({
+      bindingResolution: {
+        configuredBinding: {
+          spec: {
+            channel: "feishu",
+            accountId: "acct-acp",
+            conversationId: "oc_group_topic:topic:om_topic_root_1",
+            agentId: "codex",
+            mode: "persistent",
+          },
+          record: {
+            bindingId: "config:acp:feishu:acct-acp:oc_group_topic:topic:om_topic_root_1",
+            targetSessionKey: "agent:codex:acp:binding:feishu:acct-acp:abc123",
+            targetKind: "session",
+            conversation: {
+              channel: "feishu",
+              accountId: "acct-acp",
+              conversationId: "oc_group_topic:topic:om_topic_root_1",
+              parentConversationId: "oc_group_topic",
+            },
+            status: "active",
+            boundAt: 0,
+            metadata: { source: "config" },
+          },
+        },
+        statefulTarget: {
+          kind: "stateful",
+          driverId: "acp",
+          sessionKey: "agent:codex:acp:binding:feishu:acct-acp:abc123",
+          agentId: "codex",
+        },
+      },
+      configuredBinding: {
+        spec: {
+          channel: "feishu",
+          accountId: "acct-acp",
+          conversationId: "oc_group_topic:topic:om_topic_root_1",
+          agentId: "codex",
+          mode: "persistent",
+        },
+      },
+      route: {
+        agentId: "codex",
+        channel: "feishu",
+        accountId: "acct-acp",
+        sessionKey: "agent:codex:acp:binding:feishu:acct-acp:abc123",
+        mainSessionKey: "agent:codex:main",
+        matchedBy: "binding.channel",
+      },
+    });
+    ensureConfiguredBindingRouteReadyMock.mockResolvedValue({
+      ok: false,
+      error: "runtime unavailable",
+    });
+
+    dispatchReplyFromConfigMock.mockResolvedValue({
+      queuedFinal: false,
+      counts: { final: 0 },
+    });
+    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
+
+    installFeishuLifecycleReplyRuntime({
+      resolveAgentRouteMock,
+      finalizeInboundContextMock,
+      dispatchReplyFromConfigMock,
+      withReplyDispatcherMock,
+      storePath: "/tmp/feishu-acp-failure-sessions.json",
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    restoreFeishuLifecycleStateDir(originalStateDir);
+  });
+
+  it("sends one ACP failure notice to the topic root across replay", async () => {
+    const onMessage = await setupLifecycleMonitor();
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_topic_msg_1",
+      chatId: "oc_group_topic",
+      rootId: "om_topic_root_1",
+      threadId: "omt_topic_1",
+      text: "hello topic",
+    });
+
+    await expectFeishuSingleEffectAcrossReplay({
+      handler: onMessage,
+      event,
+      effectMock: sendMessageFeishuMock,
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(resolveConfiguredBindingRouteMock).toHaveBeenCalledTimes(1);
+    expect(ensureConfiguredBindingRouteReadyMock).toHaveBeenCalledTimes(1);
+    expect(sendMessageFeishuMock).toHaveBeenCalledTimes(1);
+    expect(sendMessageFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "acct-acp",
+        to: "chat:oc_group_topic",
+        replyToMessageId: "om_topic_root_1",
+        replyInThread: true,
+        text: expect.stringContaining("runtime unavailable"),
+      }),
+    );
+    expect(dispatchReplyFromConfigMock).not.toHaveBeenCalled();
+  });
+
+  it("does not duplicate the ACP failure notice after the first send succeeds", async () => {
+    const onMessage = await setupLifecycleMonitor();
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_topic_msg_2",
+      chatId: "oc_group_topic",
+      rootId: "om_topic_root_1",
+      threadId: "omt_topic_1",
+      text: "hello topic",
+    });
+
+    await expectFeishuSingleEffectAcrossReplay({
+      handler: onMessage,
+      event,
+      effectMock: sendMessageFeishuMock,
+    });
+
+    expect(sendMessageFeishuMock).toHaveBeenCalledTimes(1);
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+  });
+});

package/src/monitor.bot-identity.ts

@@ -0,0 +1,86 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import type { RuntimeEnv } from "../runtime-api.js";
+import { waitForAbortableDelay } from "./async.js";
+import { fetchBotIdentityForMonitor, type FeishuMonitorBotIdentity } from "./monitor.startup.js";
+import { botNames, botOpenIds } from "./monitor.state.js";
+import type { ResolvedFeishuAccount } from "./types.js";
+
+// Delays must be >= PROBE_ERROR_TTL_MS (60s) so each retry makes a real network request
+// instead of silently hitting the probe error cache.
+const BOT_IDENTITY_RETRY_DELAYS_MS = [60_000, 120_000, 300_000, 600_000, 900_000];
+
+export function applyBotIdentityState(
+  accountId: string,
+  identity: FeishuMonitorBotIdentity,
+): { botOpenId?: string; botName?: string } {
+  const botOpenId = normalizeOptionalString(identity.botOpenId);
+  const botName = normalizeOptionalString(identity.botName);
+
+  botOpenIds.set(accountId, botOpenId ?? "");
+  if (botName) {
+    botNames.set(accountId, botName);
+  } else {
+    botNames.delete(accountId);
+  }
+
+  return { botOpenId, botName };
+}
+
+async function retryBotIdentityProbe(
+  account: ResolvedFeishuAccount,
+  accountId: string,
+  runtime: RuntimeEnv | undefined,
+  abortSignal: AbortSignal | undefined,
+): Promise<void> {
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  for (let i = 0; i < BOT_IDENTITY_RETRY_DELAYS_MS.length; i += 1) {
+    if (abortSignal?.aborted) {
+      return;
+    }
+
+    const delayElapsed = await waitForAbortableDelay(BOT_IDENTITY_RETRY_DELAYS_MS[i], abortSignal);
+    if (!delayElapsed) {
+      return;
+    }
+
+    const identity = await fetchBotIdentityForMonitor(account, { runtime, abortSignal });
+    const resolved = applyBotIdentityState(accountId, identity);
+    if (resolved.botOpenId) {
+      log(
+        `feishu[${accountId}]: bot open_id recovered via background retry: ${resolved.botOpenId}`,
+      );
+      return;
+    }
+
+    const nextDelay = BOT_IDENTITY_RETRY_DELAYS_MS[i + 1];
+    error(
+      `feishu[${accountId}]: bot identity background retry ${i + 1}/${BOT_IDENTITY_RETRY_DELAYS_MS.length} failed` +
+        (nextDelay ? `; next attempt in ${nextDelay / 1000}s` : ""),
+    );
+  }
+
+  error(
+    `feishu[${accountId}]: bot identity background retry exhausted; requireMention group messages may be skipped until restart`,
+  );
+}
+
+export function startBotIdentityRecovery(params: {
+  account: ResolvedFeishuAccount;
+  accountId: string;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+}): void {
+  const { account, accountId, runtime, abortSignal } = params;
+  const log = runtime?.log ?? console.log;
+
+  log(
+    `feishu[${accountId}]: bot open_id unknown; starting background retry (delays: ${BOT_IDENTITY_RETRY_DELAYS_MS.map((delay) => `${delay / 1000}s`).join(", ")})`,
+  );
+  log(
+    `feishu[${accountId}]: requireMention group messages stay gated until bot identity recovery succeeds`,
+  );
+
+  void retryBotIdentityProbe(account, accountId, runtime, abortSignal);
+}

package/src/monitor.bot-menu-handler.ts

@@ -0,0 +1,165 @@
+import type { ClawdbotConfig, HistoryEntry, RuntimeEnv } from "../runtime-api.js";
+import { handleFeishuMessage, type FeishuMessageEvent } from "./bot.js";
+import { maybeHandleFeishuQuickActionMenu } from "./card-ux-launcher.js";
+import {
+  claimUnprocessedFeishuMessage,
+  recordProcessedFeishuMessage,
+  releaseFeishuMessageProcessing,
+} from "./dedup.js";
+import { botNames, botOpenIds } from "./monitor.state.js";
+import { isFeishuRetryableSyntheticEventError } from "./monitor.synthetic-error.js";
+
+type FeishuBotMenuEvent = {
+  event_key?: string;
+  timestamp?: string | number;
+  operator?: {
+    operator_name?: string;
+    operator_id?: { open_id?: string; user_id?: string; union_id?: string };
+  };
+};
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function readStringOrNumber(value: unknown): string | number | undefined {
+  return typeof value === "string" || typeof value === "number" ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseFeishuBotMenuEvent(value: unknown): FeishuBotMenuEvent | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const operator = value.operator;
+  if (operator !== undefined && !isRecord(operator)) {
+    return null;
+  }
+  return {
+    event_key: readString(value.event_key),
+    timestamp: readStringOrNumber(value.timestamp),
+    operator: operator
+      ? {
+          operator_name: readString(operator.operator_name),
+          operator_id: isRecord(operator.operator_id)
+            ? {
+                open_id: readString(operator.operator_id.open_id),
+                user_id: readString(operator.operator_id.user_id),
+                union_id: readString(operator.operator_id.union_id),
+              }
+            : undefined,
+        }
+      : undefined,
+  };
+}
+
+export function createFeishuBotMenuHandler(params: {
+  cfg: ClawdbotConfig;
+  accountId: string;
+  runtime?: RuntimeEnv;
+  chatHistories: Map<string, HistoryEntry[]>;
+  fireAndForget?: boolean;
+  getBotOpenId?: (accountId: string) => string | undefined;
+  getBotName?: (accountId: string) => string | undefined;
+}): (data: unknown) => Promise<void> {
+  const { cfg, accountId, runtime, chatHistories, fireAndForget } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+  const getBotOpenId = params.getBotOpenId ?? ((id) => botOpenIds.get(id));
+  const getBotName = params.getBotName ?? ((id) => botNames.get(id));
+
+  return async (data) => {
+    try {
+      const event = parseFeishuBotMenuEvent(data);
+      if (!event) {
+        return;
+      }
+      const operatorOpenId = event.operator?.operator_id?.open_id?.trim();
+      const eventKey = event.event_key?.trim();
+      if (!operatorOpenId || !eventKey) {
+        return;
+      }
+      const syntheticEvent: FeishuMessageEvent = {
+        sender: {
+          sender_id: {
+            open_id: operatorOpenId,
+            user_id: event.operator?.operator_id?.user_id,
+            union_id: event.operator?.operator_id?.union_id,
+          },
+          sender_type: "user",
+        },
+        message: {
+          message_id: `bot-menu:${eventKey}:${event.timestamp ?? Date.now()}`,
+          suppress_reply_target: true,
+          chat_id: `p2p:${operatorOpenId}`,
+          chat_type: "p2p",
+          message_type: "text",
+          content: JSON.stringify({
+            text: `/menu ${eventKey}`,
+          }),
+        },
+      };
+      const syntheticMessageId = syntheticEvent.message.message_id;
+      const claim = await claimUnprocessedFeishuMessage({
+        messageId: syntheticMessageId,
+        namespace: accountId,
+        log,
+      });
+      if (claim === "duplicate") {
+        log(`feishu[${accountId}]: dropping duplicate bot-menu event for ${syntheticMessageId}`);
+        return;
+      }
+      if (claim === "inflight") {
+        log(`feishu[${accountId}]: dropping in-flight bot-menu event for ${syntheticMessageId}`);
+        return;
+      }
+      const handleLegacyMenu = () =>
+        handleFeishuMessage({
+          cfg,
+          event: syntheticEvent,
+          botOpenId: getBotOpenId(accountId),
+          botName: getBotName(accountId),
+          runtime,
+          chatHistories,
+          accountId,
+          processingClaimHeld: true,
+        });
+
+      const promise = maybeHandleFeishuQuickActionMenu({
+        cfg,
+        eventKey,
+        operatorOpenId,
+        runtime,
+        accountId,
+      })
+        .then(async (handledMenu) => {
+          if (handledMenu) {
+            await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+            releaseFeishuMessageProcessing(syntheticMessageId, accountId);
+            return;
+          }
+          return await handleLegacyMenu();
+        })
+        .catch(async (err) => {
+          if (isFeishuRetryableSyntheticEventError(err)) {
+            releaseFeishuMessageProcessing(syntheticMessageId, accountId);
+          } else {
+            await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+          }
+          throw err;
+        });
+      if (fireAndForget) {
+        promise.catch((err) => {
+          error(`feishu[${accountId}]: error handling bot menu event: ${String(err)}`);
+        });
+        return;
+      }
+      await promise;
+    } catch (err) {
+      error(`feishu[${accountId}]: error handling bot menu event: ${String(err)}`);
+    }
+  };
+}

package/src/monitor.bot-menu.lifecycle.test-support.ts

@@ -0,0 +1,224 @@
+import { createRuntimeEnv } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import "./lifecycle.test-support.js";
+import {
+  getFeishuLifecycleTestMocks,
+  resetFeishuLifecycleTestMocks,
+} from "./lifecycle.test-support.js";
+import {
+  createFeishuLifecycleConfig,
+  createFeishuLifecycleReplyDispatcher,
+  createResolvedFeishuLifecycleAccount,
+  expectFeishuReplyDispatcherSentFinalReplyOnce,
+  expectFeishuReplyPipelineDedupedAcrossReplay,
+  expectFeishuReplyPipelineDedupedAfterPostSendFailure,
+  expectFeishuSingleEffectAcrossReplay,
+  installFeishuLifecycleReplyRuntime,
+  mockFeishuReplyOnceDispatch,
+  restoreFeishuLifecycleStateDir,
+  setFeishuLifecycleStateDir,
+  setupFeishuLifecycleHandler,
+} from "./test-support/lifecycle-test-support.js";
+
+const {
+  createEventDispatcherMock,
+  createFeishuReplyDispatcherMock,
+  dispatchReplyFromConfigMock,
+  finalizeInboundContextMock,
+  resolveAgentRouteMock,
+  resolveBoundConversationMock,
+  sendCardFeishuMock,
+  touchBindingMock,
+  withReplyDispatcherMock,
+} = getFeishuLifecycleTestMocks();
+
+let _handlers: Record<string, (data: unknown) => Promise<void>> = {};
+let lastRuntime = createRuntimeEnv();
+const originalStateDir = process.env.OPENCLAW_STATE_DIR;
+const lifecycleConfig = createFeishuLifecycleConfig({
+  accountId: "acct-menu",
+  appId: "cli_test",
+  appSecret: "secret_test",
+  channelConfig: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+  accountConfig: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+});
+
+const lifecycleAccount = createResolvedFeishuLifecycleAccount({
+  accountId: "acct-menu",
+  appId: "cli_test",
+  appSecret: "secret_test",
+  config: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+});
+
+function createBotMenuEvent(params: { eventKey: string; timestamp: string }) {
+  return {
+    event_key: params.eventKey,
+    timestamp: params.timestamp,
+    operator: {
+      operator_id: {
+        open_id: "ou_user1",
+        user_id: "user_1",
+        union_id: "union_1",
+      },
+    },
+  };
+}
+
+async function setupLifecycleMonitor() {
+  lastRuntime = createRuntimeEnv();
+  return setupFeishuLifecycleHandler({
+    createEventDispatcherMock,
+    onRegister: (registered) => {
+      _handlers = registered;
+    },
+    runtime: lastRuntime,
+    cfg: lifecycleConfig,
+    account: lifecycleAccount,
+    handlerKey: "application.bot.menu_v6",
+    missingHandlerMessage: "missing application.bot.menu_v6 handler",
+  });
+}
+
+describe("Feishu bot-menu lifecycle", () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+    resetFeishuLifecycleTestMocks();
+    _handlers = {};
+    lastRuntime = createRuntimeEnv();
+    setFeishuLifecycleStateDir("openclaw-feishu-bot-menu");
+
+    createFeishuReplyDispatcherMock.mockReturnValue(createFeishuLifecycleReplyDispatcher());
+
+    resolveBoundConversationMock.mockImplementation(() => ({
+      bindingId: "binding-menu",
+      targetSessionKey: "agent:bound-agent:feishu:direct:ou_user1",
+    }));
+
+    resolveAgentRouteMock.mockReturnValue({
+      agentId: "main",
+      channel: "feishu",
+      accountId: "acct-menu",
+      sessionKey: "agent:main:feishu:direct:ou_user1",
+      mainSessionKey: "agent:main:main",
+      matchedBy: "default",
+    });
+
+    mockFeishuReplyOnceDispatch({
+      dispatchReplyFromConfigMock,
+      replyText: "menu reply once",
+    });
+
+    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
+
+    installFeishuLifecycleReplyRuntime({
+      resolveAgentRouteMock,
+      finalizeInboundContextMock,
+      dispatchReplyFromConfigMock,
+      withReplyDispatcherMock,
+      storePath: "/tmp/feishu-bot-menu-sessions.json",
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    restoreFeishuLifecycleStateDir(originalStateDir);
+  });
+
+  it("opens one launcher card across duplicate quick-actions replay", async () => {
+    const onBotMenu = await setupLifecycleMonitor();
+    const event = createBotMenuEvent({
+      eventKey: "quick-actions",
+      timestamp: "1700000000000",
+    });
+
+    await expectFeishuSingleEffectAcrossReplay({
+      handler: onBotMenu,
+      event,
+      effectMock: sendCardFeishuMock,
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(sendCardFeishuMock).toHaveBeenCalledTimes(1);
+    expect(sendCardFeishuMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "acct-menu",
+        to: "user:ou_user1",
+      }),
+    );
+    expect(dispatchReplyFromConfigMock).not.toHaveBeenCalled();
+    expect(createFeishuReplyDispatcherMock).not.toHaveBeenCalled();
+  });
+
+  it("falls back once to the legacy routed reply path when launcher rendering fails", async () => {
+    const onBotMenu = await setupLifecycleMonitor();
+    const event = createBotMenuEvent({
+      eventKey: "quick-actions",
+      timestamp: "1700000000001",
+    });
+    sendCardFeishuMock.mockRejectedValueOnce(new Error("boom"));
+
+    await expectFeishuReplyPipelineDedupedAcrossReplay({
+      handler: onBotMenu,
+      event,
+      dispatchReplyFromConfigMock,
+      createFeishuReplyDispatcherMock,
+      waitTimeoutMs: 5_000,
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(sendCardFeishuMock).toHaveBeenCalledTimes(1);
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "acct-menu",
+        chatId: "p2p:ou_user1",
+        replyToMessageId: undefined,
+      }),
+    );
+    expect(finalizeInboundContextMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        AccountId: "acct-menu",
+        SessionKey: "agent:bound-agent:feishu:direct:ou_user1",
+        MessageSid: "bot-menu:quick-actions:1700000000001",
+      }),
+    );
+    expect(touchBindingMock).toHaveBeenCalledWith("binding-menu");
+
+    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
+  });
+
+  it("does not duplicate delivery when launcher fallback hits a post-send failure", async () => {
+    const onBotMenu = await setupLifecycleMonitor();
+    const event = createBotMenuEvent({
+      eventKey: "quick-actions",
+      timestamp: "1700000000002",
+    });
+    sendCardFeishuMock.mockRejectedValueOnce(new Error("boom"));
+    dispatchReplyFromConfigMock.mockImplementationOnce(async ({ dispatcher }) => {
+      await dispatcher.sendFinalReply({ text: "menu reply once" });
+      throw new Error("post-send failure");
+    });
+
+    await expectFeishuReplyPipelineDedupedAfterPostSendFailure({
+      handler: onBotMenu,
+      event,
+      dispatchReplyFromConfigMock,
+      runtimeErrorMock: lastRuntime?.error as ReturnType<typeof vi.fn>,
+      waitTimeoutMs: 5_000,
+    });
+
+    expect(sendCardFeishuMock).toHaveBeenCalledTimes(1);
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
+  });
+});