lark-remote 0.4.1 → 0.4.3

package/dist/connector/index.js

@@ -47,7 +47,7 @@ const noKeepAliveAgent = new https.Agent({ keepAlive: false });
  */
 export const DEDUP_TTL_MS = 300;
 /**
- * SDK converter 注册表支持的 msg_type（@larksuite/channel 0.3.0 实测）。
+ * SDK converter 注册表支持的 msg_type（@larksuite/channel 0.7.1 实测）。
  * 带资源但类型不在其中 = 未来新增类型：照常下载 + warn（default-deny）。
  */
 const KNOWN_RESOURCE_CONTENT_TYPES = new Set([
@@ -85,9 +85,22 @@ const RESOURCE_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000;
 const MERGE_FORWARD_HINT = {
     merge_forward: '（合并转发里的附件暂不支持保存，可逐条转发或直接发送文件）',
 };
-function withTimeout(promise, ms, label) {
+/** withTimeout 的超时专用错误：catch 侧据此知道清理已交给补删路径。 */
+class ResourceTimeoutError extends Error {
+}
+/**
+ * 给没有超时的 SDK 调用套一层超时。**超时只是不再等它，底层操作照跑**
+ * （`downloadResourceToFile` 没有 abort 入参），所以 onLateSettle 在操作自己
+ * 结束时补做清理：此刻 unlink 在 win32 会被句柄占用挡到放弃、在 posix 只删掉
+ * 目录项把空间留给未关闭的 fd，两种平台都可能留下孤儿文件。
+ */
+function withTimeout(promise, ms, label, onLateSettle) {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        const timer = setTimeout(() => {
+            reject(new ResourceTimeoutError(`${label} timed out after ${ms}ms`));
+            if (onLateSettle)
+                promise.then(onLateSettle, onLateSettle);
+        }, ms);
         promise.then((value) => {
             clearTimeout(timer);
             resolve(value);
@@ -100,7 +113,7 @@ function withTimeout(promise, ms, label) {
 /**
  * 判断 send 失败是否值得重试一次（§9.5 限流重试口径，§P1-3 修正）。
  *
- * @larksuite/channel@0.3.0 的 classifyError 把飞书业务码 99991400/99991401
+ * @larksuite/channel@0.7.1 的 classifyError 把飞书业务码 99991400/99991401
  * （频率控制）归类为 `code='permission_denied'`（SDK 源码实证），并保留原始
  * axios 错误在 `cause` 链上（`cause.response.data.code`）。因此仅判
  * `code === 'rate_limited'` 会让这条重试路径对设计目标完全死亡。判定覆盖：
@@ -160,6 +173,30 @@ function isRetryablePatchError(err) {
     const status = err.response?.status;
     return typeof status === 'number' && status >= 500 && status < 600;
 }
+/**
+ * 飞书的「tenant_access_token 无效」业务码（HTTP 200 + body code）。
+ * appSecret 在后台被重置后，此前签发的 token 立刻落到这个码。
+ */
+const FEISHU_TOKEN_INVALID_CODE = 99991663;
+/** 带飞书业务码的失败：日志与错误文案只留 message，判定要另存 code。 */
+class FeishuBusinessError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'FeishuBusinessError';
+        this.code = code;
+    }
+}
+/**
+ * 这次失败是否等于「缓存里的 token 已失效」：body code 99991663 或 HTTP 401。
+ * 判定发生在内层 try 抓到的原始错误上，外层 `${label} failed: …` 包装在其之后。
+ */
+function isAccessTokenRejected(err) {
+    if (err instanceof FeishuBusinessError)
+        return err.code === FEISHU_TOKEN_INVALID_CODE;
+    const resp = err?.response;
+    return resp?.status === 401;
+}
 /**
  * 带重试的 `im.v1.message.patch`。
  *
@@ -173,6 +210,11 @@ function isRetryablePatchError(err) {
  * 这里在唯一的底层 patch 出口上兜住：瞬态错误重试最多 PATCH_MAX_RETRIES 次，
  * 全部失败才把最后一个错误抛出去（此时上层 classifyRejection 也会判为
  * recoverable，不会击穿进程）。patch 是整卡替换，重试天然幂等。
+ *
+ * 重试期间不会有更新的帧插到前面：@larksuite/channel 的 CardStreamController 用
+ * `Throttle.inFlight`（在途 fire 未结束则新 fire 延后）+ 每流 FIFO `UpdateQueue`
+ * 两层串行，本函数就在 `fire()` 的 await 链上，所以后续帧一定排在本次重试之后。
+ * 终态帧另走 `flushNow()` + `queue.drain()`。不需要在这里补 sequence 机制。
  */
 async function patchWithRetry(patchFn, request, options) {
     let lastError;
@@ -234,10 +276,13 @@ export class FeishuConnector {
         // 卡片 patch 的统一出口（观测 + 重试）：
         // 1) 观测（2026-08-11 run 卡定格事故）：飞书业务码错误以 HTTP 200 + {code!=0}
         //    返回时，lark SDK 正常 resolve、@larksuite/channel 的 patchCard 丢弃返回值，
-        //    导致终态卡 patch 被业务层拒绝时全链路无日志无兜底。这里把业务码记 warn，
-        //    返回值原样透传。
+        //    导致终态卡 patch 被业务层拒绝时全链路无日志无兜底。这里把业务码记 warn。
+        //    **不在这里抛**：流式卡片的 patch 由 throttle 触发、脱离 await 链
+        //    （`Throttle.fireSoon` 丢掉 doFire 的 promise），抛出即成 detached rejection。
+        //    恢复链路只覆盖有 await 的调用方：见 `updateCard()` 读业务码后抛。
         // 2) 重试（2026-09-15 socket-close 事故）：瞬态传输失败就地重试，最多
         //    PATCH_MAX_RETRIES 次，不把失败直接落到 unhandledRejection 打死进程。
+        //    业务码是确定性失败，不进重试循环。
         // Guard: unit-test mocks may omit rawClient; skip probe installation in that case.
         const messageService = tryGetPatchService(this.channel);
         if (messageService?.patch) {
@@ -358,7 +403,7 @@ export class FeishuConnector {
         for (const res of msg.resources) {
             const tmpPath = path.join(os.tmpdir(), `lark-remote-inbound-${randomUUID()}`);
             try {
-                const { contentType, bytesWritten } = await withTimeout(this.channel.downloadResourceToFile(msg.messageId, res.fileKey, res.type, tmpPath), timeoutMs, `downloadResource fileKey=${res.fileKey}`);
+                const { contentType, bytesWritten } = await withTimeout(this.channel.downloadResourceToFile(msg.messageId, res.fileKey, res.type, tmpPath), timeoutMs, `downloadResource fileKey=${res.fileKey}`, () => silentlyUnlink(tmpPath));
                 if (bytesWritten > maxBytes) {
                     silentlyUnlink(tmpPath);
                     const limitMb = maxBytes / (1024 * 1024);
@@ -382,7 +427,9 @@ export class FeishuConnector {
                 });
             }
             catch (err) {
-                silentlyUnlink(tmpPath);
+                // 超时不在这里删文件：上面已把清理挂到底层传输的 settle 上。
+                if (!(err instanceof ResourceTimeoutError))
+                    silentlyUnlink(tmpPath);
                 getLogger().warn(`[feishu] downloadResource failed fileKey=${res.fileKey} type=${res.type}:`, err.message);
                 failures.push({
                     kind: res.kind,
@@ -458,24 +505,49 @@ export class FeishuConnector {
             return result.messageId;
         }
         catch (err) {
-            // Log the error but don't throw - this prevents unhandled rejection
+            // 抛出去前先落一条格式化日志（调用方只看到包装后的 message）。
+            // 抛普通 Error 而不是原 err：axios 错误对象跨层序列化会丢信息。
             const errorInfo = this.formatError(err);
             getLogger().error('[feishu] streamCard failed:', errorInfo);
-            // Throw a plain error to avoid axios error serialization issues
             throw new Error(`streamCard failed: ${errorInfo}`, { cause: err });
         }
     }
+    /**
+     * 原地替换已发消息的卡片内容。
+     *
+     * 走 `rawClient.im.v1.message.patch` 而不是 `channel.updateCard()`，唯一目的就是
+     * 拿到返回值：飞书的业务码拒绝以 HTTP 200 + `{code!=0}` 返回，SDK 的 `patchCard`
+     * 把返回值丢了，调用方于是拿到假成功（卡片定格在被打回的那一帧，用户却收到
+     * 「已保存」）。抛出去让 `bridge.updateCardInPlace()` 的 catch 走 sendResult 兜底。
+     * `rawClient` 缺失（测试 mock）时回退 SDK 入口，行为退化为「看不见业务码」。
+     */
     async updateCard(messageId, card) {
+        const messageService = tryGetPatchService(this.channel);
+        let rejection;
         try {
-            await this.channel.updateCard(messageId, card);
+            if (messageService?.patch) {
+                const res = await messageService.patch({
+                    path: { message_id: messageId },
+                    data: { content: JSON.stringify(card) },
+                });
+                if (typeof res?.code === 'number' && res.code !== 0) {
+                    rejection = { code: res.code, msg: res.msg };
+                }
+            }
+            else {
+                await this.channel.updateCard(messageId, card);
+            }
         }
         catch (err) {
-            // Log the error but don't throw - this prevents unhandled rejection
+            // Log the error but don't swallow it - a plain error avoids axios
+            // serialization issues in the logger.
             const errorInfo = this.formatError(err);
             getLogger().error('[feishu] updateCard failed:', errorInfo);
-            // Throw a plain error to avoid axios error serialization issues
             throw new Error(`updateCard failed: ${errorInfo}`, { cause: err });
         }
+        if (rejection) {
+            throw new Error(`updateCard failed: Feishu rejected the card (code=${rejection.code} msg=${rejection.msg ?? ''})`, { cause: rejection });
+        }
     }
     /** Format error for logging without causing circular serialization */
     formatError(err) {
@@ -530,13 +602,38 @@ export class FeishuConnector {
      * 标签（'sendFile' | 'sendImage'）。
      */
     async uploadAndSendMedia(chatId, filePath, label, uploadUrl, buildForm, keyField, msgType) {
+        try {
+            // 被判 token 无效时清缓存重取，整段上传重做**一次**（appSecret 在飞书后台
+            // 被重置后，缓存里的旧 token 立刻失效；不清缓存就要一直失败到自然过期
+            // ~2h，期间发文件全报错）。只重试一次：持续被拒说明问题不在 token 缓存。
+            for (let attempt = 0;; attempt++) {
+                const accessToken = await this.getTenantAccessToken();
+                try {
+                    return await this.uploadWithToken(accessToken, chatId, filePath, uploadUrl, buildForm, keyField, msgType);
+                }
+                catch (err) {
+                    if (attempt === 0 && isAccessTokenRejected(err)) {
+                        this.invalidateTenantToken();
+                        getLogger().warn(`[feishu] ${label}: tenant token rejected, refetching once`);
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+        }
+        catch (err) {
+            const errorInfo = this.formatError(err);
+            getLogger().error(`[feishu] ${label} failed:`, errorInfo);
+            throw new Error(`${label} failed: ${errorInfo}`, { cause: err });
+        }
+    }
+    /** 单次「上传 + 发媒体消息」；文件流在此拥有，任何失败路径都销毁（P2-18）。 */
+    async uploadWithToken(accessToken, chatId, filePath, uploadUrl, buildForm, keyField, msgType) {
         let fileStream = null;
         try {
-            // P2-18: tenant_access_token cache（~2h），避免每次发送都取 token。
-            const accessToken = await this.getTenantAccessToken();
             fileStream = fs.createReadStream(filePath);
             const form = buildForm(fileStream);
-            // P2-18: timeout 120s（大文件慢链路）；httpsAgent: noKeepAlive 防止
+            // P2-18: timeout 120s（大文件慢链路）；httpsAgent: noKeepAliveAgent 防止
             // Bun 复用已被服务端 RST 的 keep-alive socket（ECONNRESET after ~30s）。
             const uploadResp = await axios.post(uploadUrl, form, {
                 headers: {
@@ -547,7 +644,7 @@ export class FeishuConnector {
                 httpsAgent: noKeepAliveAgent,
             });
             if (uploadResp.data.code !== 0) {
-                throw new Error(`Upload failed: ${uploadResp.data.msg}`);
+                throw new FeishuBusinessError(`Upload failed: ${uploadResp.data.msg}`, uploadResp.data.code);
             }
             const mediaKey = uploadResp.data.data[keyField];
             // P2-18: timeout 30s；noKeepAlive 同上。
@@ -565,7 +662,7 @@ export class FeishuConnector {
                 httpsAgent: noKeepAliveAgent,
             });
             if (sendResp.data.code !== 0) {
-                throw new Error(`Media message failed: ${sendResp.data.msg}`);
+                throw new FeishuBusinessError(`Media message failed: ${sendResp.data.msg}`, sendResp.data.code);
             }
             return sendResp.data.data.message_id;
         }
@@ -579,9 +676,7 @@ export class FeishuConnector {
                     /* already destroyed */
                 }
             }
-            const errorInfo = this.formatError(err);
-            getLogger().error(`[feishu] ${label} failed:`, errorInfo);
-            throw new Error(`${label} failed: ${errorInfo}`, { cause: err });
+            throw err;
         }
     }
     /**
@@ -617,14 +712,30 @@ export class FeishuConnector {
      * fetching it on every file send wastes a round-trip and an unguarded fetch
      * could return data.code != 0 with an undefined token. Cache with expiry and
      * validate the response code.
+     *
+     * 缓存的两条失效路径：到期（下面 expire）与被服务端判 token 无效
+     * （invalidateTenantToken，见 §B13）。
      */
     cachedToken = null;
     cachedTokenExpireAt = 0;
+    /** 在途的取 token 请求：并发发送合流成一次请求（飞书该端点有限流）。 */
+    tokenFetch = null;
     async getTenantAccessToken() {
         const now = Date.now();
         if (this.cachedToken && now < this.cachedTokenExpireAt) {
             return this.cachedToken;
         }
+        this.tokenFetch ??= this.fetchTenantAccessToken().finally(() => {
+            this.tokenFetch = null;
+        });
+        return this.tokenFetch;
+    }
+    /** 清掉缓存的 token：鉴权被拒时旧值已经没有价值，留着只会继续失败。 */
+    invalidateTenantToken() {
+        this.cachedToken = null;
+        this.cachedTokenExpireAt = 0;
+    }
+    async fetchTenantAccessToken() {
         // P2-18: timeout 30s on the token request.
         // httpsAgent: noKeepAlive — same Bun keep-alive fix as upload above.
         const tokenResp = await axios.post('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
@@ -636,13 +747,13 @@ export class FeishuConnector {
             httpsAgent: noKeepAliveAgent,
         });
         if (tokenResp.data.code !== 0) {
-            throw new Error(`Failed to get tenant_access_token: ${tokenResp.data.msg ?? 'unknown error'}`);
+            throw new FeishuBusinessError(`Failed to get tenant_access_token: ${tokenResp.data.msg ?? 'unknown error'}`, tokenResp.data.code);
         }
         const token = tokenResp.data.tenant_access_token;
         // Expire is in seconds; refresh 5min early as a safety margin.
         const expire = (tokenResp.data.expire ?? 7200);
         this.cachedToken = token;
-        this.cachedTokenExpireAt = now + (expire - 300) * 1000;
+        this.cachedTokenExpireAt = Date.now() + (expire - 300) * 1000;
         return token;
     }
 }

package/dist/inbound/placeholder.d.ts

@@ -6,7 +6,8 @@
  * `src/router/index.ts` 的裸前缀判定当成 bash 命令执行了整段消息。
  *
  * 规则来源：`docs/zh/architecture/inbound-message-matrix.md` §1 的 22 种 message_type
- * 实测渲染串。判定顺序**先清洗后判语义**：任何前缀判定都必须发生在剥离之后。
+ * 实测渲染串（`@larksuite/channel@0.7.1`）。判定顺序**先清洗后判语义**：任何前缀
+ * 判定都必须发生在剥离之后。
  *
  * 取舍（有意为之）：剥离对所有消息生效，所以用户在**纯文本**消息里手打
  * `![image](…)` / `<file key="…"/>` 这类字面量也会被当成占位符剥掉。代价是极少数
@@ -15,7 +16,7 @@
  */
 export type PlaceholderKind = 'image' | 'file' | 'video' | 'audio' | 'sticker' | 'share' | 'location' | 'folder' | 'vote' | 'todo' | 'meeting' | 'calendar' | 'hongbao' | 'forwarded' | 'unsupported' | 'unknown';
 export interface StripResult {
-    /** 剥离占位符后的文本（trim 后；forwarded 块只剥标签、保留内部文本）。 */
+    /** 剥离占位符后的文本（trim 后；forwarded 与未知成对标签只剥标签、保留内部文本）。 */
     clean: string;
     /** 命中的占位符种类（去重、保序），用于 rejected 回执与排障。 */
     kinds: PlaceholderKind[];

package/dist/inbound/placeholder.js

@@ -6,7 +6,8 @@
  * `src/router/index.ts` 的裸前缀判定当成 bash 命令执行了整段消息。
  *
  * 规则来源：`docs/zh/architecture/inbound-message-matrix.md` §1 的 22 种 message_type
- * 实测渲染串。判定顺序**先清洗后判语义**：任何前缀判定都必须发生在剥离之后。
+ * 实测渲染串（`@larksuite/channel@0.7.1`）。判定顺序**先清洗后判语义**：任何前缀
+ * 判定都必须发生在剥离之后。
  *
  * 取舍（有意为之）：剥离对所有消息生效，所以用户在**纯文本**消息里手打
  * `![image](…)` / `<file key="…"/>` 这类字面量也会被当成占位符剥掉。代价是极少数
@@ -54,8 +55,13 @@ const BLOCK_RULES = [
 ];
 /** 图片渲染串：`![image](img_v3_…)` / `![]()`,富文本内嵌图与纯 image 消息同形。 */
 const IMAGE_MD_RE = /!\[(?:image)?\]\([^)]*\)/g;
-/** 合并转发：只剥标签、保留内部文本（子消息文本有语义）。 */
-const FORWARDED_TAG_RE = /<\/?forwarded_messages\s*\/?>/g;
+/**
+ * 合并转发：只剥标签、保留内部文本（子消息文本有语义）。
+ * `@larksuite/channel@0.4.1+` 在子消息抓取重试耗尽后渲染
+ * `<forwarded_messages status="fetch_failed"/>`（带属性、自闭合）——属性段必须
+ * 一起吃掉，否则落到「未知标签」分支，被判为 unsupported 并污染排障日志。
+ */
+const FORWARDED_TAG_RE = /<\/?forwarded_messages(?:\s[^<>]*)?\/?>/g;
 /** 提及标签：保留内部显示名，不作为占位符上报。 */
 const AT_TAG_RE = /<at(?:\s[^<>]*)?>([\s\S]*?)<\/at>/g;
 /** converter 的降级态（缺 key / 未识别类型 —— 都是纯噪声）。 */
@@ -63,9 +69,13 @@ const BRACKET_FALLBACK_RE = /\[(?:unsupported message|rich text message|interact
 /**
  * 未知标签兜底：只在「有属性」或「成对闭合」时才剥离。
  * 要求有属性可显著降低误伤——用户正文里的 `<3`、`a < b`、`<div>` 不会被吃掉。
+ *
+ * 成对标签**只剥标签、保留内文本**（与 `AT_TAG_RE`、`FORWARDED_TAG_RE` 同口径）：
+ * 内文本是用户打出来的正文（`<b>重点</b>`、`<info>disk full</info>`），整块吃掉
+ * 会让 coding agent 拿到残缺输入，而用户完全无从察觉。
  */
 const UNKNOWN_SELF_CLOSING_RE = /<([a-z][a-z0-9_]*)\s[^<>]*\/>/g;
-const UNKNOWN_PAIRED_RE = /<([a-z][a-z0-9_]*)(?:\s[^<>]*)?>[\s\S]*?<\/\1>/g;
+const UNKNOWN_PAIRED_RE = /<([a-z][a-z0-9_]*)(?:\s[^<>]*)?>([\s\S]*?)<\/\1>/g;
 /** 剥离后遗留的连续空行折叠为单空行（属剥离产物，不算对用户文本加工）。 */
 function collapseBlankLines(text) {
     return text.replace(/\n{3,}/g, '\n\n');
@@ -122,17 +132,17 @@ export function stripPlaceholders(raw) {
         return '';
     });
     // 8. 未知标签兜底（未来 SDK 新增类型）：剥离 + 记录 tag 名。
-    working = working.replace(UNKNOWN_SELF_CLOSING_RE, (match, tag) => {
+    working = working.replace(UNKNOWN_SELF_CLOSING_RE, (_match, tag) => {
         hit('unknown');
         if (!unknownTags.includes(tag))
             unknownTags.push(tag);
         return '';
     });
-    working = working.replace(UNKNOWN_PAIRED_RE, (match, tag) => {
+    working = working.replace(UNKNOWN_PAIRED_RE, (_match, tag, inner) => {
         hit('unknown');
         if (!unknownTags.includes(tag))
             unknownTags.push(tag);
-        return '';
+        return inner;
     });
     // 9. 放回协议块。
     if (protectedBlocks.length > 0) {

package/dist/index.js

@@ -12,6 +12,7 @@ import { ClaudeSessionReader, CodexSessionReader, OpencodeSessionReader, PiSessi
 import { CommandRouter, isImmediateAction, DIRECT_RETURN_CMDS, } from './router/index.js';
 import { dispatchOrderExecForQueue } from './router/order-exec-dispatch.js';
 import { buildCardActionFullValue } from './router/card-action-payload.js';
+import { actionFeedbackText } from './router/card-action-feedback.js';
 import { Bridge } from './bridge/index.js';
 import { initLogger, getLogger } from './logger/index.js';
 import { StartupContactStore, sendStartupHello } from './startup-contact.js';
@@ -94,9 +95,11 @@ async function initializeCliAndConfig() {
     return { config, configDir, logger, instanceLock };
 }
 /** Acquire instance lock and setup global exception handlers. */
-function setupInstanceLockAndHandlers(instanceLock, logger, configDir) {
+async function setupInstanceLockAndHandlers(instanceLock, logger, configDir) {
     try {
-        instanceLock.acquire();
+        // acquire 是异步的（身份校验走 platform/identity，win32 侧是异步 CIM 查询）：
+        // 必须 await，否则会在校验完成前就放行第二条实例。
+        await instanceLock.acquire();
     }
     catch (err) {
         if (err instanceof InstanceAlreadyRunningError) {
@@ -245,6 +248,7 @@ function initializeRunner(config, configDir, cliArgs) {
                 ? acpConf.turnIdleTimeoutMinutes * 60_000
                 : undefined,
             model: kimiConf?.model ?? 'kimi-code/k3',
+            thinkingEffort: kimiConf?.thinkingEffort,
             permissionMode: kimiConf?.permissionMode ?? 'manual',
         });
     });
@@ -307,7 +311,13 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             // 入队时刻（T0）快照 workspace + agent/session 绑定，语义与旧路径一致
             // （排队期间 /cd、/config 不再导致语义漂移）。
             const messageId = turn.messageIds[turn.messageIds.length - 1] ?? '';
-            const ctx = { userId: turn.userId, chatId: turn.chatId, messageId };
+            // turnMessageIds：终态收尾要覆盖本轮每一条消息（逐条挂的 Typing 得逐条撤）
+            const ctx = {
+                userId: turn.userId,
+                chatId: turn.chatId,
+                messageId,
+                turnMessageIds: turn.messageIds,
+            };
             let workspace = sessionStore.getCwd(turn.userId) ?? '';
             if (!workspace && workspaceStore) {
                 const workspaces = workspaceStore.list();
@@ -587,14 +597,26 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             }).catch((err) => logger.error('[control] order.exec dispatch failed:', err));
             return;
         }
+        // B7：非直返命令到这里已经没有回调响应可回（enqueue* 是 fire-and-forget），
+        // handler 返回的 toast 必须显式转成持久文本，否则失败毫无反馈。
+        const forwardActionFeedback = (res) => {
+            const text = actionFeedbackText(res);
+            if (!text)
+                return;
+            void bridge
+                .sendResult({ text }, { userId, chatId, messageId })
+                .catch((err) => logger.error('[control] card action feedback failed:', err));
+        };
         if (isImmediate) {
             bridge.enqueueImmediate(workspace, async () => {
-                await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                forwardActionFeedback(res);
             });
         }
         else {
             bridge.enqueue(workspace, async () => {
-                await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                forwardActionFeedback(res);
             }, {
                 taskMeta: {
                     userId,
@@ -651,7 +673,7 @@ async function main() {
     // Restart handoff: if spawned as a /restart replacement, wait for the old
     // lark-remote to die (and release the instance lock) before acquiring it.
     await waitForPreviousInstance();
-    setupInstanceLockAndHandlers(instanceLock, logger, configDir);
+    await setupInstanceLockAndHandlers(instanceLock, logger, configDir);
     // 阻止系统休眠（macOS caffeinate / Windows SetThreadExecutionState）：lark-remote
     // 的场景是人不在电脑前远程使用，系统休眠即失联。恒开启、无配置开关；helper 进程
     // 绑定本进程生命周期（caffeinate -w / powershell 轮询父 pid），崩溃也能自清理；

package/dist/instance-lock.d.ts

@@ -1,30 +1,46 @@
+import { type IdentityVerdict } from './platform/identity.js';
 export declare class InstanceAlreadyRunningError extends Error {
     readonly pid: number;
     readonly lockPath: string;
     constructor(pid: number, lockPath: string);
 }
+/** 锁持有者身份判定（测试注入点）；默认 = platform/identity 的真实查询。 */
+export type LockIdentityVerifier = (pid: number, expectedBinary: string) => Promise<IdentityVerdict>;
+export interface InstanceLockOptions {
+    /**
+     * 注入身份判定（测试用）。缺省走真实查询；win32 上一次查询要拉起
+     * PowerShell（冷启动约 1s），但只在「锁文件已存在」（陈旧锁/取锁竞态）
+     * 这条路径上发生，不在正常启动路径上。
+     */
+    verifyIdentity?: LockIdentityVerifier;
+}
 export declare class InstanceLock {
     private readonly lockPath;
+    private readonly verifyIdentity;
+    constructor(lockPath: string, opts?: InstanceLockOptions);
     /**
-     * P2-20: injectable process-running probe for testing, and a process-name
-     * verifier to defend against PID reuse (a stale pid recycled by an unrelated
-     * process would otherwise be misjudged as "our instance still running").
-     * Default implementation checks the process name via `ps` when available.
+     * 取锁。**异步**是接口的一部分：身份校验走 platform/identity（win32 侧是
+     * 异步 CIM 查询），调用方必须 await——漏 await 会在校验完成前就放行第二条
+     * 实例（这正是锁要防的事）。
      */
-    private readonly isProcessRunning;
-    constructor(lockPath: string, opts?: {
-        isProcessRunning?: (pid: number, expectedComm: string | undefined) => boolean;
-    });
-    acquire(): void;
+    acquire(): Promise<void>;
     release(): void;
     registerExitHandlers(): void;
     /**
-     * Lock file stores `pid\ncomm` where comm is the owning process's command
-     * name (captured at acquire time). On stale-lock checks we verify the
-     * recorded pid is still alive AND still running a process whose comm
-     * matches — defending against PID reuse where an unrelated process recycled
-     * the stale pid.
+     * Lock file stores `pid\nbinaryName`, the owning process's executable name
+     * captured at acquire time. `binaryName(process.execPath)` 是唯一在
+     * posix/win32 都稳定可比的口径：win32 没有 ps，而 execPath（`C:\...\node.exe`）
+     * 与 CIM CommandLine 首 token 归一后必然一致（bun/node 垫片场景亦然）。
      */
     private lockContents;
-    private readPidAndComm;
+    private readPidAndName;
+    /**
+     * 锁是否仍由「我们的」实例持有（fail-open 三态）：
+     *   - 进程不存在             → false（陈旧）
+     *   - 无记录名（老/损坏文件）→ false（无法验证，与迁移前同口径按陈旧处理）
+     *   - 身份 match             → true（锁定实例还在跑，拒绝取锁）
+     *   - 身份 mismatch          → false（pid 已复用给无关进程，陈旧可接管）
+     *   - 身份 unknown           → true（查不到身份，宁可拒绝也不 clobber）
+     */
+    private isHeldByLiveInstance;
 }