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

package/openclaw.plugin.json

@@ -6,6 +6,180 @@
   "channels": [
     "feishu"
   ],
+  "contracts": {
+    "tools": [
+      "feishu_app_scopes",
+      "feishu_bitable_create_app",
+      "feishu_bitable_create_field",
+      "feishu_bitable_create_record",
+      "feishu_bitable_get_meta",
+      "feishu_bitable_get_record",
+      "feishu_bitable_list_fields",
+      "feishu_bitable_list_records",
+      "feishu_bitable_update_record",
+      "feishu_chat",
+      "feishu_doc",
+      "feishu_drive",
+      "feishu_perm",
+      "feishu_wiki"
+    ]
+  },
+  "toolMetadata": {
+    "feishu_app_scopes": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_create_app": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_create_field": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_create_record": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_get_meta": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_get_record": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_list_fields": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_list_records": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_bitable_update_record": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_chat": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_doc": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_drive": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_perm": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    },
+    "feishu_wiki": {
+      "configSignals": [
+        {
+          "rootPath": "channels.feishu",
+          "required": [
+            "appId",
+            "appSecret"
+          ]
+        }
+      ]
+    }
+  },
   "channelEnvVars": {
     "feishu": [
       "FEISHU_APP_ID",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/feishu",
-  "version": "2026.5.1-beta.1",
+  "version": "2026.5.2-beta.2",
   "description": "OpenClaw Feishu/Lark channel plugin (community maintained by @m1heng)",
   "repository": {
     "type": "git",
@@ -16,7 +16,7 @@
     "openclaw": "workspace:*"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.4.25"
+    "openclaw": ">=2026.5.2-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -47,10 +47,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.4.25"
+      "pluginApi": ">=2026.5.2-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.5.1-beta.1"
+      "openclawVersion": "2026.5.2-beta.2"
     },
     "release": {
       "publishToClawHub": true,

package/src/channel.ts

@@ -1154,6 +1154,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount, FeishuProbeResul
       setup: feishuSetupAdapter,
       setupWizard: feishuSetupWizard,
       messaging: {
+        targetPrefixes: ["feishu", "lark"],
         normalizeTarget: (raw) => normalizeFeishuTarget(raw) ?? undefined,
         resolveDeliveryTarget: ({ conversationId, parentConversationId }) => {
           const directId = parseFeishuDirectConversationId(conversationId);

package/src/chat.test.ts

@@ -142,4 +142,55 @@ describe("registerFeishuChatTools", () => {
     );
     expect(registerTool).not.toHaveBeenCalled();
   });
+
+  it("preserves Feishu diagnostics from rejected member lookups", async () => {
+    const registerTool = vi.fn();
+    registerFeishuChatTools(
+      createChatToolApi({
+        config: {
+          channels: {
+            feishu: {
+              enabled: true,
+              appId: "app_id",
+              appSecret: "app_secret", // pragma: allowlist secret
+              tools: { chat: true },
+            },
+          },
+        },
+        registerTool,
+      }),
+    );
+
+    const tool = registerTool.mock.calls[0]?.[0];
+    contactUserGetMock.mockRejectedValueOnce(
+      Object.assign(new Error("Request failed with status code 400"), {
+        response: {
+          status: 400,
+          data: {
+            code: 99992360,
+            msg: "The request you send is not a valid {user_id} or not exists",
+            error: {
+              log_id: "20260429124800CHAT",
+              troubleshooter: "https://open.feishu.cn/search?log_id=20260429124800CHAT",
+            },
+          },
+        },
+      }),
+    );
+
+    const result = await tool.execute("tc_4", {
+      action: "member_info",
+      member_id: "ou_1",
+    });
+
+    expect(result.details.error).toContain('"http_status":400');
+    expect(result.details.error).toContain('"feishu_code":99992360');
+    expect(result.details.error).toContain(
+      '"feishu_msg":"The request you send is not a valid {user_id} or not exists"',
+    );
+    expect(result.details.error).toContain('"feishu_log_id":"20260429124800CHAT"');
+    expect(result.details.error).toContain(
+      '"feishu_troubleshooter":"https://open.feishu.cn/search?log_id=20260429124800CHAT"',
+    );
+  });
 });

package/src/chat.ts

@@ -1,9 +1,9 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import type { OpenClawPluginApi } from "../runtime-api.js";
 import { listEnabledFeishuAccounts } from "./accounts.js";
 import { FeishuChatSchema, type FeishuChatParams } from "./chat-schema.js";
 import { createFeishuClient } from "./client.js";
+import { formatFeishuApiError } from "./comment-shared.js";
 import { resolveToolsConfig } from "./tools-config.js";
 
 function json(data: unknown) {
@@ -179,7 +179,7 @@ export function registerFeishuChatTools(api: OpenClawPluginApi) {
               return json({ error: `Unknown action: ${String(p.action)}` });
           }
         } catch (err) {
-          return json({ error: formatErrorMessage(err) });
+          return json({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
         }
       },
     },

package/src/comment-shared.ts

@@ -41,6 +41,7 @@ export function formatFeishuApiError(
     (options.includeNestedErrorLogId
       ? readString(isRecord(responseData?.error) ? responseData.error.log_id : undefined)
       : undefined);
+  const nestedError = isRecord(responseData?.error) ? responseData.error : undefined;
 
   return JSON.stringify({
     message:
@@ -58,9 +59,49 @@ export function formatFeishuApiError(
       typeof responseData?.code === "number" ? responseData.code : readString(responseData?.code),
     feishu_msg: readString(responseData?.msg),
     feishu_log_id: feishuLogId,
+    feishu_troubleshooter:
+      readString(responseData?.troubleshooter) || readString(nestedError?.troubleshooter),
   });
 }
 
+function formatFeishuApiFailure(
+  error: unknown,
+  errorPrefix: string,
+  options: {
+    includeConfigParams?: boolean;
+    includeNestedErrorLogId?: boolean;
+  } = {},
+): string {
+  const details = formatFeishuApiError(error, options);
+  return `${errorPrefix}: ${details || "unknown error"}`;
+}
+
+export function createFeishuApiError(
+  error: unknown,
+  errorPrefix: string,
+  options: {
+    includeConfigParams?: boolean;
+    includeNestedErrorLogId?: boolean;
+  } = {},
+): Error {
+  return new Error(formatFeishuApiFailure(error, errorPrefix, options), { cause: error });
+}
+
+export async function requestFeishuApi<T>(
+  request: () => Promise<T>,
+  errorPrefix: string,
+  options: {
+    includeConfigParams?: boolean;
+    includeNestedErrorLogId?: boolean;
+  } = {},
+): Promise<T> {
+  try {
+    return await request();
+  } catch (error) {
+    throw createFeishuApiError(error, errorPrefix, options);
+  }
+}
+
 type ParsedCommentDocumentRef = {
   fileType?: CommentFileType;
   fileToken?: string;

package/src/dedup.ts

@@ -118,7 +118,7 @@ export async function tryRecordMessagePersistent(
   });
 }
 
-export async function hasRecordedMessagePersistent(
+async function hasRecordedMessagePersistent(
   messageId: string,
   namespace = "global",
   log?: (...args: unknown[]) => void,

package/src/directory.test.ts

@@ -8,15 +8,12 @@ vi.mock("./client.js", () => ({
   createFeishuClient: createFeishuClientMock,
 }));
 
-const {
-  listFeishuDirectoryGroups,
-  listFeishuDirectoryGroupsLive,
-  listFeishuDirectoryPeers,
-  listFeishuDirectoryPeersLive,
-} = await importFreshModule<typeof import("./directory.js")>(
-  import.meta.url,
-  "./directory.js?directory-test",
-);
+const { listFeishuDirectoryGroupsLive, listFeishuDirectoryPeersLive } = await importFreshModule<
+  typeof import("./directory.js")
+>(import.meta.url, "./directory.js?directory-test");
+const { listFeishuDirectoryGroups, listFeishuDirectoryPeers } = await importFreshModule<
+  typeof import("./directory.static.js")
+>(import.meta.url, "./directory.static.js?directory-test");
 
 function makeStaticCfg(): ClawdbotConfig {
   return {

package/src/directory.ts

@@ -9,8 +9,6 @@ import {
   type FeishuDirectoryPeer,
 } from "./directory.static.js";
 
-export { listFeishuDirectoryGroups, listFeishuDirectoryPeers } from "./directory.static.js";
-
 export async function listFeishuDirectoryPeersLive(params: {
   cfg: ClawdbotConfig;
   query?: string;

package/src/media.test.ts

@@ -384,6 +384,34 @@ describe("sendMediaFeishu msg_type routing", () => {
     );
   });
 
+  it("preserves Feishu diagnostics when media sends reject before response checks", async () => {
+    messageCreateMock.mockRejectedValueOnce(
+      Object.assign(new Error("Request failed with status code 400"), {
+        response: {
+          status: 400,
+          data: {
+            code: 9499,
+            msg: "Bad Request",
+            error: {
+              log_id: "20260429124731MEDIA",
+              troubleshooter: "https://open.feishu.cn/search?log_id=20260429124731MEDIA",
+            },
+          },
+        },
+      }),
+    );
+
+    const send = sendMediaFeishu({
+      cfg: emptyConfig,
+      to: "user:ou_target",
+      mediaBuffer: Buffer.from("image"),
+      fileName: "photo.png",
+    });
+
+    await expect(send).rejects.toThrow(/Feishu image send failed: .*"feishu_code":9499/);
+    await expect(send).rejects.toThrow(/"feishu_log_id":"20260429124731MEDIA"/);
+  });
+
   it("uses msg_type=media when replying with mp4", async () => {
     await sendMediaFeishu({
       cfg: emptyConfig,

package/src/media.ts

@@ -12,6 +12,7 @@ import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtim
 import type { ClawdbotConfig } from "../runtime-api.js";
 import { resolveFeishuRuntimeAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
+import { requestFeishuApi } from "./comment-shared.js";
 import { normalizeFeishuExternalKey } from "./external-keys.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
@@ -418,12 +419,17 @@ export async function uploadImageFeishu(params: {
   // See: https://github.com/larksuite/node-sdk/issues/121
   const imageData = typeof image === "string" ? fs.createReadStream(image) : image;
 
-  const response = await client.im.image.create({
-    data: {
-      image_type: imageType,
-      image: imageData,
-    },
-  });
+  const response = await requestFeishuApi(
+    () =>
+      client.im.image.create({
+        data: {
+          image_type: imageType,
+          image: imageData,
+        },
+      }),
+    "Feishu image upload failed",
+    { includeNestedErrorLogId: true },
+  );
 
   return {
     imageKey: extractFeishuUploadKey(response, {
@@ -469,14 +475,19 @@ export async function uploadFileFeishu(params: {
 
   const safeFileName = sanitizeFileNameForUpload(fileName);
 
-  const response = await client.im.file.create({
-    data: {
-      file_type: fileType,
-      file_name: safeFileName,
-      file: fileData,
-      ...(duration !== undefined && { duration }),
-    },
-  });
+  const response = await requestFeishuApi(
+    () =>
+      client.im.file.create({
+        data: {
+          file_type: fileType,
+          file_name: safeFileName,
+          file: fileData,
+          ...(duration !== undefined && { duration }),
+        },
+      }),
+    "Feishu file upload failed",
+    { includeNestedErrorLogId: true },
+  );
 
   return {
     fileKey: extractFeishuUploadKey(response, {
@@ -506,26 +517,36 @@ export async function sendImageFeishu(params: {
   const content = JSON.stringify({ image_key: imageKey });
 
   if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: "image",
-        ...(replyInThread ? { reply_in_thread: true } : {}),
-      },
-    });
+    const response = await requestFeishuApi(
+      () =>
+        client.im.message.reply({
+          path: { message_id: replyToMessageId },
+          data: {
+            content,
+            msg_type: "image",
+            ...(replyInThread ? { reply_in_thread: true } : {}),
+          },
+        }),
+      "Feishu image reply failed",
+      { includeNestedErrorLogId: true },
+    );
     assertFeishuMessageApiSuccess(response, "Feishu image reply failed");
     return toFeishuSendResult(response, receiveId);
   }
 
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: "image",
-    },
-  });
+  const response = await requestFeishuApi(
+    () =>
+      client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          content,
+          msg_type: "image",
+        },
+      }),
+    "Feishu image send failed",
+    { includeNestedErrorLogId: true },
+  );
   assertFeishuMessageApiSuccess(response, "Feishu image send failed");
   return toFeishuSendResult(response, receiveId);
 }
@@ -553,26 +574,36 @@ export async function sendFileFeishu(params: {
   const content = JSON.stringify({ file_key: fileKey });
 
   if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: msgType,
-        ...(replyInThread ? { reply_in_thread: true } : {}),
-      },
-    });
+    const response = await requestFeishuApi(
+      () =>
+        client.im.message.reply({
+          path: { message_id: replyToMessageId },
+          data: {
+            content,
+            msg_type: msgType,
+            ...(replyInThread ? { reply_in_thread: true } : {}),
+          },
+        }),
+      "Feishu file reply failed",
+      { includeNestedErrorLogId: true },
+    );
     assertFeishuMessageApiSuccess(response, "Feishu file reply failed");
     return toFeishuSendResult(response, receiveId);
   }
 
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: msgType,
-    },
-  });
+  const response = await requestFeishuApi(
+    () =>
+      client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          content,
+          msg_type: msgType,
+        },
+      }),
+    "Feishu file send failed",
+    { includeNestedErrorLogId: true },
+  );
   assertFeishuMessageApiSuccess(response, "Feishu file send failed");
   return toFeishuSendResult(response, receiveId);
 }

package/src/send.reply-fallback.test.ts

@@ -57,6 +57,34 @@ describe("Feishu reply fallback for withdrawn/deleted targets", () => {
     });
   });
 
+  it("preserves Feishu diagnostics when direct sends reject before response checks", async () => {
+    const apiError = Object.assign(new Error("Request failed with status code 400"), {
+      response: {
+        status: 400,
+        data: {
+          code: 9499,
+          msg: "Bad Request",
+          error: {
+            log_id: "202604291247104BEF4C42D2420A9AD569",
+            troubleshooter:
+              "https://open.feishu.cn/search?log_id=202604291247104BEF4C42D2420A9AD569",
+          },
+        },
+      },
+    });
+    createMock.mockRejectedValue(apiError);
+
+    await expect(
+      sendMessageFeishu({
+        cfg: {} as never,
+        to: "user:ou_target",
+        text: "hello",
+      }),
+    ).rejects.toThrow(
+      /Feishu send failed: .*"http_status":400.*"feishu_code":9499.*"feishu_msg":"Bad Request".*"feishu_log_id":"202604291247104BEF4C42D2420A9AD569".*"feishu_troubleshooter":"https:\/\/open\.feishu\.cn\/search\?log_id=202604291247104BEF4C42D2420A9AD569"/,
+    );
+  });
+
   it("falls back to create for withdrawn post replies", async () => {
     replyMock.mockResolvedValue({
       code: 230011,

package/src/send.ts

@@ -7,6 +7,7 @@ import {
 import type { ClawdbotConfig } from "../runtime-api.js";
 import { resolveFeishuRuntimeAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
+import { createFeishuApiError, requestFeishuApi } from "./comment-shared.js";
 import type { MentionTarget } from "./mention-target.types.js";
 import { buildMentionedCardContent, buildMentionedMessage } from "./mention.js";
 import { parsePostContent } from "./post.js";
@@ -117,14 +118,19 @@ async function sendFallbackDirect(
   },
   errorPrefix: string,
 ): Promise<FeishuSendResult> {
-  const response = await client.im.message.create({
-    params: { receive_id_type: params.receiveIdType },
-    data: {
-      receive_id: params.receiveId,
-      content: params.content,
-      msg_type: params.msgType,
-    },
-  });
+  const response = await requestFeishuApi(
+    () =>
+      client.im.message.create({
+        params: { receive_id_type: params.receiveIdType },
+        data: {
+          receive_id: params.receiveId,
+          content: params.content,
+          msg_type: params.msgType,
+        },
+      }),
+    errorPrefix,
+    { includeNestedErrorLogId: true },
+  );
   assertFeishuMessageApiSuccess(response, errorPrefix);
   return toFeishuSendResult(response, params.receiveId);
 }
@@ -168,7 +174,7 @@ async function sendReplyOrFallbackDirect(
     });
   } catch (err) {
     if (!isWithdrawnReplyError(err)) {
-      throw err;
+      throw createFeishuApiError(err, params.replyErrorPrefix, { includeNestedErrorLogId: true });
     }
     if (threadReplyFallbackError) {
       throw threadReplyFallbackError;

package/src/test-support/lifecycle-test-support.ts

@@ -2,7 +2,6 @@ import { randomUUID } from "node:crypto";
 import { createPluginRuntimeMock } from "openclaw/plugin-sdk/channel-test-helpers";
 import { expect, vi, type Mock } from "vitest";
 import type { ClawdbotConfig, PluginRuntime, RuntimeEnv } from "../../runtime-api.js";
-import { createFeishuMessageReceiveHandler } from "../monitor.message-handler.js";
 import { setFeishuRuntime } from "../runtime.js";
 import type { ResolvedFeishuAccount } from "../types.js";
 
@@ -411,31 +410,6 @@ async function loadMonitorSingleAccount() {
   return module.monitorSingleAccount;
 }
 
-export async function setupFeishuMessageReceiveLifecycleHandler(params: {
-  runtime: RuntimeEnv;
-  core: PluginRuntime;
-  cfg: ClawdbotConfig;
-  accountId: string;
-  fireAndForget?: boolean;
-  handleMessage: Parameters<typeof createFeishuMessageReceiveHandler>[0]["handleMessage"];
-  resolveDebounceText: Parameters<
-    typeof createFeishuMessageReceiveHandler
-  >[0]["resolveDebounceText"];
-}): Promise<(data: unknown) => Promise<void>> {
-  return createFeishuMessageReceiveHandler({
-    cfg: params.cfg,
-    core: params.core,
-    accountId: params.accountId,
-    runtime: params.runtime,
-    chatHistories: new Map(),
-    fireAndForget: params.fireAndForget,
-    handleMessage: params.handleMessage,
-    resolveDebounceText: params.resolveDebounceText,
-    hasProcessedMessage: vi.fn(async () => false),
-    recordProcessedMessage: vi.fn(async () => true),
-  });
-}
-
 export async function setupFeishuLifecycleHandler(params: {
   createEventDispatcherMock: {
     mockReturnValue: (value: unknown) => unknown;

package/src/monitor.reply-once.lifecycle.test-support.ts

@@ -1,190 +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,
-  createFeishuTextMessageEvent,
-  expectFeishuReplyDispatcherSentFinalReplyOnce,
-  expectFeishuReplyPipelineDedupedAcrossReplay,
-  expectFeishuReplyPipelineDedupedAfterPostSendFailure,
-  installFeishuLifecycleReplyRuntime,
-  mockFeishuReplyOnceDispatch,
-  restoreFeishuLifecycleStateDir,
-  setFeishuLifecycleStateDir,
-  setupFeishuMessageReceiveLifecycleHandler,
-} from "./test-support/lifecycle-test-support.js";
-
-const {
-  createFeishuReplyDispatcherMock,
-  dispatchReplyFromConfigMock,
-  finalizeInboundContextMock,
-  resolveAgentRouteMock,
-  withReplyDispatcherMock,
-} = getFeishuLifecycleTestMocks();
-
-let lastRuntime = createRuntimeEnv();
-let lifecycleCore: ReturnType<typeof installFeishuLifecycleReplyRuntime>;
-const handleMessageMock = vi.fn();
-const originalStateDir = process.env.OPENCLAW_STATE_DIR;
-const lifecycleConfig = createFeishuLifecycleConfig({
-  accountId: "acct-lifecycle",
-  appId: "cli_test",
-  appSecret: "secret_test",
-  accountConfig: {
-    groupPolicy: "open",
-    groups: {
-      oc_group_1: {
-        requireMention: false,
-        groupSessionScope: "group_topic_sender",
-        replyInThread: "enabled",
-      },
-    },
-  },
-});
-
-async function setupLifecycleMonitor() {
-  lastRuntime = createRuntimeEnv();
-  return setupFeishuMessageReceiveLifecycleHandler({
-    runtime: lastRuntime,
-    core: lifecycleCore,
-    cfg: lifecycleConfig,
-    accountId: "acct-lifecycle",
-    handleMessage: handleMessageMock,
-    resolveDebounceText: ({ event }) => {
-      const parsed = JSON.parse(event.message.content) as { text?: string };
-      return parsed.text ?? "";
-    },
-  });
-}
-
-describe("Feishu reply-once lifecycle", () => {
-  beforeEach(() => {
-    vi.useRealTimers();
-    resetFeishuLifecycleTestMocks();
-    handleMessageMock.mockReset();
-    lastRuntime = createRuntimeEnv();
-    setFeishuLifecycleStateDir("openclaw-feishu-lifecycle");
-
-    createFeishuReplyDispatcherMock.mockReturnValue(createFeishuLifecycleReplyDispatcher());
-
-    resolveAgentRouteMock.mockReturnValue({
-      agentId: "main",
-      channel: "feishu",
-      accountId: "acct-lifecycle",
-      sessionKey: "agent:main:feishu:group:oc_group_1",
-      mainSessionKey: "agent:main:main",
-      matchedBy: "default",
-    });
-
-    mockFeishuReplyOnceDispatch({
-      dispatchReplyFromConfigMock,
-      replyText: "reply once",
-    });
-
-    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
-    handleMessageMock.mockImplementation(async ({ event }) => {
-      const reply = createFeishuReplyDispatcherMock({
-        accountId: "acct-lifecycle",
-        chatId: event.message.chat_id,
-        replyToMessageId: event.message.root_id ?? event.message.message_id,
-        replyInThread: true,
-        rootId: event.message.root_id,
-      });
-      try {
-        await withReplyDispatcherMock({
-          dispatcher: reply.dispatcher,
-          onSettled: () => reply.markDispatchIdle(),
-          run: () =>
-            dispatchReplyFromConfigMock({
-              ctx: {
-                AccountId: "acct-lifecycle",
-                MessageSid: event.message.message_id,
-              },
-              dispatcher: reply.dispatcher,
-            }),
-        });
-      } catch (err) {
-        lastRuntime?.error(`feishu[acct-lifecycle]: failed to dispatch message: ${String(err)}`);
-      }
-    });
-
-    lifecycleCore = installFeishuLifecycleReplyRuntime({
-      resolveAgentRouteMock,
-      finalizeInboundContextMock,
-      dispatchReplyFromConfigMock,
-      withReplyDispatcherMock,
-      storePath: "/tmp/feishu-lifecycle-sessions.json",
-    });
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    restoreFeishuLifecycleStateDir(originalStateDir);
-  });
-
-  it("routes a topic-bound inbound event and emits one reply across duplicate replay", async () => {
-    const onMessage = await setupLifecycleMonitor();
-    const event = createFeishuTextMessageEvent({
-      messageId: "om_lifecycle_once",
-      chatId: "oc_group_1",
-      rootId: "om_root_topic_1",
-      threadId: "omt_topic_1",
-      text: "hello from topic",
-    });
-
-    await expectFeishuReplyPipelineDedupedAcrossReplay({
-      handler: onMessage,
-      event,
-      dispatchReplyFromConfigMock,
-      createFeishuReplyDispatcherMock,
-    });
-
-    expect(lastRuntime?.error).not.toHaveBeenCalled();
-    expect(handleMessageMock).toHaveBeenCalledTimes(1);
-    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
-    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
-    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        accountId: "acct-lifecycle",
-        chatId: "oc_group_1",
-        replyToMessageId: "om_root_topic_1",
-        replyInThread: true,
-        rootId: "om_root_topic_1",
-      }),
-    );
-    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
-  });
-
-  it("does not duplicate delivery when the first attempt fails after sending the reply", async () => {
-    const onMessage = await setupLifecycleMonitor();
-    const event = createFeishuTextMessageEvent({
-      messageId: "om_lifecycle_retry",
-      chatId: "oc_group_1",
-      rootId: "om_root_topic_1",
-      threadId: "omt_topic_1",
-      text: "hello from topic",
-    });
-
-    dispatchReplyFromConfigMock.mockImplementationOnce(async ({ dispatcher }) => {
-      await dispatcher.sendFinalReply({ text: "reply once" });
-      throw new Error("post-send failure");
-    });
-
-    await expectFeishuReplyPipelineDedupedAfterPostSendFailure({
-      handler: onMessage,
-      event,
-      dispatchReplyFromConfigMock,
-      runtimeErrorMock: lastRuntime?.error as ReturnType<typeof vi.fn>,
-    });
-
-    expect(lastRuntime?.error).toHaveBeenCalledTimes(1);
-    expect(handleMessageMock).toHaveBeenCalledTimes(1);
-    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
-    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
-  });
-});