lark-remote 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -5,6 +5,39 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.4] - 2026-10-04
+
+### 修复
+
+- **opencode 的工具卡片能显示完整命令了**：opencode 的 ACP 在参数流式阶段先发 `tool_call`（参数为空、标题只回落成工具名），真正的命令/路径随后由 `tool_call_update` 携带。此前卡片只显示 `Bash` 看不到执行了什么；现在按调用 id 原地回填参数，命令与路径正常展示。顺带修掉同一命令被重复渲染成 `ls — ls` 的摘要去重问题
+- **思考内容的省略计数不再虚增**：增量刷新时，旧逻辑把「前 N 字符已省略」标记自身的文本也计进被丢弃的正文，每帧约虚增 14 字符。现在只累计真实丢弃的正文，显示量始终不超过上限
+
+### 变更
+
+- **`!` 命令失败用例去掉宿主 locale 依赖**：原先匹配 stderr 文案（`command not found`），中文 locale 下 bash 输出「未找到命令」导致用例稳定误红。改为断言确定性信号——命令名回显、非零退出码、诊断块呈现
+
+## [0.4.3] - 2026-09-24
+
+### 新增
+
+- **富文本消息的顶层附件也能落盘了**：`@larksuite/channel` 从 `0.3.0` 升到 `0.7.1`。富文本（`post`）消息在**正文之外**的顶层附件区（`<file key=… name=…/>`，文件夹为 `<folder …/>`）此前不产出资源、会被当噪声丢掉；现在按序号识别并保存到当前工作目录，附件绝对路径照常写进 agent 提示词。往群里发一条「正文 + PDF」的富文本消息，agent 拿到的和普通文件消息一致（文件夹不产资源，只保留正文）
+- **Windows 上收摊改走协议通道**：进程终止不再依赖跨进程 `SIGTERM`（win32 上本就不可靠），各 runner 统一登记「协议停止请求」，由 agent 自己响应后退出
+
+### 修复
+
+- **审批重投不再永不过期**：同一个 `requestId` 被重复投递时重新计时，并保证一个 requestId 最多只有一条待触发计时器。此前重投会留下两条计时器——要么审批永远等不到超时（server 无限等待），要么旧计时器提前把新窗口咬掉
+- **Windows 防休眠此前从未生效**：`SetThreadExecutionState` 的 flags 因 Int32 溢出被截断，脚本一直静默失败。现按无符号 32 位、以十进制字面量传参，并把非终止错误升级为终止错误，让失败能落到告警分支而不是无声无息
+- **资源下载超时不再静默**：超时只停止等待，底层下载照跑，晚到的结果由回调补做清理——避免「界面说超时、文件其实落了盘却没人管」
+- **租户 token 失效会自动恢复**：识别 `tenant_access_token` 失效（飞书业务码 `99991663` 与 HTTP 401）并刷新后重试，不再让整条消息处理链失败
+- **卡片 patch 失败不再成为无人接的 rejection**：流式卡片的 patch 由 throttle 触发、脱离 await 链（`Throttle.fireSoon` 丢掉 promise），业务码异常时改为记 warn 并原样透传返回值；需要抛出的场景收敛到带 await 的更新入口
+
+### 变更
+
+- **平台能力收口**：进程终止统一走 `Terminator` 抽象（删除 `ProcessStopper` 兼容壳），路径、进程身份、休眠能力按平台各自实现
+- **claude 权限模式取值口径修正**：`permissionMode` 的 `default` 表示**省略该参数**（不是 CLI 的取值），与其他 agent 的配置语义对齐
+- **测试套件平台无关化**：消除用例与 fixture 对宿主平台的隐性依赖（Windows 上全量失败从 25 条降到 0）；同步 CLI 探测通道短路，不再依赖本机装了哪些 agent CLI
+- **测试临时目录统一自清**：文件级钩子 + 全局兜底清扫，消除 `%TEMP%` 泄漏，被强杀或超时的场景也能收拾干净
+
 ## [0.4.2] - 2026-09-19
 
 ### 新增

package/dist/bridge/approval-coordinator.d.ts

@@ -142,6 +142,8 @@ export declare class ApprovalCoordinator {
      */
     pendingCount(): number;
     private clearTimer;
+    /** 装超时计时器；先清掉旧的，保证一个 requestId 最多只有一条待触发的计时。 */
+    private armTimeout;
     /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
     private assertFreshNonce;
     /** 记录问题答案到 tracked.answers（懒初始化 Map）。 */

package/dist/bridge/approval-coordinator.js

@@ -30,28 +30,30 @@ export class ApprovalCoordinator {
      * Handle an approval_requested event.
      */
     onRequested(event) {
+        // 事件级 timeoutMs 优先（Codex autoResolutionMs / Pi extension timeout），
+        // 缺省回落 run 级默认超时。放在事件上而非桥按 agentKind 分支，公共层
+        // 保持无 agent 分支。
+        const timeoutMs = event.timeoutMs ?? this.approvalTimeoutMs;
         const existing = this.approvals.get(event.requestId);
         if (existing) {
             // Already tracked — update state
             existing.state = 'pending';
             existing.view = event.view;
+            // 重投必须重新计时：上一路的计时器在 resolved/expired 时已清掉，不重装
+            // 这条审批就永不过期，server 只能无限等待（红线「审批超时自动 cancel」）。
+            this.armTimeout(existing, timeoutMs);
             return;
         }
-        // 事件级 timeoutMs 优先（Codex autoResolutionMs / Pi extension timeout），
-        // 缺省回落 run 级默认超时。放在事件上而非桥按 agentKind 分支，公共层
-        // 保持无 agent 分支。
-        const timer = setTimeout(() => {
-            this.expireApproval(event.requestId);
-        }, event.timeoutMs ?? this.approvalTimeoutMs);
         const tracked = {
             requestId: event.requestId,
             kind: event.kind,
             state: 'pending',
             view: event.view,
             createdAt: Date.now(),
-            timeoutTimer: timer,
+            timeoutTimer: null,
         };
         this.approvals.set(event.requestId, tracked);
+        this.armTimeout(tracked, timeoutMs);
     }
     /**
      * Handle an approval_resolved event.
@@ -329,6 +331,13 @@ export class ApprovalCoordinator {
             tracked.timeoutTimer = null;
         }
     }
+    /** 装超时计时器；先清掉旧的，保证一个 requestId 最多只有一条待触发的计时。 */
+    armTimeout(tracked, timeoutMs) {
+        this.clearTimer(tracked);
+        tracked.timeoutTimer = setTimeout(() => {
+            this.expireApproval(tracked.requestId);
+        }, timeoutMs);
+    }
     /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
     assertFreshNonce(requestId, nonce) {
         if (nonce === undefined)

package/dist/bridge/index.d.ts

@@ -33,6 +33,12 @@ interface BridgeContext {
     userId: string;
     chatId: string;
     messageId: string;
+    /**
+     * 本轮（装配窗口）全部入站 messageId，`messageId` 是其中最后一条。
+     * 只有走入站装配器的路径会填；卡片动作等单消息路径留空，收尾退化为只处理
+     * `messageId`。缺它会导致合并轮次里先到的消息挂着 Typing 不撤（§B8）。
+     */
+    turnMessageIds?: string[];
 }
 /** A sendable result payload (mirror of the router's CommandResult shape). */
 interface BridgeResult {
@@ -347,11 +353,27 @@ export declare class Bridge {
      * Returns runId, cardSession, and activeRun object for tracking.
      */
     private createRunSession;
+    /**
+     * §9.12 空闲看门狗：单 interval + 截止时间判定（P2-1），普通 run 与 compact
+     * 共用同一套兜底。事件到达只 `touch()` 刷新时间戳（无 timer 操作）；静默超过
+     * `idleTimeoutMs` 才 finish('idle_timeout') + runner.stop()，让该工作区的串行
+     * 队列继续推进（否则一个挂死的 run 永久堵住后续消息）。
+     */
+    private startIdleWatchdog;
     /**
      * Step 2 of forwardToClaude: Run the agent and consume its event stream.
      * Handles idle watchdog, event processing, session sync, and state transitions.
      */
     private runAgentStreamToEnd;
+    /**
+     * 终态 reaction 收尾：撤掉 Typing、打上下方终态表情。
+     *
+     * 逐条挂 Typing（`src/index.ts` 对每条入站消息都加），但 ctx.messageId 只是
+     * 装配窗口里的最后一条——只对它收尾会让先到的那几条永远停在「正在输入」。
+     * connector 的两个 reaction 方法自带 try/catch（缺失 reaction 是 no-op），
+     * 所以这里 fire-and-forget 即可，不额外兜错。
+     */
+    private finishTurnReactions;
     /**
      * Step 3 of forwardToClaude: Finalize the run.
      * Handles fallback card sending, completion notification, and cleanup.

package/dist/bridge/index.js

@@ -782,6 +782,51 @@ export class Bridge {
         getLogger().info(`[lark-remote] activeRuns.set cwd=${cwd} runId=${runId}`);
         return { runId, cardSession, activeRun };
     }
+    /**
+     * §9.12 空闲看门狗：单 interval + 截止时间判定（P2-1），普通 run 与 compact
+     * 共用同一套兜底。事件到达只 `touch()` 刷新时间戳（无 timer 操作）；静默超过
+     * `idleTimeoutMs` 才 finish('idle_timeout') + runner.stop()，让该工作区的串行
+     * 队列继续推进（否则一个挂死的 run 永久堵住后续消息）。
+     */
+    startIdleWatchdog(opts) {
+        let lastEventTs = Date.now();
+        let interval = null;
+        const stop = () => {
+            if (interval)
+                clearInterval(interval);
+            interval = null;
+        };
+        if (this.idleTimeoutMs > 0) {
+            // 周期取 idleTimeoutMs/2：停滞后最多在 1.5× idleTimeoutMs 内触发
+            // （半个窗口延迟，看门狗语义可接受）
+            const tickMs = Math.max(1, Math.floor(this.idleTimeoutMs / 2));
+            interval = setInterval(() => {
+                if (Date.now() - lastEventTs <= this.idleTimeoutMs)
+                    return;
+                // 权限等待期间暂停空闲看门狗：claude/codex 等待人工决策时无 stdout
+                // 事件。审批由 ApprovalCoordinator 的超时（默认 5 分钟 < 看门狗窗口）
+                // 自愈：cancel 送达 + 中断 turn，不会无限挂起。
+                if ((opts.pendingApprovals?.() ?? 0) > 0) {
+                    lastEventTs = Date.now();
+                    return;
+                }
+                stop();
+                getLogger().warn(`[lark-remote] claude idle timeout, stopping process runId=${opts.runId}`);
+                void Promise.allSettled([
+                    opts.session.finish('idle_timeout', {
+                        idleTimeoutMinutes: Math.max(1, Math.round(this.idleTimeoutMs / 60_000)),
+                    }),
+                    opts.runner.stop(),
+                ]);
+            }, tickMs);
+        }
+        return {
+            touch: () => {
+                lastEventTs = Date.now();
+            },
+            stop,
+        };
+    }
     /**
      * Step 2 of forwardToClaude: Run the agent and consume its event stream.
      * Handles idle watchdog, event processing, session sync, and state transitions.
@@ -790,13 +835,8 @@ export class Bridge {
         // Runner 声明的 usage 权威来源（review P3-7）：codex app-server = 'live'
         // （turn/started 的 tokenUsage.last 是本 turn 增量）。其余 runner 未声明。
         const usageAuthority = runner.getUsageAuthority?.();
-        // P2-1: idle watchdog 用单 interval + lastEventTs 截止时间判定，而非每事件
-        // clearTimeout + setTimeout 重建 timer。高频事件流下 timer 重建次数与事件数
-        // 成正比（N 事件 = N 次 setTimeout + N 个闭包/秒）；interval 方案只建一个
-        // interval，事件到来时仅刷新时间戳（无 timer 操作）。语义不变：事件流停滞
-        // 超过 idleTimeoutMs 仍触发 runner.stop()（§9.12）。
-        let lastEventTs = Date.now();
-        let idleInterval = null;
+        // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
+        let watchdog = null;
         let sawResult = false;
         // 记录 result 是否为 error: error 时跳过 jsonl usage 读取 (见 stream end 处说明)
         let resultNotSuccess = false;
@@ -867,44 +907,15 @@ export class Bridge {
                 // Card session did not enter running state - still try to send static fallback
                 getLogger().info(`[lark-remote] cardSession not running, using static fallback`);
             }
-            // P2-1: 单 interval 看门狗。事件到来时只刷新 lastEventTs（无 timer 操作）；
-            // interval 周期检查 `now - lastEventTs > idleTimeoutMs`，超时才触发 stop。
-            // 这样高频事件流下 timer 重建次数与事件数解耦（只建一个 interval），而
-            // "15min 无事件即 stop" 的语义不变（§9.12）。周期取 idleTimeoutMs/2，使停滞
-            // 后最多在 1.5× idleTimeoutMs 内触发（半个窗口延迟，watchdog 语义可接受）。
-            const fireIdleTimeout = () => {
-                // 权限等待期间暂停空闲看门狗：claude/codex 等待人工决策时无 stdout
-                // 事件，「等审批」不是「挂死」。审批由 ApprovalCoordinator 的超时
-                // （默认 5 分钟 < 看门狗窗口）自愈：cancel 送达 + 中断 turn，不会无限
-                // 挂起。
-                const pendingApproval = this.approvalCoordinators.get(runId)?.pendingCount() ?? 0;
-                if (pendingApproval > 0) {
-                    lastEventTs = Date.now();
-                    return;
-                }
-                if (idleInterval)
-                    clearInterval(idleInterval);
-                idleInterval = null;
-                getLogger().warn(`[lark-remote] claude idle timeout, stopping process runId=${runId}`);
-                void Promise.allSettled([
-                    cardSession.finish('idle_timeout', {
-                        idleTimeoutMinutes: Math.max(1, Math.round(this.idleTimeoutMs / 60_000)),
-                    }),
-                    runner.stop(),
-                ]);
-            };
-            const resetIdle = () => {
-                lastEventTs = Date.now();
-            };
-            if (this.idleTimeoutMs > 0) {
-                const tickMs = Math.max(1, Math.floor(this.idleTimeoutMs / 2));
-                idleInterval = setInterval(() => {
-                    if (Date.now() - lastEventTs > this.idleTimeoutMs) {
-                        fireIdleTimeout();
-                    }
-                }, tickMs);
-            }
-            resetIdle();
+            // P2-1: 单 interval 看门狗。事件到来时只刷新时间戳（无 timer 操作）；
+            // interval 周期检查静默时长，超时才 finish('idle_timeout') + stop()。
+            // 武装点在建卡之后，与原实现一致（宽限期不含 cardSession.start() 耗时）。
+            watchdog = this.startIdleWatchdog({
+                runId,
+                session: cardSession,
+                runner,
+                pendingApprovals: () => this.approvalCoordinators.get(runId)?.pendingCount() ?? 0,
+            });
             let contextLength;
             getLogger().info(`[lark-remote] runner.run() begin runId=${runId} message=${message.slice(0, 100)}`);
             // Extract agent-specific options from config
@@ -995,7 +1006,7 @@ export class Bridge {
                     if (preInitResult && usageAuthority !== 'live') {
                         getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
                         // Still reset idle timer — the CLI is alive and producing events.
-                        resetIdle();
+                        watchdog?.touch();
                         // Do NOT push to cardSession: the run-state reducer would also
                         // skip it (sessionId === undefined), but skipping at the bridge
                         // layer avoids the push + render overhead for a no-op event.
@@ -1107,17 +1118,14 @@ export class Bridge {
                 // lastEventTs 重新武装看门狗。result 后 CLI 进程做 jsonl flush/清理（finalizing
                 // 过渡）期间，宽限期恢复为完整的 idleTimeoutMs，避免已产出结果的 turn 被误标
                 // idle_timeout。旧实现 `else { resetIdle(); }` 漏掉 result 分支。
-                resetIdle();
+                watchdog?.touch();
                 await cardSession.push(event);
             }
             getLogger().info(`[lark-remote] runner stream end runId=${runId} sawResult=${sawResult}`);
             // §9.12 红线（§P1-2 方案 A 第 2 点）：for-await 自然结束 = CLI 已退出，
             // 看门狗使命结束，立即摘除 interval（不再等 finally），堵掉「stream 已结束、
             // 收尾处理跨过死线被误标 idle_timeout」的同源小窗口（P2-4 随本修复一并关闭）。
-            if (idleInterval) {
-                clearInterval(idleInterval);
-                idleInterval = null;
-            }
+            watchdog?.stop();
             // stream 结束 = CLI 退出 = jsonl 已落盘。读 jsonl 拿准确的 contextLength + compactCount：
             // live stream-json 不发 compact_boundary，live contextLength 会被 result 的 input+output 兜底失真。
             // 但 result=error 时跳过: 进程可能立即退出未写新 usage (如 kimi 0.26+ 拒绝 -p+--auto
@@ -1222,8 +1230,7 @@ export class Bridge {
             }
         }
         finally {
-            if (idleInterval)
-                clearInterval(idleInterval);
+            watchdog?.stop();
             const coordinator = this.approvalCoordinators.get(runId);
             if (coordinator) {
                 coordinator.onTurnEnded();
@@ -1231,6 +1238,24 @@ export class Bridge {
             }
         }
     }
+    /**
+     * 终态 reaction 收尾：撤掉 Typing、打上下方终态表情。
+     *
+     * 逐条挂 Typing（`src/index.ts` 对每条入站消息都加），但 ctx.messageId 只是
+     * 装配窗口里的最后一条——只对它收尾会让先到的那几条永远停在「正在输入」。
+     * connector 的两个 reaction 方法自带 try/catch（缺失 reaction 是 no-op），
+     * 所以这里 fire-and-forget 即可，不额外兜错。
+     */
+    finishTurnReactions(ctx, emoji) {
+        const ids = ctx.turnMessageIds?.length
+            ? [...new Set([...ctx.turnMessageIds, ctx.messageId])]
+            : [ctx.messageId];
+        // 两类 emoji 互不相干（撤 Typing / 打终态），并发发出没有顺序依赖。
+        for (const id of ids) {
+            void this.connector.removeReactionByEmoji(id, 'Typing');
+            void this.connector.addReaction(id, emoji);
+        }
+    }
     /**
      * Step 3 of forwardToClaude: Finalize the run.
      * Handles fallback card sending, completion notification, and cleanup.
@@ -1264,7 +1289,7 @@ export class Bridge {
                 await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind);
             }
             // Add a terminal-state emoji reaction to the user's original message
-            void this.connector.addReaction(ctx.messageId, terminalReactionEmoji(cardSession.currentState.terminal));
+            this.finishTurnReactions(ctx, terminalReactionEmoji(cardSession.currentState.terminal));
         }
         finally {
             // P1-13: cleanup must survive mid-finalize errors. The only unguarded
@@ -1548,6 +1573,14 @@ export class Bridge {
             await this.sendResult({ text: '⚠️ 当前运行模式不支持 Compact' }, ctx);
             return;
         }
+        // activeRuns 以 cwd 为键：注册前先确认槽位空闲，否则压缩会覆盖在跑的 run 的
+        // 记录，令 /stop 只停到最后注册的那个。
+        const busyWith = this.activeRuns.get(cwd);
+        if (busyWith) {
+            log.info(`[lark-remote] compact refused: workspace busy cwd=${cwd} runId=${busyWith.runId}`);
+            await this.sendResult({ text: '⚠️ 该工作区正在运行任务，请等待结束或先 /stop' }, ctx);
+            return;
+        }
         await this.sendResult({ text: '🗜 Compact 已触发，正在压缩会话…' }, ctx);
         const compactRunId = randomUUID();
         const cardSession = new RunCardSession({
@@ -1559,8 +1592,28 @@ export class Bridge {
                 agentKind,
             },
         });
+        // A6：压缩与普通 run 共用同一套生命周期——注册进 activeRuns（/stop 有对象可停、
+        // /active 看得见）、挂 §9.12 空闲看门狗、终态后补 reaction。缺任何一环，卡住的
+        // 压缩都只能等 runner 级超时，用户既停不掉也看不出它还在跑。
+        const activeRun = {
+            runId: compactRunId,
+            userId: ctx.userId,
+            chatId: ctx.chatId,
+            session: cardSession,
+            cwd,
+            runner,
+            agentKind,
+        };
+        this.activeRuns.set(cwd, activeRun);
+        getLogger().info(`[lark-remote] activeRuns.set cwd=${cwd} runId=${compactRunId} compact=true`);
+        let watchdog = null;
         try {
             await cardSession.start();
+            watchdog = this.startIdleWatchdog({
+                runId: compactRunId,
+                session: cardSession,
+                runner,
+            });
             // operationKind=compaction：卡片不渲染 Compact 按钮（防递归 Compact）。
             await cardSession.push({
                 type: 'turn_started',
@@ -1572,11 +1625,21 @@ export class Bridge {
             let resultSubtype;
             let resultError;
             for await (const event of runner.runCompact('', { cwd, sessionId })) {
+                // 已终态（/stop、空闲看门狗）后不再消费事件：与 runAgentStreamToEnd 同口径，
+                // 否则迟到的 result 会把终态卡改写成「已完成」。
+                const cardTerminal = cardSession.currentState.terminal;
+                if (cardTerminal === 'done' ||
+                    cardTerminal === 'error' ||
+                    cardTerminal === 'interrupted' ||
+                    cardTerminal === 'idle_timeout') {
+                    continue;
+                }
                 if (event.type === 'result') {
                     sawResult = true;
                     resultSubtype = event.subtype;
                     resultError = event.errorMessage;
                 }
+                watchdog?.touch();
                 await cardSession.push(event);
             }
             // §5.3: 卡片终态必须等于引擎真实终态。旧实现只看 sawResult 布尔——error
@@ -1616,7 +1679,26 @@ export class Bridge {
         }
         catch (err) {
             log.error(`[lark-remote] streamCodexCompact failed: ${errorMessage(err)}`);
-            await cardSession.finish('error', { errorMsg: errorMessage(err) });
+            // 终态守卫（与 runAgentStreamToEnd 同口径）：running/finalizing 才转 error，
+            // 已终态（interrupted/idle_timeout）保留首终态，不被迟到的异常改写。
+            const catchTerminal = cardSession.currentState.terminal;
+            if (catchTerminal === 'running' || catchTerminal === 'finalizing') {
+                await cardSession.finish('error', { errorMsg: errorMessage(err) });
+            }
+            else {
+                log.info(`[lark-remote] skip compact error finish: state already terminal (${catchTerminal}) runId=${compactRunId}`);
+            }
+        }
+        finally {
+            watchdog?.stop();
+            // 只摘自己的槽位：/stop 可能已删掉本条并让排队的下一条占住同一 cwd。
+            if (this.activeRuns.get(cwd) === activeRun) {
+                this.activeRuns.delete(cwd);
+                getLogger().info(`[lark-remote] activeRuns.delete cwd=${cwd} runId=${compactRunId}`);
+            }
+            // 终态 reaction：与普通 run 同一口径（done→Done / error→ERROR /
+            // interrupted→SHHH / idle_timeout→Alarm）。
+            this.finishTurnReactions(ctx, terminalReactionEmoji(cardSession.currentState.terminal));
         }
     }
     /**
@@ -1808,7 +1890,7 @@ export class Bridge {
                 getLogger().info(`[lark-remote] executeBash done runId=${runId} exitCode=${exitCode}`);
             }
             // Add a Done emoji reaction to the user's original message to signal completion
-            void this.connector.addReaction(ctx.messageId, 'Done');
+            this.finishTurnReactions(ctx, 'Done');
         }
     }
 }

package/dist/card/card-budget.js

@@ -1,4 +1,4 @@
-import { truncateUtf8, truncateMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, CARD_BUDGET_BYTES, } from './text-truncate.js';
+import { truncateUtf8, dropOldestMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, CARD_BUDGET_BYTES, } from './text-truncate.js';
 /**
  * 静态卡片体积保护
  *
@@ -12,16 +12,14 @@ export function enforceCardBudget(card, opts = {}) {
     // 小体积可以含很多 table，大体积可以没有 table。必须在字节检查之前独立判断。
     const cardStr = JSON.stringify(card);
     const bytesBefore = Buffer.byteLength(cardStr, 'utf8');
-    const totalTables = countCardTables(JSON.parse(cardStr));
-    if (totalTables > FEISHU_MAX_TABLES) {
-        // 深拷贝后对每个 lark_md 文本做 truncateMarkdownTables
-        const fixed = JSON.parse(cardStr);
-        truncateCardMarkdownTables(fixed);
-        const fixedStr = JSON.stringify(fixed);
+    const parsed = JSON.parse(cardStr);
+    const droppedTables = capCardMarkdownTables(parsed, FEISHU_MAX_TABLES);
+    if (droppedTables > 0) {
+        const fixedStr = JSON.stringify(parsed);
         // table 截断后可能仍超字节预算，继续走后续阶段
         if (Buffer.byteLength(fixedStr, 'utf8') <= CARD_BUDGET_BYTES) {
             return {
-                card: fixed,
+                card: parsed,
                 wasTruncated: true,
                 reason: 'table_count_limited',
                 bytesBefore,
@@ -29,7 +27,7 @@ export function enforceCardBudget(card, opts = {}) {
             };
         }
         // table 修好了但字节仍超，用 fixed 作为后续处理的起点
-        return enforceByteBudget(fixed, opts, bytesBefore);
+        return enforceByteBudget(parsed, opts, bytesBefore);
     }
     if (bytesBefore <= CARD_BUDGET_BYTES) {
         return { card, wasTruncated: false, bytesBefore, bytesAfter: bytesBefore };
@@ -189,7 +187,7 @@ function getPanelIndices(elements) {
 /**
  * 遍历卡片元素树（含 collapsible_panel.elements 与 column_set.columns[].elements）。
  *
- * count 与 truncate 两条路径共用同一遍历，避免两套递归漂移（G5 Duplication）。
+ * 计数与裁剪两条路径共用同一遍历，避免两套递归漂移（G5 Duplication）。
  */
 function walkCardElements(elements, visit) {
     for (const el of elements) {
@@ -205,29 +203,44 @@ function walkCardElements(elements, visit) {
     }
 }
 /**
- * Count all markdown tables across every lark_md text field in a card JSON.
+ * 卡片里含 markdown table 的 lark_md 字段，按**文档顺序**（计数与裁剪共用同一
+ * 份遍历，避免两套递归漂移）。
  */
-function countCardTables(card) {
-    let total = 0;
+function tableFields(card) {
+    const fields = [];
     walkCardElements(card?.body?.elements ?? [], (el) => {
         if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
-            total += countMarkdownTables(el.text.content);
+            const tables = countMarkdownTables(el.text.content);
+            if (tables > 0)
+                fields.push({ el, tables });
         }
     });
-    return total;
+    return fields;
 }
 /**
- * In-place truncate markdown tables in every lark_md text field of a card,
- * keeping at most FEISHU_MAX_TABLES per field.
+ * 按**整卡**预算删除 markdown table：`maxTables` 是整张卡的上限，不是每个字段的。
+ *
+ * 逐字段各限 5 张是空操作（11310 红线失效）：table 分散在多个字段时，每个字段
+ * 都「没超限」，一张都不会被删，而守卫照样上报 `table_count_limited`。
+ * 这里按文档顺序累计，超出预算的**最旧** table 整块删除、保留最新 `maxTables`
+ * 张——与 `truncateMarkdownTables()` 的「删最旧、留最新」口径一致。
+ *
+ * @returns 实际删除的 table 数（0 = 无需处理，未改动 card）
  */
-function truncateCardMarkdownTables(card) {
-    walkCardElements(card?.body?.elements ?? [], (el) => {
-        if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
-            const truncated = truncateMarkdownTables(el.text.content);
-            if (truncated !== el.text.content) {
-                el.text.content = truncated;
-            }
-        }
-    });
+function capCardMarkdownTables(card, maxTables) {
+    const fields = tableFields(card);
+    const total = fields.reduce((sum, f) => sum + f.tables, 0);
+    let dropped = 0;
+    for (const { el, tables } of fields) {
+        // 每轮按「还差几张」重算：某字段的分隔行数可能多于可删块（畸形表），
+        // 只按声明数删会漏。
+        const toDrop = total - dropped - maxTables;
+        if (toDrop <= 0)
+            break;
+        const content = el.text.content;
+        el.text.content = dropOldestMarkdownTables(content, Math.min(toDrop, tables));
+        dropped += tables - countMarkdownTables(el.text.content);
+    }
+    return dropped;
 }
 //# sourceMappingURL=card-budget.js.map

package/dist/card/run-renderer.js

@@ -659,11 +659,18 @@ export function renderRunCard(state, options = {}) {
     if (Buffer.byteLength(JSON.stringify(skeletonCard), 'utf8') <= CARD_BUDGET_BYTES) {
         return skeletonCard;
     }
-    // 理论上不可达：skeleton 已是静态最小结构。若仍超限，硬截断文本提示兜底。
+    // 理论上不可达：skeleton 已是静态最小结构。若仍超限（errorMsg 等无界文本
+    // 灌进 summary），硬截断只丢 summary——审批入口与 stop/新会话按钮是红线，
+    // 任何一级兜底都不能把它们截掉（丢了用户就再也停不下这个 run）。
     const truncatedSkeleton = {
         ...skeletonCard,
         body: {
-            elements: [statusRow(state), markdownDiv('_⚠️ 输出过大_'), newSessionButton()],
+            elements: [
+                statusRow(state),
+                markdownDiv('_⚠️ 输出过大_'),
+                ...approvalArea(state),
+                ...actionRow(state, options),
+            ],
         },
     };
     return truncatedSkeleton;