lark-remote 0.5.10 → 0.5.12

package/CHANGELOG.md

@@ -5,6 +5,44 @@ 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.12] - 2026-10-24
+
+### 修复
+
+- **Bash 工具结果不再偶发丢失**：kimi 的终端子进程退出后，runner 会等 stdout 尾部 flush（最多 200ms）再推 Bash 输出；但 `terminal/wait_for_exit` 此前在 flush 之前就返回，服务端拿到响应后立即 release 并结束回合，回合结果可能先于延迟推送的 tool_result 到达，卡片上的 Bash 面板变成空输出。现在 wait_for_exit 在 tool_result 入队后才返回，保证输出先于回合结束送达
+
+### 维护
+
+- **测试同步原语收紧**：pid 文件改为等完整内容再读（避免读到空串后把 0 当 PID 轮询进程组）；kimi 压缩完成用例改由 mock server 在收到 prompt 后延迟落记录，消除并行负载下的假红。无行为变化
+
+## [0.5.11] - 2026-10-24
+
+### 修复
+
+- **审批卡在超长或超量输入下不再整卡消失**：审批理由、题面、选项、文件变更等 agent 产出的文本此前没有上限，一条超长理由（实测 3 万字符）或 8 题 × 5 选项就能把卡片顶出字节/元素预算，被飞书整卡拒收——审批彻底不可见，回合只能挂到超时。现在自由文本按字节截断、题数/选项/变更条目按渲染上限折叠，最底层兜底卡改用紧凑审批区：审批按钮在任何降级档都保留
+- **停止 bash 任务后卡片稳定显示「已手动终止」**：停止路径与自然收尾会并发写同一张卡的终态，后写者胜出；现在首个终态胜出，不再被随后的「执行失败」覆盖
+- **内容审核截断后的自动续跑接回本轮会话**：续跑此前用入队时的会话快照，新会话第一条消息被截断时会落到一个全新的空会话，本轮上下文全部丢失；现在按卡片状态 → 运行中会话 → 起点快照三级取本轮实际使用的会话
+- **DSH 停止后残留的排队 prompt 不再被下一个回合隐形执行**：服务端 cancel 不会清空 inbox，被停的 prompt 可能仍留在里面等下一个无人订阅的 turn 认领（耗 token、改工作区、卡片不可见）。现在 cancel 确认关闭后补一次撤回探测，确认不在或撤回成功才清在途标记；退出路径的 cancel 走同一收尾
+- **DSH 断线重连后的历史缺口会回填**：重连快照按消息截取，断连期间积压超过 200 条消息时快照首条会越过上次游标，中间的运行事件此前对本次订阅永久缺失。现在用 `session/page` 的游标向前翻页补齐（最多 20×200 条）；尾部是用户消息时事件探测返回 `unknown`，不再误报「已停止」
+- **pi 会话切换后旧连接不再误杀新回合**：`/new`、`/resume` 切换会替换连接，旧连接迟到的关闭/事件此前会被推进新回合的共享队列，导致新消息未发出即丢失或新回合空转「成功」。现在连接回调带轮次代际锚点，非当前轮的迟到回调直接丢弃
+- **上下文占用统计包含末轮输出**：统一口径改为「输入 + 输出 + 缓存读 + 缓存写」，与文档和压缩水位一致；长收尾回合不再系统性低估数千到数万 token
+- **会话列表不再把 subagent 子会话当成父会话**：codex 按 id 读取与列表/active 同口径过滤子线程；kimi 的工作目录判定改用同路径比较，大小写或尾分隔符差异不再让会话从列表消失
+- **配置 YAML 语法错误不再静默退出**：与配置校验失败同路径在终端输出原因并退出，而不是零输出地无声退出
+- **工作区兜底与路径竞态收紧**：没有当前目录时取「最近使用」的工作区而不是最早保存的别名；`/cd`、`ls.switch`、`/ws use` 的目录检查补 TOCTOU 防护，路径在检查与使用之间被删时给出明确回复而不是静默失败
+- **只有 chatId 的旧绑定记录可以重新认领**：这类记录此前会让所有消息被静默拒绝且永远无法重新绑定，现在视为未绑定，任意首条私聊可重新认领
+- **卡片动作不再被在途媒体下载卡住**：会话变更类卡片动作执行前的入站冲刷改为 2 秒有界等待，大文件下载在途时点「新会话」不再让整个聊天停摆到下载超时；clone 引导期间到达的附件直接忽略，不再落盘或与引导话术冲突
+- **`job.kill` 等纯远程操作立即执行**：终态卡上的「停止后台任务」不再排进串行队列等当前 run 结束
+- **显式清空的模型配置重启后不再被旧选择填回**：`/config` 里清空模型/服务商等于回到默认，残留的旧选择不会再把它填回去
+- **其他可靠性修复**：实例锁改为先写完整临时文件再原子链接，消除并发启动时的空文件窗口；pi 大上下文压缩不再受 60 秒请求超时影响；kimi 非终态的空工具结果不再把运行中的工具提前标成完成；DSH 会话读取遇到单条畸形事件只跳过该条，不再整张恢复卡变空；JSONL 流按字节边界解码，中文/emoji 被 chunk 切开时不再出现乱码
+
+### 安全
+
+- **退出时取消 DSH 回合的凭据临时文件不再可预测**：此前把短时 cookie 写到 `<tmpdir>/lark-remote-exit-cancel-<pid>.hdr`，同机其他用户可预建软链把凭据引到自己可读的文件。现在写入仅本人可进入的随机 0700 临时目录、文件 0600，正常结束与异常路径都会清理
+
+### 变更
+
+- **架构文档同步**：last-session 允许 cwd 缺失、两处终端直写豁免、标题显示宽度常量、DSH follow 快照与事件落盘顺序，中英两侧一致
+
 ## [0.5.10] - 2026-10-24
 
 ### 修复

package/dist/binder.js

@@ -44,7 +44,13 @@ export class OwnerBinder {
      */
     authorize(userId, chatId) {
         const bound = this.store.getContact();
-        if (bound) {
+        // 只有 chatId 没有 userId 的记录（老版本写入/手改文件）视同未绑定：
+        // bound.userId === undefined 时任何真实 openId 都判不等，一切消息被
+        // 静默 rejected 且永远无法重新认领——用户只能靠文档提示删文件。
+        if (bound && bound.userId === undefined) {
+            getLogger().warn('[binder] startup contact has chatId but no userId; treating as unbound (re-claimable)');
+        }
+        else if (bound) {
             if (userId === bound.userId)
                 return { kind: 'owner' };
             this.rejectedTotal++;

package/dist/bridge/index.js

@@ -682,8 +682,10 @@ export class Bridge {
         for (const [runId, b] of bashTargets) {
             getLogger().info(`[lark-remote] interrupt hit bash runId=${runId} cwd=${b.cwd} userId=${input.userId}`);
             await b.bashRunner.stop({ immediate: true });
-            // Update card to show interrupted state
-            await b.cardSession.finish('interrupted', { exitCode: -1 });
+            // Update card to show interrupted state. exitCode 不传（保持 null）：
+            // bash-renderer 的「已手动终止」文案要求 exitCode === null；传 -1 会让
+            // 该分支不可达，中断卡退化成「退出码: -1」的失败样式。
+            await b.cardSession.finish('interrupted');
             this.activeBashRuns.delete(runId);
             getLogger().info(`[lark-remote] interrupt bash stop done runId=${runId}`);
             stoppedCount++;
@@ -1006,6 +1008,7 @@ export class Bridge {
         // 放在 finalize 之后：activeRuns 槽位已释放，续跑能正常开新卡片。
         await this.retryAfterContentFilter({
             cardSession,
+            activeRun,
             ctx,
             cwd,
             agentKind,
@@ -1042,6 +1045,12 @@ export class Bridge {
             getLogger().info(`[lark-remote] content_filter auto-retry skipped: session epoch moved runId=${state.runId}`);
             return;
         }
+        // 续跑必须接「本轮实际使用的 session」而非入队时刻快照（与 finalize 路径
+        // 的三级优先同口径：卡片状态 → activeRun → 起点快照）。快照只在 run 未建立
+        // 任何新会话时兜底。可证场景：新会话第一条消息（快照 undefined）被截断——
+        // init 已建立 S1，epoch 未动，传快照会让续跑落到全新空会话，本轮上下文
+        // 全部丢失；claude --resume fork 场景同理（init 上报的 id 才是权威）。
+        const retrySessionId = state.sessionId ?? params.activeRun.sessionId ?? params.sessionId;
         getLogger().warn(`[lark-remote] content_filter detected, auto-retrying once runId=${state.runId} cwd=${params.cwd}`);
         await this.sendResult({
             text: '🔁 上一回合被服务方内容审核截断（content_filter，通常是误报），已自动重试一次。',
@@ -1052,7 +1061,7 @@ export class Bridge {
                 cwdOverride: params.cwd,
                 binding: {
                     agent: params.agentKind,
-                    sessionId: params.sessionId,
+                    sessionId: retrySessionId,
                     sessionEpoch: params.sessionEpochAtStart,
                 },
                 autoRetry: true,

package/dist/card/approval-render.d.ts

@@ -14,3 +14,17 @@ export declare function renderApprovalArea(approval: ApprovalView | undefined, o
     runId?: string;
     terminal?: string;
 }): object[];
+/**
+ * 紧凑审批区（run 卡 skeleton/truncatedSkeleton 兜底档专用）：固定小体积的
+ * 「标题 + 摘要 reason + 决策按钮」，不渲染正文/选项/题面。
+ *
+ * 为什么需要：完整审批区是唯一不受估算器管辖、也不参与 degraded/extreme 分层
+ * 裁剪的区域； pathological 输入（超长 reason、题数×选项爆元素数）会让所有兜底
+ * 层一起超限，超限卡被飞书整卡拒收（11310）→ 审批不可见。兜底层换用本入口后
+ * 结构性保证 ≤ 几个元素 + ≤ 1KB 文本，审批入口（红线）在任何降级档都活着。
+ */
+export declare function renderApprovalAreaCompact(approval: ApprovalView | undefined, opts?: {
+    expired?: boolean;
+    runId?: string;
+    terminal?: string;
+}): object[];

package/dist/card/approval-render.js

@@ -8,17 +8,50 @@ import { collapsibleMarkdownPanel } from './collapsible.js';
 import { truncateMarkdownTables } from './text-truncate.js';
 import { truncateUtf8 } from '../common/truncate.js';
 import { cardButton } from './card-shared.js';
+import { countCardElements } from './card-budget.js';
 /** Unique nonce for card button callbacks (SDK dedup + router validation). */
 function mkNonce() {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 /** 计划面板正文字节预算（折叠展示 + 截断保护 28KB 卡片预算）。 */
 const PLAN_PANEL_BYTES = 6000;
-/** reason div（3 处共用）；反引号中和防 lark_md 解析错误。 */
+/**
+ * 审批区自由文本字段（reason/note/题面/描述/回执等 agent 产出的散文）的统一
+ * 字节预算。这些字段此前无上限：实测 reason 30,000 字符 → 整卡 31,450 字节被
+ * 飞书 11310 拒收，审批彻底不可见，run 只能挂到审批超时/看门狗。1KB 足以传达
+ * 语义并支撑决策。
+ */
+const APPROVAL_FIELD_BYTES = 1000;
+/** 短标签类字段（题头/工具名/路径）的字节预算。 */
+const APPROVAL_LABEL_BYTES = 300;
+/**
+ * 提问批次的渲染上限：题数 × 每题元素（选项行 + 输入框 + 按钮）撑爆的是元素
+ * 数预算（实测 8 题 × 5 选项 = 144 元素 > 90 上限 → 11310 整卡报废）。超出的
+ * 题折叠为计数提示；被折叠的题无法在卡上作答（整批「跳过」与 Web UI/终端
+ * 兜底），仍远好于整卡被拒、一题都答不了。
+ */
+const MAX_RENDERED_QUESTIONS = 5;
+/** 单题选项渲染上限（超过折叠为计数提示；选项 label 是回调 payload，不可截断）。 */
+const MAX_RENDERED_OPTIONS = 8;
+/** 文件变更 / 权限条目的渲染上限（每条 1–2 个元素，无上限时百条级直接爆元素预算）。 */
+const MAX_RENDERED_CHANGE_ITEMS = 20;
+/**
+ * 审批区自身的元素数预算：卡总预算（MAX_CARD_ELEMENTS=90）减去状态行 / goal /
+ * summary / 操作行等骨架（约 20 个，含极端情况的余量）后的安全份额。按已渲染
+ * 元素数**自适应**截断——固定题数 × 选项数的组合上限挡不住「少题多选项」与
+ * 「多题少选项」的两种组合（一行选项 = column_set + button + div 共 3 个
+ * 元素，5 题 × 5 选项就 ~92 个）。
+ */
+const APPROVAL_AREA_ELEMENT_BUDGET = 50;
+/** 审批区自由文本统一入口：反引号中和（防 11311）+ 字节预算截断（防 11310）。 */
+function capApprovalText(text, maxBytes = APPROVAL_FIELD_BYTES) {
+    return truncateUtf8(text.replace(/`/g, '·'), maxBytes);
+}
+/** reason div（3 处共用）；反引号中和防 lark_md 解析错误 + 字节预算截断。 */
 function reasonDiv(approval) {
     if (!approval.reason)
         return null;
-    const neutralized = approval.reason.replace(/`/g, '·');
+    const neutralized = capApprovalText(approval.reason);
     return {
         tag: 'div',
         text: { tag: 'lark_md', content: `💡 ${neutralized}` },
@@ -41,12 +74,11 @@ export function renderApprovalArea(approval, opts) {
         return [];
     // 终态（done/error/interrupted/idle_timeout）下 run 已结束：coordinator 已
     // 释放，按钮点击无处响应，隐藏整个审批区避免"点了没反应"。
-    if (opts?.terminal && opts.terminal !== 'running' && opts.terminal !== 'finalizing') {
+    if (isTerminalHidden(opts))
         return [];
-    }
     const elements = [];
     if (approval.note) {
-        const neutralized = approval.note.replace(/`/g, '·');
+        const neutralized = capApprovalText(approval.note);
         elements.push({
             tag: 'div',
             text: { tag: 'lark_md', content: `ℹ️ ${neutralized}` },
@@ -69,7 +101,7 @@ export function renderApprovalArea(approval, opts) {
     }
     // 响应发送失败：明确告知原因 + 可重试，而不是静默停在可点状态。
     if (approval.deliveryError) {
-        const neutralized = approval.deliveryError.replace(/`/g, '·');
+        const neutralized = capApprovalText(approval.deliveryError);
         elements.push({
             tag: 'div',
             text: {
@@ -80,6 +112,54 @@ export function renderApprovalArea(approval, opts) {
     }
     return elements;
 }
+/**
+ * 紧凑审批区（run 卡 skeleton/truncatedSkeleton 兜底档专用）：固定小体积的
+ * 「标题 + 摘要 reason + 决策按钮」，不渲染正文/选项/题面。
+ *
+ * 为什么需要：完整审批区是唯一不受估算器管辖、也不参与 degraded/extreme 分层
+ * 裁剪的区域； pathological 输入（超长 reason、题数×选项爆元素数）会让所有兜底
+ * 层一起超限，超限卡被飞书整卡拒收（11310）→ 审批不可见。兜底层换用本入口后
+ * 结构性保证 ≤ 几个元素 + ≤ 1KB 文本，审批入口（红线）在任何降级档都活着。
+ */
+export function renderApprovalAreaCompact(approval, opts) {
+    if (!approval)
+        return [];
+    if (isTerminalHidden(opts))
+        return [];
+    const elements = [
+        {
+            tag: 'div',
+            text: {
+                tag: 'lark_md',
+                content: '✋ **等待审批**（内容过长已折叠，完整内容请查终端 / Web UI）',
+            },
+        },
+    ];
+    pushIf(elements, reasonDiv(approval));
+    if (approval.kind === 'question') {
+        if (opts?.expired) {
+            elements.push({ tag: 'div', text: { tag: 'lark_md', content: '⏰ **提问已超时**' } });
+        }
+        else {
+            // 提问批次的紧凑形态只保留整批跳过（逐题作答 UI 被折叠）。
+            elements.push(cardButton('⏭️ 跳过回答', {
+                cmd: 'approval.respond',
+                decision: 'decline',
+                requestId: approval.requestId,
+                runId: opts?.runId,
+                nonce: mkNonce(),
+            }, { type: 'default' }));
+        }
+    }
+    else {
+        elements.push(...renderDecisionButtons(approval, opts?.expired, opts?.runId));
+    }
+    return elements;
+}
+/** 终态隐藏判定（renderApprovalArea 与 compact 共用）。 */
+function isTerminalHidden(opts) {
+    return !!opts?.terminal && opts.terminal !== 'running' && opts.terminal !== 'finalizing';
+}
 /**
  * Render approval action buttons from the real protocol decision list.
  * accept and decline are always offered (decline is a universal safety
@@ -150,7 +230,7 @@ function renderToolApproval(approval, expired, runId) {
             content: '**🔧 工具请求**',
         },
     });
-    const toolLabel = approval.toolName ?? '(unknown tool)';
+    const toolLabel = capApprovalText(approval.toolName ?? '(unknown tool)', APPROVAL_LABEL_BYTES);
     elements.push({
         tag: 'div',
         text: { tag: 'lark_md', content: `🔧 \`${toolLabel}\`` },
@@ -158,10 +238,10 @@ function renderToolApproval(approval, expired, runId) {
     pushIf(elements, reasonDiv(approval));
     // 原始 input（非空时展示，截断保护卡片预算；ExitPlanMode 的 `{}` 不展示）。
     if (approval.toolInput && approval.toolInput !== '{}') {
-        const neutralized = approval.toolInput.replace(/`/g, '·');
+        const neutralized = capApprovalText(approval.toolInput, 500);
         elements.push({
             tag: 'div',
-            text: { tag: 'lark_md', content: `\`${neutralized.slice(0, 500)}\`` },
+            text: { tag: 'lark_md', content: `\`${neutralized}\`` },
         });
     }
     elements.push(...renderDecisionButtons(approval, expired, runId));
@@ -184,7 +264,7 @@ function renderPlanApproval(approval, expired, runId) {
     });
     pushIf(elements, reasonDiv(approval));
     if (approval.planFilePath) {
-        const neutralizedPath = approval.planFilePath.replace(/`/g, '·');
+        const neutralizedPath = capApprovalText(approval.planFilePath, APPROVAL_LABEL_BYTES);
         elements.push({
             tag: 'div',
             text: { tag: 'lark_md', content: `📄 ${neutralizedPath}` },
@@ -215,7 +295,7 @@ function renderPlanApproval(approval, expired, runId) {
     if (!expired) {
         elements.push(renderPlanFeedbackInput(approval.requestId, runId));
         if (approval.planFeedback) {
-            const neutralized = approval.planFeedback.replace(/`/g, '·');
+            const neutralized = capApprovalText(approval.planFeedback);
             elements.push({
                 tag: 'div',
                 text: { tag: 'lark_md', content: `📝 ${neutralized}` },
@@ -259,18 +339,17 @@ function renderCommandApproval(approval, expired, runId) {
     // Command display
     // 命令里的反引号会提前终止 lark_md 行内代码 span，奇数次
     // 反引号极易触发 11311 解析错误导致整卡失败（同 renderFileDiff 的中和策略）。
-    const neutralizedCommand = (approval.command ?? '').replace(/`/g, '·');
-    const cmdContent = neutralizedCommand
-        ? `\`${neutralizedCommand.slice(0, 500)}\``
-        : '(no command)';
+    const neutralizedCommand = capApprovalText(approval.command ?? '', 500);
+    const cmdContent = neutralizedCommand ? `\`${neutralizedCommand}\`` : '(no command)';
     elements.push({
         tag: 'div',
         text: { tag: 'lark_md', content: `**⚡ 命令审批**\n${cmdContent}` },
     });
     if (approval.commandCwd) {
+        const neutralizedCwd = capApprovalText(approval.commandCwd, APPROVAL_LABEL_BYTES);
         elements.push({
             tag: 'div',
-            text: { tag: 'lark_md', content: `📂 \`${approval.commandCwd}\`` },
+            text: { tag: 'lark_md', content: `📂 \`${neutralizedCwd}\`` },
         });
     }
     pushIf(elements, reasonDiv(approval));
@@ -297,11 +376,16 @@ function renderFileApproval(approval, expired, runId) {
         const TOTAL_DIFF_CHARS = 2400;
         let renderedDiffChars = 0;
         let omittedDiffs = 0;
-        for (const change of approval.fileChanges) {
+        // 条目数上限（元素预算）：每条 1 path div + 至多 1 diff div，无上限时
+        // 百条级变更直接撑爆元素数（>90 → 11310 整卡报废）。
+        const changes = approval.fileChanges.slice(0, MAX_RENDERED_CHANGE_ITEMS);
+        const omittedChanges = approval.fileChanges.length - changes.length;
+        for (const change of changes) {
             const icon = change.kind === 'add' ? '🆕' : change.kind === 'delete' ? '🗑️' : '✏️';
+            const path = capApprovalText(change.path, APPROVAL_LABEL_BYTES);
             elements.push({
                 tag: 'div',
-                text: { tag: 'lark_md', content: `${icon} \`${change.path}\` (${change.kind})` },
+                text: { tag: 'lark_md', content: `${icon} \`${path}\` (${change.kind})` },
             });
             if (change.diff) {
                 if (renderedDiffChars < TOTAL_DIFF_CHARS) {
@@ -316,6 +400,12 @@ function renderFileApproval(approval, expired, runId) {
                 }
             }
         }
+        if (omittedChanges > 0) {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `_…另有 ${omittedChanges} 个文件变更未展示（卡片预算）_` },
+            });
+        }
         if (omittedDiffs > 0) {
             elements.push({
                 tag: 'div',
@@ -354,11 +444,16 @@ function renderPermissionsApproval(approval, expired, runId) {
     pushIf(elements, reasonDiv(approval));
     // Permission items with toggle buttons
     if (approval.permissions?.items) {
-        for (const item of approval.permissions.items) {
+        // 条目数上限（元素预算）：每条 label div + toggle button 共 2 个元素。
+        const items = approval.permissions.items.slice(0, MAX_RENDERED_CHANGE_ITEMS);
+        const omittedItems = approval.permissions.items.length - items.length;
+        for (const item of items) {
             const icon = item.selected ? '✅' : '⬜';
+            // label 仅展示（payload 用 item.id），可安全截断。
+            const label = capApprovalText(item.label, APPROVAL_LABEL_BYTES);
             elements.push({
                 tag: 'div',
-                text: { tag: 'lark_md', content: `${icon} ${item.label}` },
+                text: { tag: 'lark_md', content: `${icon} ${label}` },
             });
             elements.push(cardButton(item.selected ? '取消授予' : '授予', {
                 cmd: 'approval.toggle',
@@ -369,6 +464,12 @@ function renderPermissionsApproval(approval, expired, runId) {
                 nonce: mkNonce(),
             }, { type: item.selected ? 'default' : 'primary', size: 'small' }));
         }
+        if (omittedItems > 0) {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `_…另有 ${omittedItems} 项权限未展示（卡片预算）_` },
+            });
+        }
     }
     // Action buttons
     // Derived from the real protocol decision list (see renderDecisionButtons).
@@ -396,7 +497,7 @@ function renderQuestionApproval(approval, expired, runId) {
     if (approval.intro) {
         elements.push({
             tag: 'div',
-            text: { tag: 'lark_md', content: `📝 ${approval.intro}` },
+            text: { tag: 'lark_md', content: `📝 ${capApprovalText(approval.intro)}` },
         });
     }
     if (expired) {
@@ -410,22 +511,36 @@ function renderQuestionApproval(approval, expired, runId) {
         if (approval.expiredHint) {
             elements.push({
                 tag: 'div',
-                text: { tag: 'lark_md', content: approval.expiredHint.replace(/`/g, '·') },
+                text: { tag: 'lark_md', content: capApprovalText(approval.expiredHint) },
             });
         }
         return elements;
     }
     const questions = approval.questions ?? [];
+    let renderedQuestions = 0;
     for (let i = 0; i < questions.length; i++) {
+        // 题数粗上限 + 审批区元素预算（自适应）：任一触发即折叠剩余题。
+        if (i >= MAX_RENDERED_QUESTIONS ||
+            countCardElements({ elements }) > APPROVAL_AREA_ELEMENT_BUDGET) {
+            elements.push({
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `_…另有 ${questions.length - renderedQuestions} 题未展示（卡片元素预算）；可在终端 / Web UI 回答，或点下方「跳过回答」跳过整批_`,
+                },
+            });
+            break;
+        }
+        renderedQuestions++;
         const q = questions[i];
         const selected = q.selected ?? [];
-        const header = q.header || `问题 ${i + 1}`;
+        const header = capApprovalText(q.header || `问题 ${i + 1}`, APPROVAL_LABEL_BYTES);
         const freeText = (q.options?.length ?? 0) === 0;
         elements.push({
             tag: 'div',
             text: {
                 tag: 'lark_md',
-                content: `**${header}**${q.multiSelect ? '（可多选）' : ''}\n${q.question}`,
+                content: `**${header}**${q.multiSelect ? '（可多选）' : ''}\n${capApprovalText(q.question)}`,
             },
         });
         if (q.detail) {
@@ -451,24 +566,35 @@ function renderQuestionApproval(approval, expired, runId) {
             if (answered) {
                 elements.push({
                     tag: 'div',
-                    text: { tag: 'lark_md', content: `✍️ 已答：${answered}` },
+                    text: { tag: 'lark_md', content: `✍️ 已答：${capApprovalText(answered)}` },
                 });
             }
             continue;
         }
-        for (const option of q.options ?? []) {
+        // 选项渲染上限（label 是回调 payload 不可截断，只能按条数折叠）。
+        const options = q.options ?? [];
+        for (const option of options.slice(0, MAX_RENDERED_OPTIONS)) {
             const isSelected = selected.includes(option.label);
             // 单选/多选图标区分：单选 ⚪/🔵（radio 隐喻），多选 ⬜/☑️（checkbox 隐喻）。
             const icon = q.multiSelect ? (isSelected ? '☑️' : '⬜') : isSelected ? '🔵' : '⚪';
             elements.push(renderOptionRow(approval.requestId, i, option, isSelected, icon, runId));
         }
+        if (options.length > MAX_RENDERED_OPTIONS) {
+            elements.push({
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `_…另有 ${options.length - MAX_RENDERED_OPTIONS} 个选项未展示（卡片元素预算）_`,
+                },
+            });
+        }
         // 自定义答案（Other）的选中态展示：选项按钮无法表示自由文本，单独显示
         // 已选文本，避免「点了没反应」的困惑。
         const customSelected = q.selected?.find((s) => !q.options.some((o) => o.label === s));
         if (customSelected) {
             elements.push({
                 tag: 'div',
-                text: { tag: 'lark_md', content: `✍️ 自定义答案：${customSelected}` },
+                text: { tag: 'lark_md', content: `✍️ 自定义答案：${capApprovalText(customSelected)}` },
             });
         }
         // 单选问题提供自定义答案（Other）输入——输入文本后提交
@@ -486,7 +612,7 @@ function renderQuestionApproval(approval, expired, runId) {
             if (q.note) {
                 elements.push({
                     tag: 'div',
-                    text: { tag: 'lark_md', content: `📝 ${q.note}` },
+                    text: { tag: 'lark_md', content: `📝 ${capApprovalText(q.note)}` },
                 });
             }
         }
@@ -550,7 +676,7 @@ function renderOptionRow(requestId, questionIndex, option, isSelected, icon, run
                         tag: 'div',
                         text: {
                             tag: 'lark_md',
-                            content: `${icon} ${option.label}${option.description ? `\n_${option.description}_` : ''}`,
+                            content: `${icon} ${option.label}${option.description ? `\n_${capApprovalText(option.description)}_` : ''}`,
                         },
                     },
                 ],

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

@@ -68,6 +68,14 @@ export class BashCardSession extends CardSession {
     }
     /** Transition to a terminal state and patch the card. */
     async finish(terminal, meta = {}) {
+        // 终态守卫（与 run-state 的 finishRun 首终态优先同口径）：/stop 路径
+        // （bridge.interruptCurrentRun）与 executeBashInternal 的自然收尾路径会对
+        // 同一张卡并发 finish——SIGKILL 后 exitCode 为 -1，自然路径的
+        // finish('error', { exitCode: -1 }) 会把 interrupt 路径刚写的 'interrupted'
+        // 覆盖成「执行失败」，后落者胜出且取决于时序。首终态胜出后忽略后续 finish。
+        if (this.state.terminal !== 'running') {
+            return;
+        }
         this.cancelPendingFlush();
         // 若有 in-flight flush 正在 await updateCard，必须等它完成后再发终态 patch，
         // 保证顺序（pre-terminal 先落地 → terminal 后落地 → terminal 胜出）。

package/dist/card/bash-renderer.js

@@ -1,7 +1,7 @@
 import { terminalToColor, terminalToLabel, stopButton } from './card-shared.js';
 import { markdownDiv } from './collapsible.js';
 import { CARD_BUDGET_BYTES } from './text-truncate.js';
-import { truncateUtf8 } from '../common/truncate.js';
+import { truncateUtf8, truncate } from '../common/truncate.js';
 /**
  * 飞书卡片大小限制（安全阈值，与 run-renderer 一致）。
  * 从共享的 text-truncate.ts 导入，避免三处各自定义后数值漂移。
@@ -20,36 +20,24 @@ const OUTPUT_MAX_BYTES = 12_000;
  */
 const DEGRADED_OUTPUT_BYTES = 4_000;
 /**
- * Truncate long commands for display.
+ * Truncate long commands for display. 按码点截断（裸 slice 切在 emoji 中间会
+ * 留下孤立代理项进卡片），项目已有 truncate() 实现同语义。
  */
 function truncateCommand(cmd, maxLen = 40) {
-    if (cmd.length <= maxLen)
-        return cmd;
-    return cmd.slice(0, maxLen - 3) + '...';
+    return truncate(cmd, maxLen);
 }
 /**
- * Build the status row (status tag + command) element.
+ * Build the status row element.
+ *
+ * 单 div + ` · ` 分隔（窄屏硬闸，与 run-renderer 的 statusRow 同款）：旧版把
+ * 状态标签（2 字短文本）放 `column_set` 的 auto 列、命令放 grow 列——手机
+ * 窄屏下 auto 列会被挤成竖排（run 卡踩过同型坑，bash 卡漏改）。
+ * 单行文本的换行点只落在 " · " 处，各分段自身不折行。
  */
 function buildStatusRow(state) {
     const { terminal, exitCode, command } = state;
     const statusLabel = bashStatusTagLabel(terminal, exitCode);
-    return {
-        tag: 'column_set',
-        columns: [
-            {
-                tag: 'column',
-                width: 'auto',
-                elements: [{ tag: 'div', text: { content: statusLabel, tag: 'lark_md' } }],
-            },
-            {
-                tag: 'column',
-                width: 'grow',
-                elements: [
-                    { tag: 'div', text: { content: `⏱ ${truncateCommand(command, 40)}`, tag: 'lark_md' } },
-                ],
-            },
-        ],
-    };
+    return markdownDiv(`${statusLabel} · ⏱ ${truncateCommand(command, 40)}`, 'notation');
 }
 /**
  * Build the exit code footer elements (terminal states only).

package/dist/card/card-budget.js

@@ -224,7 +224,12 @@ function enforceByteBudget(truncated, opts = {}, bytesBefore) {
         dropOldestPanels(panelCount - maxEventPanels);
         reasons.push('event_count_limited');
     }
-    if (size() <= CARD_BUDGET_BYTES) {
+    // 元素数预算必须与字节预算同查（含 hint 预留位）：字节路径的返回条件此前
+    // 只看字节——元素超限但卡内无 collapsible_panel 时（如 95 个小 div），
+    // 阶段1-4 全是空操作，超限卡原样直通（实测 wasTruncated:false、95 元素
+    // > 90 → 飞书 11310 整卡报废，正是文件头注释记载的 /ws、/order 故障形态）。
+    const elementsWithinBudgetWithHint = () => countCardElements(truncated) + (omitted > 0 ? 1 : 0) <= MAX_CARD_ELEMENTS;
+    if (size() <= CARD_BUDGET_BYTES && elementsWithinBudgetWithHint()) {
         insertOmittedHint(elements, omitted, truncationHint);
         return done(modifications > 0 || omitted > 0);
     }
@@ -235,13 +240,12 @@ function enforceByteBudget(truncated, opts = {}, bytesBefore) {
     if (omitted > 0) {
         reasons.push('panels_dropped');
     }
-    if (size() <= CARD_BUDGET_BYTES) {
+    if (size() <= CARD_BUDGET_BYTES && elementsWithinBudgetWithHint()) {
         insertOmittedHint(elements, omitted, truncationHint);
         return done(true);
     }
     // ========== 阶段4：截断剩余顶层 div 文本 ==========
     // 骨架元素（header/usage 等）自身超限的情况（如超大 displayTitle）。
-    insertOmittedHint(elements, omitted, truncationHint);
     let textTruncations = 0;
     for (const el of elements) {
         if (el.tag === 'div' && el.text?.content) {
@@ -255,9 +259,25 @@ function enforceByteBudget(truncated, opts = {}, bytesBefore) {
     if (textTruncations > 0) {
         reasons.push('text_truncated');
     }
-    if (size() <= CARD_BUDGET_BYTES) {
+    if (size() <= CARD_BUDGET_BYTES && elementsWithinBudgetWithHint()) {
+        insertOmittedHint(elements, omitted, truncationHint);
         return done(true);
     }
+    // ========== 阶段4.5：元素数兜底（无面板可删的元素超限） ==========
+    // 阶段1-4 只会裁内容/删面板；元素超限且无面板时在此按序丢弃最旧的顶层
+    // 元素直到达标（与 table/panel 的「删最旧、留最新」口径一致，尾部操作
+    // 按钮保留）。留 ≥3 个元素兜底，仍不达标则交给阶段5 的最小卡。
+    if (countCardElements(truncated) > MAX_CARD_ELEMENTS) {
+        while (countCardElements(truncated) > MAX_CARD_ELEMENTS && elements.length > 3) {
+            elements.shift();
+            omitted++;
+        }
+        reasons.push('element_budget_elements_dropped');
+        if (size() <= CARD_BUDGET_BYTES && elementsWithinBudgetWithHint()) {
+            insertOmittedHint(elements, omitted, truncationHint);
+            return done(true);
+        }
+    }
     // ========== 阶段5：最终兜底（原 extreme_fallback） ==========
     const minimalCard = cardWithHeader({
         template: 'orange',