@openclaw/feishu 2026.5.2-beta.2 → 2026.5.3-beta.1

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

@@ -1,219 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,224 +0,0 @@
-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 });
-  });
-});