lark-remote 0.5.6 → 0.5.8

package/CHANGELOG.md

@@ -5,6 +5,46 @@ 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.5.8] - 2026-10-21
+
+### 修复
+
+- **DSH 的 `/resume` 列表卡看得出会话内容**：此前 DSH 会话的列表卡只有 session id 和时间，必须逐条点进详情才知道哪一条是要找的会话。DSH 0.2.x 的列表响应里已带着会话标题与每轮的输入/输出，现在把它们映射成「标题 / 最近输入 / 最后输出」直接渲染，行上有预览就不再逐条去拉分页详情（那是上万条事件的大响应）；字段缺失或标题只是占位符时回退原有行为。详情卡头部同样优先用服务端的末轮输入作「最近输入」，并在它与会话标题不同时分成两段展示，不再把用户自己说的话挂在「AI 标题」下面
+- **后台任务卡里的命令不再被截断**：活过本轮的后台任务（终端里起的后台进程）原先按固定字数截断，用户没法核对卡上那条命令到底是要停哪个。现在短命令内联展示、中等长度用代码块整段展示、只有确实很长的脚本或链式命令才收进折叠面板，且面板里保留完整原文——命令是你都要核对或复制的对象，任何情况下不再 truncate
+- **停止按钮不再被挤成「🟥…」**：命令与停止按钮原先并排同一行（命令列 `grow`、按钮列 `auto`），长命令的最小内容宽度会把按钮压成一个色块。现在命令独占一行，停止按钮在下一行独占一列
+- **运行卡片收尾后保留状态行**：终态原先会把「⏱ 耗时 · 🧰 步数 · 📊 上下文」整行去掉，回看卡片时看不出这一跑花了多久、做了多少步。现在保留：耗时定格，步数与上下文显示该回合最后一次投影的快照
+
+### 变更
+
+- **模型输出被服务方内容审核截断时不再算「运行出错」，并会自动续跑一次**：上游把 `finish_reason: content_filter` 归一成普通错误，它既不在默认的重试判据里（空响应/限流/服务错误/超时/传输），也不会触发换模型，于是一次多为误报的判定就把整个回合判死——跑了很久的回合在最后一步被截断，已写入磁盘的改动都还在，卡片上却只有一句英文内部报文。现在错误卡说明三件事：谁拦的、改动还在、下一步可做什么（重试仍被拦截时换模型或稍后再试）；桥接层同时在同一会话补一条「从上次中断的位置继续，不要重复已完成的步骤」，只补一次，且若运行期间会话指针已被 `/new`、`/resume` 移动过就跳过，避免把旧会话接回来
+- **DSH 在卡片上的显示名统一为 `DSH`**：各 agent 的显示名收敛到同一张表，启动注册与没有注册表时的回退路径共用同一份数据，不再出现同一 agent 在不同位置叫法不同
+- **重复实现单源化，无行为变化**：档位取中位、工具摘要、卡片头部/按钮/字段行、队列管理与配置卡渲染等此前写了两遍的实现合并为单一来源；测试专用生产钩子移除；同主题测试套件合并、共享夹具抽出（用例覆盖不减）
+- **文档里的测试锚点改指存活文件**：套件合并删掉了若干测试文件，贡献指南与架构设计文档按路径点名的锚点因此指向不存在的路径，已改指承接其覆盖的文件。无行为变化
+
+## [0.5.7] - 2026-10-20
+
+### 新增
+
+- **DSH 运行的工具调用与运行状态进卡**：此前 DSH 直连的运行卡片只有正文、看不到任何工具调用。现在工具块以原生折叠面板呈现（与思考块同款交互，点标题展开、不经过服务端往返），运行中或失败的默认展开，正文按卡片内工具数量分配截断预算；摘要识别 DSH 的工具名与参数（`glob`、`web_search`、`todo_write`、`subagent`、`job_*`、`terminal_*` 等），标题显示不下时按**显示宽度**做中间省略——保住工具名与路径结尾，而不是从尾部切掉文件名。卡片还会投影 DSH 的 `session/control` 状态流（步数与上下文占用），并在首帧列出仍在后台运行的任务（终端里 `run_in_background` 起的进程活过了本轮），终态卡片可直接停止它们
+- **恢复卡片能看出思路**：DSH 的历史块分 `text` / `reasoning` / `tool-call` 三类，此前只认 `text`，于是一个真实会话里 371 段思考、12 段正文的恢复卡只剩一串工具调用。现在思考映射成 thinking、正文映射成回复，工具调用与结果合成同一个面板（标题带工具名与命令，失败标 `❌`，正文是输出）
+- **`/resume` 卡保住「我上一句 + 你最后一句」**：卡片只显示最后 N 个块，用户最关心的「我刚说了什么、它最后答了什么」常被中间的工具往返挤出窗口。现在这两句有独立名额
+
+### 修复
+
+- **手机端窄屏排版**：状态行原先用并排短列布局，窄屏上会被挤成竖排（「运行中」三个字竖着排），且列宽由客户端决定、服务端控制不了。改为单行单块 + ` · ` 分隔，并补上本轮耗时
+- **卡片元素总数上限按实测收敛**：飞书拒绝的判据是递归 `elements` 成员数量，此前记录有误。现在运行卡片同时受字节预算与元素预算约束，超限时从最旧的步骤开始省略，不再整卡发送失败
+- **DSH 的停止不再假报已停止**：回合跑在共享的 `dsh web` 宿主里，退出本地进程带不走它。停止现在分两步——prompt 还没被回合取走时从宿主收件箱撤回，已被取走才发取消并用 `session/list.running` 轮询确认；无法确认时明确告知「可能仍在后台运行」，而不是报一句已停止。取消确认落地前，下一条消息由门禁拦住，避免会话级取消打到新回合；每次提交的在途身份另存一份，下次启动对账：清掉残留的待执行 prompt，对仍开着的回合只提示不代杀
+- **排队与压缩的回合归属**：排队中的 prompt 此前可能在上一个回合结束时被收尾，现在绑定到自己的回合；`/compact` 执行前先探服务端是否还有在途回合；进程退出时取消尚未收尾的回合，不留无人订阅的孤儿回合
+- **空闲判定改用会话状态**：此前靠事件流静默推断，工具往返密集时容易误判。现在读 `session/list.running`，事件探测降为兜底
+- **回顾卡不再被系统注入内容灌满**：DSH 的 `user/message` 里混着 agent 指令、技能清单、运行期上下文、压缩检查点等注入项，此前照单全收，回顾卡上看不见用户真正说过的话。现在按类型过滤，系统通知单独标 `🔔`
+- **Windows 与 CI 稳定性**：退出路径的取消与凭据检查统一走平台判定；若干用例的凭据路径断言跟随 `path.join`，不再写死 POSIX 字面量
+
+### 变更
+
+- **英文文档补齐 DSH 部分**：`docs/en/architecture/design.md` 补上停止与取消确认的叙述，`docs/en/architecture/streaming-card.md` 更正工具折叠的口径（此前写的「连续工具超过阈值折叠」已被实现取代），两侧不再有互相矛盾的说法
+- **用户文档纠正过期说法**：`/order` 别名的命令形态与存储位置（英文侧仍写已移除的 `/order alias <name> <text>` 与 `aliases.json`，实际是 `alias add|rm <orderId|序号>`、随指令存在 `orders.json`）、`/ws save` 示例多带一个实际不生效的路径参数、贡献指南要求 `bun run test` 而入门文档教的是 `bun test`、README 里真机用例的缺失目录前缀
+- **注释与文档整理**：入站消息两篇架构文档改为描述当前实现，测试文件头不再点名已不存在的文件。无行为变化
+
 ## [0.5.6] - 2026-10-18
 
 ### 新增
@@ -20,7 +60,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### 变更
 
 - **英文文档补齐 DSH 部分**：`docs/en/architecture/design.md` 补上直连与凭据签发、审批与提问转写、压缩能力声明；`docs/en/usage.md` 补 `manageProcess` / `dshHome` / `dshCommand` / `startTimeoutMs` / `permissionPreset` 五项配置说明，并纠正一处过期说法——原先写着 `token` 可以在 `/config` 卡片里编辑，实际该字段早已移出卡片
-- **注释与发布条目里的内部评审轮次标注清理**。无行为变化
+- **注释与发布条目整理**。无行为变化
 
 ## [0.5.5] - 2026-10-18
 
@@ -68,7 +108,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 变更
 
-- **注释里的运维现场数据与仓库外引用清理**：一处测试注释记录的崩溃进程号、实例名与精确到秒的重启时间改为占位描述；若干注释不再指向仓库之外的维护规范文件名。无行为变化
+- **注释里的运维数据与仓库外引用改为占位描述**。无行为变化
 
 ## [0.5.2] - 2026-10-11
 
@@ -96,7 +136,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **消除两处宿主环境相关的测试假红**：宿主带上本机没有的 locale（macOS 常见的 `LC_ALL=C.UTF-8`）时，bash 每次启动都往 stderr 打 setlocale 警告，让输出断言随机变红，测试 setup 阶段现在剔掉该变量（保留 UTF-8 解析所需项）；JSON-RPC 退出计时用例的计时起点从进程启动改到收到 `initialize` 应答，慢速 Windows runner 上不再因启动耗时超过阈值而误红
 - **英文架构文档补齐**：`docs/en/architecture/design.md` 增补与中文侧对应的五个章节，英中两侧不再不对称
-- **注释与用例名清理**：延续上一版的清理，去掉剩余指向未发布文档的引用与评审编号，并修正清理过程中留下的残句。无行为变化
+- **注释与用例名整理**：让公开仓库里的引用都能落地。无行为变化
 
 ## [0.5.0] - 2026-10-07
 
@@ -114,7 +154,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 变更
 
-- **注释与测试命名清理**：去掉源码、测试注释与用例名中指向未发布内部文档的引用（评审条目号、场景号、轮次号、文件名前缀），让公开仓库里的引用都能落地。无行为变化
+- **注释与测试命名整理**：让公开仓库里的引用都能落地。无行为变化
 
 ## [0.4.5] - 2026-10-07
 
@@ -468,13 +508,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### 测试
 
 - 合并 stub 工厂、净化 fixtures、移除冗余测试
-- 新增 P1-15 configContainer 锚点测试（含 codex 负向断言）
+- 新增 configContainer 锚点测试（含 codex 负向断言）
 
 ## [0.1.2] - 2026-08-10
 
 ### 修复
 
-- claude / opencode / kimi 的 Agent 工厂改为从 `configContainer` 读取配置，避免使用过期闭包导致配置不生效（P1-15）
+- claude / opencode / kimi 的 Agent 工厂改为从 `configContainer` 读取配置，避免使用过期闭包导致配置不生效
 - codex / kimi 的 `readSessionContent` 增加 cwd 校验，防止越界读取会话
 - `listClaudeSessions` / `isClaudeSessionActive` 支持跨目录回退，处理会话迁移后的定位
 - 修复 `handleQueueInput` 竞态：替换任务在 await 之前注册

package/README.en.md

@@ -137,8 +137,8 @@ bun run lint          # eslint
 
 # Live Feishu API integration tests (skipped by default; need valid
 # credentials under ~/.lark-remote-test)
-FEISHU_LIVE_TEST=1 bun run test tests/feishu-card-form-error.test.ts
-FEISHU_LIVE_TEST=1 bun run test tests/feishu-reaction-emoji-live.test.ts
+FEISHU_LIVE_TEST=1 bun run test tests/feishu-live/feishu-card-form-error.test.ts
+FEISHU_LIVE_TEST=1 bun run test tests/feishu-live/feishu-reaction-emoji-live.test.ts
 ```
 
 ## Documentation

package/README.md

@@ -141,8 +141,8 @@ bun run typecheck     # tsc --noEmit
 bun run lint          # eslint
 
 # 真实飞书 API 集成测试（默认跳过，需要 ~/.lark-remote-test 下的有效凭据）
-FEISHU_LIVE_TEST=1 bun run test tests/feishu-card-form-error.test.ts
-FEISHU_LIVE_TEST=1 bun run test tests/feishu-reaction-emoji-live.test.ts
+FEISHU_LIVE_TEST=1 bun run test tests/feishu-live/feishu-card-form-error.test.ts
+FEISHU_LIVE_TEST=1 bun run test tests/feishu-live/feishu-reaction-emoji-live.test.ts
 ```
 
 ## 文档

package/dist/bridge/index.d.ts

@@ -4,7 +4,7 @@ import type { SessionReaderRegistry, SessionStore } from '../session/index.js';
 import type { AppConfig } from '../config/index.js';
 import { type RunCardChannel } from '../card/run-card-session.js';
 import type { RunTerminal } from '../card/run-state.js';
-import { type AgentKind } from '../runner/types.js';
+import { type AgentKind, type StopOutcome } from '../runner/types.js';
 import { QueueManager, type QueuedTask, type EnqueueOptions, type AgentBinding, type ExecutingInfo } from './queue-manager.js';
 import type { InboundMediaPayload } from '../connector/index.js';
 import type { MediaOutcome } from '../inbound/turn.js';
@@ -46,6 +46,13 @@ export interface CommandResult {
     markdown?: string;
     card?: object;
 }
+/** Detailed result of one interrupt, for callers that must not over-promise. */
+export interface InterruptOutcome {
+    stopped: boolean;
+    agentKind?: AgentKind;
+    /** Present for DSH: what the remote stop actually achieved. */
+    stop?: StopOutcome;
+}
 export interface ActiveRunSnapshot {
     runId: string;
     userId: string;
@@ -151,6 +158,16 @@ export declare class Bridge {
      * 与 session 是否还在、能否压缩无关（2026-10-08 线上缺陷）。
      */
     private compactableRuns;
+    /**
+     * 终态卡片的渲染快照（runId → state + options），供「详情」在 run 结束后
+     * 仍能二次渲染。
+     *
+     * run 结束时 activeRuns 被清空，而卡片上的「详情」按钮还活着；没有快照，
+     * 点终态卡上的「详情」只能得到一句「已失效」。只保留最近若干条：单条快照
+     * 受 MAX_BLOCKS 约束（几十 KB 以内），用户只会点刚收到的卡。
+     */
+    private runCardSnapshots;
+    private static readonly RUN_CARD_SNAPSHOT_MAX;
     /**
      * Active `!` bash runs, keyed by runId (NOT cwd). Bash runs bypass the serial
      * queue and may run in parallel with claude runs / other bash runs in the same
@@ -318,6 +335,20 @@ export declare class Bridge {
          * omitted, all workspaces are candidates (used by /stop, /t, and card stop button which don't know which cwd to target). */
         cwd?: string;
     }): Promise<boolean>;
+    /**
+     * Same as {@link interruptCurrentRun}, plus what the runner's stop actually
+     * achieved. DSH returns a {@link StopOutcome} (withdrawn / cancelled /
+     * unconfirmed); process runners and bash return none.
+     *
+     * Callers use `stop.status === 'unconfirmed'` to avoid promising "stopped" or
+     * "executing immediately" when a turn may still be running in the host.
+     */
+    interruptCurrentRunDetailed(input: {
+        userId: string;
+        chatId: string;
+        runId?: string;
+        cwd?: string;
+    }): Promise<InterruptOutcome>;
     /** Send a result message to the user (§7). Returns true on success, false on failure. */
     sendResult(result: CommandResult, ctx: CommandContext): Promise<boolean>;
     /**
@@ -345,6 +376,22 @@ export declare class Bridge {
      * card id from their set on `false`.
      */
     patchCard(messageId: string, card: object): Promise<boolean>;
+    /**
+     * 终态快照的写入点：finalize 时把当前 state + 渲染选项留一份。
+     *
+     * 不放在 finish() 里：bridge 才知道 hasRunCompact 等渲染选项，且 eviction
+     * 与 activeRuns 生命周期在同一个地方收口。
+     */
+    private rememberRunCardSnapshot;
+    /**
+     * 停止终态卡上的一个后台任务。
+     *
+     * 后台任务的生命周期跨 run（这就是它需要单独入口的原因），所以解析路径是
+     * 终态快照（runId → sessionId/cwd/agentKind）+ 该工作区的 runner 实例，
+     * 而不是 activeRuns。成功后同步摘掉 state 里的任务并就地重渲染，否则按钮
+     * 会留在卡片上而任务早已结束。
+     */
+    killBackgroundJob(runId: string, jobId: string, ctx: CommandContext): Promise<boolean>;
     /** Send a file to the user via Feishu. */
     sendFile(filePath: string, ctx: CommandContext): Promise<void>;
     /**
@@ -369,7 +416,22 @@ export declare class Bridge {
     forwardToClaude(message: string, ctx: CommandContext, opts?: {
         cwdOverride?: string;
         binding?: AgentBinding;
+        autoRetry?: boolean;
     }): Promise<void>;
+    /**
+     * 内容审核截断后的单次自动续跑。
+     *
+     * DSH 把上游 `finish_reason: content_filter` 归一成 PI_AI_ERROR：既不在默认
+     * 重试码里（EMPTY_RESPONSE/RATE_LIMIT/SERVER/TIMEOUT/TRANSPORT），也不会换模型，
+     * 于是一次（多数是误报的）判定就把整个 turn 判死。2026-10-21 现场：60 步、
+     * 10 分钟的 turn 在最后一步被截断，已写入的文件还在，用户只看到「运行出错」
+     * 加一句英文报文。
+     *
+     * 桥侧不改 dsh 的重试策略，改用「同一 session 补一条继续提示」：审核是概率
+     * 判定，重采样通常能过；模型从历史里接着做，不必重跑已完成的工作。
+     * 只续一次——续跑仍被截断就停在错误卡，不进入无限重试。
+     */
+    private retryAfterContentFilter;
     /**
      * Step 1 of forwardToClaude: Create run session components.
      * Returns runId, cardSession, and activeRun object for tracking.

package/dist/bridge/index.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { sleep } from '../common/sleep.js';
+import { isContentFilterFailure } from '../common/turn-failure.js';
 import { resolveFinalUsage, errorMessage } from './final-usage.js';
 import { getLogger } from '../logger/index.js';
 import { RunCardSession } from '../card/run-card-session.js';
@@ -150,6 +151,16 @@ export class Bridge {
      * 与 session 是否还在、能否压缩无关（2026-10-08 线上缺陷）。
      */
     compactableRuns = new Map();
+    /**
+     * 终态卡片的渲染快照（runId → state + options），供「详情」在 run 结束后
+     * 仍能二次渲染。
+     *
+     * run 结束时 activeRuns 被清空，而卡片上的「详情」按钮还活着；没有快照，
+     * 点终态卡上的「详情」只能得到一句「已失效」。只保留最近若干条：单条快照
+     * 受 MAX_BLOCKS 约束（几十 KB 以内），用户只会点刚收到的卡。
+     */
+    runCardSnapshots = new Map();
+    static RUN_CARD_SNAPSHOT_MAX = 8;
     /**
      * Active `!` bash runs, keyed by runId (NOT cwd). Bash runs bypass the serial
      * queue and may run in parallel with claude runs / other bash runs in the same
@@ -575,6 +586,17 @@ export class Bridge {
         return result;
     }
     async interruptCurrentRun(input) {
+        return (await this.interruptCurrentRunDetailed(input)).stopped;
+    }
+    /**
+     * Same as {@link interruptCurrentRun}, plus what the runner's stop actually
+     * achieved. DSH returns a {@link StopOutcome} (withdrawn / cancelled /
+     * unconfirmed); process runners and bash return none.
+     *
+     * Callers use `stop.status === 'unconfirmed'` to avoid promising "stopped" or
+     * "executing immediately" when a turn may still be running in the host.
+     */
+    async interruptCurrentRunDetailed(input) {
         // Find the active claude run matching this user/chat
         for (const [cwd, active] of this.activeRuns) {
             if (input.cwd !== undefined && cwd !== input.cwd)
@@ -595,13 +617,18 @@ export class Bridge {
                 // unconditional reset would then zero the successor's count and mark
                 // its slot interrupted, hiding it from queue cards.
                 const stoppedSlot = this.queueManager.getExecutingSlot(cwd);
-                await Promise.allSettled([
+                const [, stopResult] = await Promise.allSettled([
                     // 用户主动中断（/stop、stop 卡按钮、queue.immediate）显式打标
                     // interruptedReason，与审批超时自动取消（approval_timeout）、审批
                     // 卡取消（approval_cancelled）在终态数据上可区分（方案 A）。
                     active.session.finish('interrupted', { interruptedReason: 'user_stop' }),
                     runner.stop({ immediate: true }),
                 ]);
+                const stop = stopResult.status === 'fulfilled' &&
+                    stopResult.value !== null &&
+                    typeof stopResult.value === 'object'
+                    ? stopResult.value
+                    : undefined;
                 // The chain may have advanced while the stop was in flight: a new run
                 // (from a task that began during the stop window) may now occupy this
                 // cwd. Only delete the entry we actually stopped.
@@ -641,7 +668,7 @@ export class Bridge {
                     this.queueManager.resetExecutingCount(cwd, stoppedSlot);
                 }
                 getLogger().info(`[lark-remote] interrupt stop done runId=${active.runId}`);
-                return true;
+                return { stopped: true, agentKind: active.agentKind, ...(stop ? { stop } : {}) };
             }
         }
         // Then check active bash runs (! commands). These bypass the serial queue
@@ -658,11 +685,11 @@ export class Bridge {
                 await b.cardSession.finish('interrupted', { exitCode: -1 });
                 this.activeBashRuns.delete(runId);
                 getLogger().info(`[lark-remote] interrupt bash stop done runId=${runId}`);
-                return true;
+                return { stopped: true };
             }
         }
         getLogger().debug(`[lark-remote] interrupt miss userId=${input.userId}`);
-        return false;
+        return { stopped: false };
     }
     /** Send a result message to the user (§7). Returns true on success, false on failure. */
     async sendResult(result, ctx) {
@@ -756,6 +783,47 @@ export class Bridge {
             return false;
         }
     }
+    /**
+     * 终态快照的写入点：finalize 时把当前 state + 渲染选项留一份。
+     *
+     * 不放在 finish() 里：bridge 才知道 hasRunCompact 等渲染选项，且 eviction
+     * 与 activeRuns 生命周期在同一个地方收口。
+     */
+    rememberRunCardSnapshot(runId, state, options, cwd, agentKind) {
+        this.runCardSnapshots.set(runId, { state, options, cwd, agentKind });
+        while (this.runCardSnapshots.size > Bridge.RUN_CARD_SNAPSHOT_MAX) {
+            const oldest = this.runCardSnapshots.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.runCardSnapshots.delete(oldest);
+        }
+    }
+    /**
+     * 停止终态卡上的一个后台任务。
+     *
+     * 后台任务的生命周期跨 run（这就是它需要单独入口的原因），所以解析路径是
+     * 终态快照（runId → sessionId/cwd/agentKind）+ 该工作区的 runner 实例，
+     * 而不是 activeRuns。成功后同步摘掉 state 里的任务并就地重渲染，否则按钮
+     * 会留在卡片上而任务早已结束。
+     */
+    async killBackgroundJob(runId, jobId, ctx) {
+        const snapshot = this.runCardSnapshots.get(runId);
+        const sessionId = snapshot?.state.sessionId;
+        if (!snapshot || !sessionId)
+            return false;
+        const runner = this.getRunner(snapshot.cwd, snapshot.agentKind);
+        if (typeof runner.killJob !== 'function')
+            return false;
+        const killed = await runner.killJob(sessionId, jobId);
+        if (!killed)
+            return false;
+        snapshot.state = {
+            ...snapshot.state,
+            backgroundJobs: (snapshot.state.backgroundJobs ?? []).filter((job) => job.id !== jobId),
+        };
+        await this.updateCardInPlace(renderRunCard(snapshot.state, snapshot.options), ctx);
+        return true;
+    }
     /** Send a file to the user via Feishu. */
     async sendFile(filePath, ctx) {
         try {
@@ -852,6 +920,66 @@ export class Bridge {
             // Step 3: Finalize the run (error handling, fallback card, completion notification, cleanup)
             await this.finalizeRun(cardSession, activeRun, ctx, cwd);
         }
+        // Step 4: 服务方内容审核截断（`finish_reason: content_filter`）后自动续跑一次。
+        // 放在 finalize 之后：activeRuns 槽位已释放，续跑能正常开新卡片。
+        await this.retryAfterContentFilter({
+            cardSession,
+            ctx,
+            cwd,
+            agentKind,
+            sessionId,
+            sessionEpochAtStart,
+            autoRetried: opts?.autoRetry === true,
+        });
+    }
+    /**
+     * 内容审核截断后的单次自动续跑。
+     *
+     * DSH 把上游 `finish_reason: content_filter` 归一成 PI_AI_ERROR：既不在默认
+     * 重试码里（EMPTY_RESPONSE/RATE_LIMIT/SERVER/TIMEOUT/TRANSPORT），也不会换模型，
+     * 于是一次（多数是误报的）判定就把整个 turn 判死。2026-10-21 现场：60 步、
+     * 10 分钟的 turn 在最后一步被截断，已写入的文件还在，用户只看到「运行出错」
+     * 加一句英文报文。
+     *
+     * 桥侧不改 dsh 的重试策略，改用「同一 session 补一条继续提示」：审核是概率
+     * 判定，重采样通常能过；模型从历史里接着做，不必重跑已完成的工作。
+     * 只续一次——续跑仍被截断就停在错误卡，不进入无限重试。
+     */
+    async retryAfterContentFilter(params) {
+        const state = params.cardSession.currentState;
+        if (state.terminal !== 'error' || !isContentFilterFailure(state.errorMsg))
+            return;
+        if (params.autoRetried) {
+            getLogger().info(`[lark-remote] content_filter auto-retry already used runId=${state.runId} cwd=${params.cwd}`);
+            return;
+        }
+        // 会话指针在 run 期间被 /new、/resume 等移动过：续跑会接到另一个会话上，
+        // 「从断点继续」的语义不再成立，宁可不做（错误卡已经把话说清楚）。
+        const epochNow = this.sessionStore.getSessionEpoch(params.ctx.userId, params.agentKind);
+        if (epochNow !== params.sessionEpochAtStart) {
+            getLogger().info(`[lark-remote] content_filter auto-retry skipped: session epoch moved runId=${state.runId}`);
+            return;
+        }
+        getLogger().warn(`[lark-remote] content_filter detected, auto-retrying once runId=${state.runId} cwd=${params.cwd}`);
+        await this.sendResult({
+            text: '🔁 上一回合被服务方内容审核截断（content_filter，通常是误报），已自动重试一次。',
+        }, params.ctx);
+        try {
+            await this.forwardToClaude('（自动继续）上一回合因服务方内容审核被截断（content_filter，通常是误报）。' +
+                '请从上次中断的位置继续，不要重复已经完成的步骤。', params.ctx, {
+                cwdOverride: params.cwd,
+                binding: {
+                    agent: params.agentKind,
+                    sessionId: params.sessionId,
+                    sessionEpoch: params.sessionEpochAtStart,
+                },
+                autoRetry: true,
+            });
+        }
+        catch (err) {
+            // 续跑自身失败不应冒泡成未捕获异常：用户已经收到错误卡与重试通知。
+            getLogger().error(`[lark-remote] content_filter auto-retry failed runId=${state.runId}`, err);
+        }
     }
     /**
      * Step 1 of forwardToClaude: Create run session components.
@@ -1222,7 +1350,10 @@ export class Bridge {
                                     await r.respondApproval(requestId, response);
                                 }
                             },
-                            interruptTurn: () => runner.stop(),
+                            interruptTurn: async () => {
+                                // DSH may return a StopOutcome; the coordinator only awaits.
+                                await runner.stop();
+                            },
                             pushToCard: async (events) => {
                                 for (const ev of events)
                                     await cardSession.push(ev);
@@ -1409,17 +1540,19 @@ export class Bridge {
         try {
             getLogger().debug(`[lark-remote] finally settle runId=${runId} state.terminal=${cardSession.currentState.terminal}`);
             const settleResult = await cardSession.settle();
+            // 卡片收尾后仍要能点「详情」：把终态 state 与当时的渲染选项留一份。
+            // 与 fallback 卡共用同一份 options（能力门控一致，展开后按钮语义不变）。
+            const finalRenderOptions = {
+                agentKind: activeRun.agentKind,
+                // 与 createRunSession 的 renderOptions 一致：fallback 卡也要按
+                // runner 能力门控 Compact 按钮（缺省 undefined = 显示按钮，
+                // DSH 等无 runCompact 的 agent 会渲染出点了报错的死按钮）。
+                compactSupported: this.hasRunCompact(cwd, activeRun.agentKind),
+            };
+            this.rememberRunCardSnapshot(runId, cardSession.currentState, finalRenderOptions, cwd, activeRun.agentKind);
             let runCardSent = false;
             if (settleResult === 'unsent') {
-                const sent = await this.sendResult({
-                    card: renderRunCard(cardSession.currentState, {
-                        agentKind: activeRun.agentKind,
-                        // 与 createRunSession 的 renderOptions 一致：fallback 卡也要按
-                        // runner 能力门控 Compact 按钮（缺省 undefined = 显示按钮，
-                        // DSH 等无 runCompact 的 agent 会渲染出点了报错的死按钮）。
-                        compactSupported: this.hasRunCompact(cwd, activeRun.agentKind),
-                    }),
-                }, ctx);
+                const sent = await this.sendResult({ card: renderRunCard(cardSession.currentState, finalRenderOptions) }, ctx);
                 runCardSent = sent;
             }
             else {

package/dist/bridge/queue-manager.js

@@ -1,4 +1,5 @@
 import { getLogger } from '../logger/index.js';
+import { cardWithHeader } from '../card/card-shared.js';
 import { displayName } from '../platform/path.js';
 /**
  * Per-workspace cap on the number of tasks WAITING to execute.
@@ -171,25 +172,19 @@ export class QueueManager {
             // a rejected task never executes, so it must not occupy a slot.
             if (currentQueueLength >= MAX_WAITING_QUEUE) {
                 getLogger().warn(`[queue-manager] queue full cwd=${cwd} depth=${currentQueueLength} rejecting task messageId=${taskMeta.messageId}`);
-                void this.sendCard(taskMeta.chatId, {
-                    schema: '2.0',
-                    config: { wide_screen_mode: true },
-                    header: {
-                        template: 'red',
-                        title: { tag: 'plain_text', content: '🚫 队列已满' },
-                    },
-                    body: {
-                        elements: [
-                            {
-                                tag: 'div',
-                                text: {
-                                    tag: 'lark_md',
-                                    content: `当前工作目录已有 ${MAX_WAITING_QUEUE} 条消息排队等待，为防止积压已拒收本条消息。请等待队列消化后重发，或用 \`/stop\` 清空当前任务。`,
-                                },
+                void this.sendCard(taskMeta.chatId, cardWithHeader({
+                    template: 'red',
+                    title: '🚫 队列已满',
+                    elements: [
+                        {
+                            tag: 'div',
+                            text: {
+                                tag: 'lark_md',
+                                content: `当前工作目录已有 ${MAX_WAITING_QUEUE} 条消息排队等待，为防止积压已拒收本条消息。请等待队列消化后重发，或用 \`/stop\` 清空当前任务。`,
                             },
-                        ],
-                    },
-                }, { replyTo: taskMeta.feishuReplyTo ?? taskMeta.messageId }).catch((err) => {
+                        },
+                    ],
+                }), { replyTo: taskMeta.feishuReplyTo ?? taskMeta.messageId }).catch((err) => {
                     getLogger().error('[queue-manager] failed to send queue-full rejection card:', err);
                 });
                 return;
@@ -559,26 +554,20 @@ export class QueueManager {
                 return;
             }
             const previewForCard = liveTask?.messagePreview ?? messagePreview;
-            const card = {
-                schema: '2.0',
-                config: { wide_screen_mode: true },
-                header: {
-                    template: 'green',
-                    title: { tag: 'plain_text', content: '▶️ 已开始执行' },
-                },
-                body: {
-                    elements: [
-                        {
-                            tag: 'div',
-                            text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
-                        },
-                        { tag: 'hr' },
-                        { tag: 'div', text: { tag: 'lark_md', content: `📝 \`${previewForCard}\`` } },
-                        { tag: 'hr' },
-                        ...this.buildQueueActionButtons(cwd, messageId, true),
-                    ],
-                },
-            };
+            const card = cardWithHeader({
+                template: 'green',
+                title: '▶️ 已开始执行',
+                elements: [
+                    {
+                        tag: 'div',
+                        text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
+                    },
+                    { tag: 'hr' },
+                    { tag: 'div', text: { tag: 'lark_md', content: `📝 \`${previewForCard}\`` } },
+                    { tag: 'hr' },
+                    ...this.buildQueueActionButtons(cwd, messageId, true),
+                ],
+            });
             await this.updateCard(cardMessageId, card);
             getLogger().debug(`[queue-manager] queue card updated to executing messageId=${messageId}`);
         }
@@ -622,26 +611,20 @@ export class QueueManager {
             return;
         }
         const workspaceName = displayName(cwd);
-        const card = {
-            schema: '2.0',
-            config: { wide_screen_mode: true },
-            header: {
-                template: 'gray',
-                title: { tag: 'plain_text', content: '❌ 已撤销' },
-            },
-            body: {
-                elements: [
-                    {
-                        tag: 'div',
-                        text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
-                    },
-                    { tag: 'hr' },
-                    { tag: 'div', text: { tag: 'lark_md', content: `📝 该消息已从队列中撤销` } },
-                    { tag: 'hr' },
-                    ...this.buildQueueActionButtons(cwd, messageId, true),
-                ],
-            },
-        };
+        const card = cardWithHeader({
+            template: 'gray',
+            title: '❌ 已撤销',
+            elements: [
+                {
+                    tag: 'div',
+                    text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
+                },
+                { tag: 'hr' },
+                { tag: 'div', text: { tag: 'lark_md', content: `📝 该消息已从队列中撤销` } },
+                { tag: 'hr' },
+                ...this.buildQueueActionButtons(cwd, messageId, true),
+            ],
+        });
         try {
             await this.updateCard(cardMessageId, card);
             getLogger().debug(`[queue-manager] queue card updated to cancelled, messageId=${messageId}`);

package/dist/card/approval-render.js

@@ -5,7 +5,8 @@
  * Uses CardKit 2.0 (no tag:"action" container — 200861 rule).
  */
 import { collapsibleMarkdownPanel } from './collapsible.js';
-import { truncateUtf8, truncateMarkdownTables } from './text-truncate.js';
+import { truncateMarkdownTables } from './text-truncate.js';
+import { truncateUtf8 } from '../common/truncate.js';
 import { cardButton } from './card-shared.js';
 /** Unique nonce for card button callbacks (SDK dedup + router validation). */
 function mkNonce() {

package/dist/card/bash-card-session.d.ts

@@ -38,7 +38,6 @@ export declare class BashCardSession extends CardSession<BashState, BashRenderOp
     protected get logPrefix(): string;
     protected get errorPrefix(): string;
     protected renderCard(state: BashState, options: BashRenderOptions): object;
-    protected hasOwnBudgetProtection(): boolean;
     protected isFlushableState(): boolean;
     /** Patch the card with updated bash state (e.g. new stdout/stderr). */
     update(patch: Partial<BashState>): Promise<void>;

package/dist/card/bash-card-session.js

@@ -53,14 +53,6 @@ export class BashCardSession extends CardSession {
     renderCard(state, options) {
         return renderBashCard(state, options);
     }
-    hasOwnBudgetProtection() {
-        // renderBashCard 自带 stringify 级 degraded/extreme fallback 预算保护
-        // （与 renderRunCard 对称），保证返回卡 ≤28KB 且保留 command/exitCode。
-        // enforceCardBudget 是会话事件面板专用的静态裁剪层，对 bash 卡的普通
-        // markdownDiv output 是 misfit（超限时极端降级丢 command/exitCode），bash
-        // 卡应跳过它，靠自身 renderer 保护。
-        return true;
-    }
     isFlushableState() {
         // finish() 已把 state 转终态后，in-flight/延迟 flush 不再用旧 state patch。
         return this.state.terminal === 'running';

package/dist/card/bash-renderer.js

@@ -1,6 +1,7 @@
 import { terminalToColor, terminalToLabel, stopButton } from './card-shared.js';
 import { markdownDiv } from './collapsible.js';
-import { truncateUtf8, CARD_BUDGET_BYTES } from './text-truncate.js';
+import { CARD_BUDGET_BYTES } from './text-truncate.js';
+import { truncateUtf8 } from '../common/truncate.js';
 /**
  * 飞书卡片大小限制（安全阈值，与 run-renderer 一致）。
  * 从共享的 text-truncate.ts 导入，避免三处各自定义后数值漂移。