lark-remote 0.5.10 → 0.5.13

package/dist/bridge/run-usage.js

@@ -0,0 +1,96 @@
+import { normalizeResultUsage } from '../runner/common/result-usage.js';
+export class RunUsageCollector {
+    contextLength;
+    finalContextLength;
+    finalContextLimit;
+    finalCompactCount;
+    finalCacheReadTokens;
+    finalCacheCreationTokens;
+    finalTotalTokens;
+    liveInput;
+    liveOutput;
+    liveContextLimit;
+    finalInputTokens;
+    finalOutputTokens;
+    finalCumulativeTotalTokens;
+    finalCumulativeInputTokens;
+    finalCumulativeOutputTokens;
+    finalCumulativeCacheReadTokens;
+    finalCumulativeCacheCreationTokens;
+    finalReasoningTokens;
+    resultNotSuccess = false;
+    get liveInputTokens() {
+        return this.liveInput;
+    }
+    get liveOutputTokens() {
+        return this.liveOutput;
+    }
+    observeCompaction(postTokens) {
+        this.contextLength = postTokens;
+    }
+    observeResult(event) {
+        this.resultNotSuccess = event.subtype !== 'success';
+        if (!event.usage)
+            return;
+        const usage = normalizeResultUsage(event.usage);
+        if (!this.contextLength)
+            this.contextLength = usage.contextLength;
+        this.liveInput = usage.inputTokens;
+        this.liveOutput = usage.outputTokens;
+        this.liveContextLimit = usage.contextLimit;
+        if (usage.cacheReadTokens !== undefined)
+            this.finalCacheReadTokens = usage.cacheReadTokens;
+        if (usage.cacheCreationTokens !== undefined) {
+            this.finalCacheCreationTokens = usage.cacheCreationTokens;
+        }
+        if (usage.totalTokens !== undefined)
+            this.finalTotalTokens = usage.totalTokens;
+        if (usage.reasoningTokens !== undefined)
+            this.finalReasoningTokens = usage.reasoningTokens;
+    }
+    finalize(finalUsage, authority) {
+        this.finalContextLength = finalUsage?.contextLength ?? this.contextLength;
+        this.finalContextLimit = finalUsage?.contextLimit ?? this.liveContextLimit;
+        this.finalCompactCount = finalUsage?.compactCount;
+        this.finalCumulativeTotalTokens = finalUsage?.cumulativeTotalTokens;
+        this.finalCumulativeInputTokens = finalUsage?.cumulativeInputTokens;
+        this.finalCumulativeOutputTokens = finalUsage?.cumulativeOutputTokens;
+        this.finalCumulativeCacheReadTokens = finalUsage?.cumulativeCacheReadTokens;
+        this.finalCumulativeCacheCreationTokens = finalUsage?.cumulativeCacheCreationTokens;
+        const useLiveFlowScope = authority !== 'jsonl' && this.liveInput !== undefined && this.liveOutput !== undefined;
+        if (useLiveFlowScope) {
+            this.finalInputTokens = this.liveInput;
+            this.finalOutputTokens = this.liveOutput;
+            return;
+        }
+        this.finalInputTokens = finalUsage?.inputTokens ?? this.liveInput;
+        this.finalOutputTokens = finalUsage?.outputTokens ?? this.liveOutput;
+        this.finalCacheReadTokens = finalUsage?.cacheReadTokens ?? this.finalCacheReadTokens;
+        this.finalCacheCreationTokens =
+            finalUsage?.cacheCreationTokens ?? this.finalCacheCreationTokens;
+        this.finalTotalTokens = finalUsage?.totalTokens ?? this.finalTotalTokens;
+    }
+    meta() {
+        return {
+            contextLength: this.finalContextLength,
+            contextLimit: this.finalContextLimit,
+            compactCount: this.finalCompactCount,
+            cacheReadTokens: this.finalCacheReadTokens,
+            cacheCreationTokens: this.finalCacheCreationTokens,
+            totalTokens: this.finalTotalTokens,
+            inputTokens: this.finalInputTokens,
+            outputTokens: this.finalOutputTokens,
+            cumulativeTotalTokens: this.finalCumulativeTotalTokens,
+            cumulativeInputTokens: this.finalCumulativeInputTokens,
+            cumulativeOutputTokens: this.finalCumulativeOutputTokens,
+            cumulativeCacheReadTokens: this.finalCumulativeCacheReadTokens,
+            cumulativeCacheCreationTokens: this.finalCumulativeCacheCreationTokens,
+            reasoningTokens: this.finalReasoningTokens,
+        };
+    }
+    logSummary(runId) {
+        const meta = this.meta();
+        return `[lark-remote] final usage runId=${runId} contextLength=${meta.contextLength} contextLimit=${meta.contextLimit ?? 'undefined'} compactCount=${meta.compactCount ?? 'undefined'} cacheRead=${meta.cacheReadTokens ?? 'undefined'} cacheCreate=${meta.cacheCreationTokens ?? 'undefined'}`;
+    }
+}
+//# sourceMappingURL=run-usage.js.map

package/dist/bridge/session-writeback.d.ts

@@ -0,0 +1,18 @@
+import type { AgentKind, TurnStartedEvent } from '../runner/index.js';
+import type { SessionStore } from '../session/index.js';
+interface InitEvent {
+    session_id: string;
+    cwd?: string;
+}
+interface WritebackContext {
+    sessionStore: SessionStore;
+    userId: string;
+    agentKind: AgentKind;
+    cwd: string;
+    sessionEpochAtStart: number;
+    runId: string;
+}
+export declare function writeBackInitSession(ctx: WritebackContext, event: InitEvent): void;
+export declare function writeBackTurnStarted(ctx: WritebackContext, event: TurnStartedEvent): boolean;
+export declare function writeBackResultSession(ctx: WritebackContext, sessionId: string | undefined): void;
+export {};

package/dist/bridge/session-writeback.js

@@ -0,0 +1,36 @@
+import { getLogger } from '../logger/index.js';
+function pointerMoved(ctx) {
+    return ctx.sessionStore.getSessionEpoch(ctx.userId, ctx.agentKind) !== ctx.sessionEpochAtStart;
+}
+export function writeBackInitSession(ctx, event) {
+    if (pointerMoved(ctx)) {
+        getLogger().info(`[lark-remote] system.init write-back skipped: session pointer moved since run start runId=${ctx.runId} sessionId=${event.session_id}`);
+        return;
+    }
+    const eventCwd = typeof event.cwd === 'string' ? event.cwd : '';
+    const hasCwd = !!ctx.sessionStore.getCwd(ctx.userId);
+    const realCwd = eventCwd.length > 0 ? eventCwd : ctx.cwd;
+    if (hasCwd && eventCwd && eventCwd !== ctx.cwd) {
+        getLogger().info(`[lark-remote] system.init: cwd=${ctx.cwd}, session cwd=${eventCwd}`);
+        ctx.sessionStore.setSessionIdAndSessionCwd(ctx.userId, ctx.agentKind, event.session_id, realCwd);
+        return;
+    }
+    const bootstrapSessionCwd = !hasCwd && eventCwd.length > 0 ? eventCwd : undefined;
+    ctx.sessionStore.setSessionIdAndCwd(ctx.userId, ctx.agentKind, event.session_id, realCwd, bootstrapSessionCwd);
+}
+export function writeBackTurnStarted(ctx, event) {
+    if (pointerMoved(ctx)) {
+        getLogger().info(`[lark-remote] turn_started write-back skipped: session pointer moved since run start runId=${ctx.runId} sessionId=${event.threadId}`);
+        return false;
+    }
+    ctx.sessionStore.setSessionIdAndCwd(ctx.userId, ctx.agentKind, event.threadId, ctx.cwd);
+    getLogger().info(`[lark-remote] turn_started session write-back runId=${ctx.runId} sessionId=${event.threadId}`);
+    return true;
+}
+export function writeBackResultSession(ctx, sessionId) {
+    if (!sessionId || pointerMoved(ctx))
+        return;
+    ctx.sessionStore.setSessionIdAndCwd(ctx.userId, ctx.agentKind, sessionId, ctx.cwd);
+    getLogger().info(`[lark-remote] result session write-back runId=${ctx.runId} sessionId=${sessionId}`);
+}
+//# sourceMappingURL=session-writeback.js.map

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