lark-remote 0.5.7 → 0.5.8

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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
 
 ### 新增

package/dist/bridge/index.d.ts

@@ -416,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';
@@ -919,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.

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 导入，避免三处各自定义后数值漂移。

package/dist/card/card-budget.js

@@ -1,4 +1,6 @@
-import { truncateUtf8, dropOldestMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, CARD_BUDGET_BYTES, } from './text-truncate.js';
+import { dropOldestMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, CARD_BUDGET_BYTES, } from './text-truncate.js';
+import { truncateUtf8 } from '../common/truncate.js';
+import { cardWithHeader } from './card-shared.js';
 /**
  * 静态卡片体积保护
  *
@@ -257,25 +259,19 @@ function enforceByteBudget(truncated, opts = {}, bytesBefore) {
         return done(true);
     }
     // ========== 阶段5：最终兜底（原 extreme_fallback） ==========
-    const minimalCard = {
-        schema: '2.0',
-        config: { wide_screen_mode: true },
-        header: {
-            template: 'orange',
-            title: { tag: 'plain_text', content: '⚠️ 内容已截断' },
-        },
-        body: {
-            elements: [
-                {
-                    tag: 'div',
-                    text: {
-                        tag: 'lark_md',
-                        content: '会话内容过大，已自动截断。\n\n请使用 `/active` 查看完整列表。',
-                    },
+    const minimalCard = cardWithHeader({
+        template: 'orange',
+        title: '⚠️ 内容已截断',
+        elements: [
+            {
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: '会话内容过大，已自动截断。\n\n请使用 `/active` 查看完整列表。',
                 },
-            ],
-        },
-    };
+            },
+        ],
+    });
     return {
         card: minimalCard,
         wasTruncated: true,

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

@@ -107,19 +107,9 @@ export declare abstract class CardSession<S, RO = unknown> {
     start(): Promise<void>;
     settle(): Promise<StreamSettleResult>;
     /**
-     * Whether renderCard() already enforces a size budget (so updateCard can
-     * skip enforceCardBudget). Subclasses whose renderer has its own
-     * stringify-level budget protection (e.g. RunCardSession via degraded/
-     * extreme fallback) should override this to return true.
-     */
-    protected hasOwnBudgetProtection(): boolean;
-    /**
-     * Render the current card and apply stringify-level budget enforcement unless
-     * the subclass renderer has its own budget protection. Centralizes the budget
-     * decision so start()/updateCard()/settle() stay symmetric — previously only
-     * updateCard() guarded, while start() producer and settle() fallback sent bare
-     * renderCard output (risking >28KB for BashCardSession, which has no own
-     * stringify-level safety net).
+     * 渲染当前卡片。所有生产子类的 renderer 都自带 stringify 级预算保护
+     * （run/bash 的 degraded/extreme 路径）；发送前 Bridge 还会再走一次
+     * enforceCardBudget，因此这里不再重复裁剪。
      */
     protected safeRenderCard(): object;
     /**

package/dist/card/card-session.js

@@ -1,5 +1,4 @@
 import { getLogger } from '../logger/index.js';
-import { enforceCardBudget } from './card-budget.js';
 /**
  * Base class for single-card streaming sessions (RunCardSession, BashCardSession).
  * Provides the shared lifecycle: start → (push/update) → finish → settle.
@@ -216,25 +215,12 @@ export class CardSession {
         }
     }
     /**
-     * Whether renderCard() already enforces a size budget (so updateCard can
-     * skip enforceCardBudget). Subclasses whose renderer has its own
-     * stringify-level budget protection (e.g. RunCardSession via degraded/
-     * extreme fallback) should override this to return true.
-     */
-    hasOwnBudgetProtection() {
-        return false;
-    }
-    /**
-     * Render the current card and apply stringify-level budget enforcement unless
-     * the subclass renderer has its own budget protection. Centralizes the budget
-     * decision so start()/updateCard()/settle() stay symmetric — previously only
-     * updateCard() guarded, while start() producer and settle() fallback sent bare
-     * renderCard output (risking >28KB for BashCardSession, which has no own
-     * stringify-level safety net).
+     * 渲染当前卡片。所有生产子类的 renderer 都自带 stringify 级预算保护
+     * （run/bash 的 degraded/extreme 路径）；发送前 Bridge 还会再走一次
+     * enforceCardBudget，因此这里不再重复裁剪。
      */
     safeRenderCard() {
-        const card = this.renderCard(this.state, this.renderOptions);
-        return this.hasOwnBudgetProtection() ? card : enforceCardBudget(card).card;
+        return this.renderCard(this.state, this.renderOptions);
     }
     /**
      * Push an update to the card. Tries controller.update first, falls back to

package/dist/card/card-shared.d.ts

@@ -9,6 +9,15 @@ import { type AgentKind } from '../runner/index.js';
 export declare function agentDisplayName(kind: string): string;
 export declare function terminalToLabel(terminal: string): string;
 export declare function terminalToColor(terminal: string): string;
+/**
+ * CardKit 2.0 静态卡骨架：schema/config/header + 给定 body elements。
+ * 队列状态卡、预算兜底卡等"只有 header 文案 + 少量 div"的卡共用。
+ */
+export declare function cardWithHeader(opts: {
+    template: string;
+    title: string;
+    elements: object[];
+}): object;
 /**
  * Create a CardKit 2.0 button with a callback behavior. Shared constructor
  * for every callback button in the card module (stop/new-session/compact/
@@ -21,6 +30,8 @@ export declare function cardButton(text: string, value: Record<string, unknown>,
     size?: 'small' | 'medium' | 'large';
     /** Fixed width, e.g. '100px' (keeps option-row buttons left-aligned). */
     width?: string;
+    /** 置灰（当前项 / 不可执行），仍保留回调 payload。 */
+    disabled?: boolean;
 }): object;
 /**
  * Create a CardKit 2.0 stop button with behaviors callback.

package/dist/card/card-shared.js

@@ -1,4 +1,5 @@
 import { AgentRegistry } from '../runner/index.js';
+import { AGENT_DISPLAY_NAMES } from '../runner/types.js';
 /**
  * Display name for an agent kind in the run card header.
  *
@@ -11,19 +12,8 @@ export function agentDisplayName(kind) {
     if (globalReg) {
         return globalReg.getDisplayName(kind);
     }
-    // Fallback: hardcoded default mapping for unit tests that exercise
-    // render helpers without booting the full AgentRegistry.
-    if (kind === 'claude')
-        return 'Claude';
-    if (kind === 'codex')
-        return 'Codex';
-    if (kind === 'opencode')
-        return 'Opencode';
-    if (kind === 'pi')
-        return 'Pi';
-    if (kind === 'kimi')
-        return 'Kimi';
-    return kind;
+    // Fallback for render helpers that run without the global registry.
+    return AGENT_DISPLAY_NAMES[kind] ?? kind;
 }
 const TERMINAL_LABELS = {
     done: '已完成',
@@ -51,6 +41,21 @@ export function terminalToColor(terminal) {
         return 'blue';
     return 'red';
 }
+/**
+ * CardKit 2.0 静态卡骨架：schema/config/header + 给定 body elements。
+ * 队列状态卡、预算兜底卡等"只有 header 文案 + 少量 div"的卡共用。
+ */
+export function cardWithHeader(opts) {
+    return {
+        schema: '2.0',
+        config: { wide_screen_mode: true },
+        header: {
+            template: opts.template,
+            title: { tag: 'plain_text', content: opts.title },
+        },
+        body: { elements: opts.elements },
+    };
+}
 /**
  * Create a CardKit 2.0 button with a callback behavior. Shared constructor
  * for every callback button in the card module (stop/new-session/compact/
@@ -65,6 +70,7 @@ export function cardButton(text, value, opts = {}) {
         ...(opts.type ? { type: opts.type } : {}),
         ...(opts.size ? { size: opts.size } : {}),
         ...(opts.width ? { width: opts.width } : {}),
+        ...(opts.disabled !== undefined ? { disabled: opts.disabled } : {}),
         behaviors: [{ type: 'callback', value }],
     };
 }

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

@@ -18,7 +18,6 @@ export declare class RunCardSession extends CardSession<RunState, RunCardRenderO
     protected get logPrefix(): string;
     protected get errorPrefix(): string;
     protected renderCard(state: RunState, options: RunCardRenderOptions): object;
-    protected hasOwnBudgetProtection(): boolean;
     protected isFlushableState(): boolean;
     push(event: AgentEvent): Promise<void>;
     finish(terminal: Exclude<RunTerminal, 'running' | 'finalizing'>, meta?: FinishMeta): Promise<void>;

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

@@ -22,12 +22,6 @@ export class RunCardSession extends CardSession {
     renderCard(state, options) {
         return renderRunCard(state, options);
     }
-    hasOwnBudgetProtection() {
-        // renderRunCard has 3-tier degraded/extreme fallback budget protection
-        // that guarantees the returned card is <= 28KB, so the base-class
-        // enforceCardBudget stringify pass is redundant for run cards.
-        return true;
-    }
     isFlushableState() {
         // finish() 已转终态（done/error/interrupted/idle_timeout）时不再 patch；
         // 'finalizing' 是非终态，in-flight/延迟 flush 仍可渲染累积事件。

package/dist/card/run-renderer.d.ts

@@ -1,13 +1,4 @@
 import type { RunState, ToolEntry } from './run-state.js';
-/**
- * 带「详情」按钮的工具行数上限（从最新往回数）。
- *
- * 按钮行是节点大户：`column_set` + 2 个 `column` + 标题 div/text + button/text/
- * behaviors/value ≈ 10 个 JSON 节点；纯标题行只有 2 个。24 行全带按钮 ≈ 240 节点，
- * 直接撞飞书的元素总数上限（实测 203 通过 / 204 失败，见 card-budget.ts）。
- * 最近 8 行保留按钮（用户最可能展开的就是刚跑完的），更早的行退化成一行标题。
- */
-export declare const MAX_TOOL_ROWS_WITH_BUTTON = 8;
 export interface RunCardRenderOptions {
     /**
      * Agent kind for the run card header title (e.g. "Claude · 思考中").
@@ -60,6 +51,9 @@ type GroupContentPrepared = Map<BlockGroup, string>;
  * 状态标签（运行中/已完成…）不再重复：header 已经写了（`🔧 dsh · 调用工具`
  * / `✅ dsh · 已完成`），终态 summary 还有一次。
  *
+ * 终态也保留状态行：耗时定格，DSH 的步数/上下文投影展示最后一次快照
+ * （2026-10-21 用户要求）。summary 的最终 usage 与状态行并存。
+ *
  * 导出供窄屏守卫测试断言分段宽度（与 `estimateCardBytes` 同一惯例）。
  */
 export declare function statusLine(state: RunState): string;