lark-remote 0.5.9 → 0.5.12

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',

package/dist/card/run-renderer.js

@@ -9,7 +9,7 @@ import { displayWidth, truncateToDisplayWidth } from '../common/text-width.js';
 import { isContentFilterFailure } from '../common/turn-failure.js';
 import { formatClock, formatTimestamp } from './time.js';
 import { formatUsageStats } from '../router/usage-format.js';
-import { renderApprovalArea } from './approval-render.js';
+import { renderApprovalArea, renderApprovalAreaCompact } from './approval-render.js';
 const REASONING_BYTES = 4_500;
 const TEXT_BYTES = 10_000;
 const DEGRADED_THINKING_KEEP = 2;
@@ -448,6 +448,24 @@ function approvalArea(state) {
     }
     return elements;
 }
+/**
+ * 紧凑审批区（skeleton/truncatedSkeleton 兜底专用）：完整审批区不受估算器
+ * 管辖、不参与 degraded/extreme 分层裁剪，pathological 输入（超长 reason、
+ * 题数×选项爆元素数）会让所有兜底层一起超限——超限卡被飞书整卡拒收（11310），
+ * 审批彻底不可见，run 挂到审批超时/看门狗。兜底层换用紧凑形态（固定小体积、
+ * 保留决策/跳过按钮），结构性保证审批入口在任何降级档都活着。
+ */
+function approvalAreaCompact(state) {
+    const elements = [];
+    for (const slot of state.approvals ?? []) {
+        elements.push(...renderApprovalAreaCompact(slot.view, {
+            expired: slot.expired,
+            runId: state.runId,
+            terminal: state.terminal,
+        }));
+    }
+    return elements;
+}
 /** 底部操作行之前的内容区提示：被 MAX_BLOCKS 截掉的早期块计数（信息保真）。 */
 function omittedBlocksHint(state) {
     return state.omittedBlocks !== undefined && state.omittedBlocks > 0
@@ -654,11 +672,12 @@ function elapsedLabel(state) {
         return `${hours}h${String(minutes % 60).padStart(2, '0')}m`;
     return `${Math.floor(hours / 24)}d${String(hours % 24).padStart(2, '0')}h`;
 }
-/** token 数量的紧凑写法：`950` / `12K` / `1.2M`。 */
+/** token 数量的紧凑写法：`950` / `12K` / `1.0M`。 */
 function formatTokens(tokens) {
     if (tokens < 1000)
         return String(tokens);
-    if (tokens < 1_000_000)
+    // 千位边界取 M 档：999_500 起四舍五入会得到 "1000K"，直接按 M 档展示。
+    if (tokens < 999_500)
         return `${Math.round(tokens / 1000)}K`;
     return `${(tokens / 1_000_000).toFixed(1)}M`;
 }
@@ -885,20 +904,23 @@ export function renderRunCard(state, options = {}) {
         return extremeCard;
     }
     const skeletonCard = assembleRunCard(state, options, buildSkeletonElements(state, options));
-    // skeleton 卡是静态结构，理论上必 ≤28KB；保留兜底断言以防未来结构膨胀
-    if (Buffer.byteLength(JSON.stringify(skeletonCard), 'utf8') <= CARD_BUDGET_BYTES) {
+    // skeleton 卡是静态结构，理论上必 ≤28KB；但审批区/summary 携带 agent 产出
+    // 文本，仍可能把任一维度顶爆（此前只查字节——题数×选项的元素数超限会漏网）。
+    // 保留兜底断言以防未来结构膨胀；超限则降级到 truncatedSkeleton。
+    if (withinRunCardBudget(skeletonCard)) {
         return skeletonCard;
     }
-    // 理论上不可达：skeleton 已是静态最小结构。若仍超限（errorMsg 等无界文本
-    // 灌进 summary），硬截断只丢 summary——审批入口与 stop/新会话按钮是红线，
-    // 任何一级兜底都不能把它们截掉（丢了用户就再也停不下这个 run）。
+    // 理论上不可达：skeleton 已是静态最小结构。若仍超限（超长 reason、题数×
+    // 选项爆元素数等审批区输入），硬截断只丢 summary 与完整审批区——审批入口
+    // （紧凑形态：标题 + 摘要 + 决策/跳过按钮）与 stop/新会话按钮是红线，任何
+    // 一级兜底都不能把它们截掉（丢了用户就再也停不下这个 run / 答不了审批）。
     const truncatedSkeleton = {
         ...skeletonCard,
         body: {
             elements: [
                 statusRow(state),
                 markdownDiv('_⚠️ 输出过大_'),
-                ...approvalArea(state),
+                ...approvalAreaCompact(state),
                 ...actionRow(state, options),
             ],
         },

package/dist/common/text-width.js

@@ -54,6 +54,11 @@ function charWidth(ch) {
         return 2;
     if (code >= 0x2600 && code <= 0x27bf)
         return 2;
+    // Misc Technical 块（U+2300–U+23FF）：⏱⏹⏳⏸⏺ 等计时器/播放器符号在
+    // 状态行里实际使用，手机端按 emoji 宽度渲染——按 1 计会系统性低估行宽，
+    // 窄屏余量比设计值更小。
+    if (code >= 0x2300 && code <= 0x23ff)
+        return 2;
     return 1;
 }
 /**

package/dist/common/tool-summary.js

@@ -61,7 +61,9 @@ export function summarizeToolInput(name, input) {
         if (typeof v !== 'string')
             return '';
         const oneLine = v.replace(/\s+/g, ' ').trim();
-        return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+        // 码点安全截断：裸 slice 切在代理对中间会留下孤立代理项进卡片
+        // （同族修复见 tool-render.ts 的 toolHeaderText）。
+        return truncate(oneLine, max);
     };
     /** First non-empty of several keys（DSH 同名工具跨版本改过参数名）。 */
     const pickAny = (keys, max = HEADER_SUMMARY_MAX) => {
@@ -82,7 +84,7 @@ export function summarizeToolInput(name, input) {
         for (const item of v) {
             if (typeof item === 'string' && item.trim()) {
                 const oneLine = item.replace(/\s+/g, ' ').trim();
-                return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+                return truncate(oneLine, max);
             }
             if (item && typeof item === 'object') {
                 const path = item.path;

package/dist/config/codex-config.js

@@ -518,9 +518,11 @@ export function loadCodexConfig(opts = {}) {
         };
     }
     catch {
-        // config.toml 解析失败（readModelCatalogJsonPath 已把此场景标记为 catalog 声明退化 ''）：
-        // catalogMode 为 true 时绝不回退 bundled/FALLBACK，返回空 provider/模型列表；
-        // 非 catalog 才走 FALLBACK 兜底。
+        // config.toml 读取/解析失败：readModelCatalogJsonPath 对此返回
+        // TOML_PARSE_FAILED_SENTINEL（isCodexCatalogMode → false），进入本 catch
+        // 时 catalogMode 恒为 false——下面的 `if (catalogMode)` 分支实际不可达，
+        // 仅作防御保留。真正「catalog 声明退化」的场景（'' 哨兵）在 parse 之前
+        // 就已按 FALLBACK 兜底处理，不会走到这里。
         if (catalogMode) {
             return {
                 currentModel: '',

package/dist/config/index.js

@@ -353,7 +353,19 @@ export function loadConfig(configPath) {
         process.exit(1);
     }
     const raw = fs.readFileSync(configPath, 'utf-8');
-    const parsed = YAML.parse(raw);
+    // YAML 语法错误（tab 缩进等）必须与校验失败同路径（console.error + exit）：
+    // 直接上抛会冒到 main().catch——此时 logger 尚未 initLogger，getLogger()
+    // 写的是默认目录的自定义 --config-dir 对不上，且 logger 只写文件，终端
+    // 零输出，用户只看到进程无声退出。
+    let parsed;
+    try {
+        parsed = YAML.parse(raw);
+    }
+    catch (err) {
+        console.error(`[lark-remote] config YAML parse failed at ${configPath}:`);
+        console.error(`  ${err.message}`);
+        process.exit(1);
+    }
     const result = AppConfigSchema.safeParse(parsed);
     if (!result.success) {
         const errors = result.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`).join('\n');