lark-remote 0.5.20 → 0.5.21

package/dist/card/approval-render.js

@@ -66,6 +66,13 @@ function pushIf(arr, el) {
     if (el !== null)
         arr.push(el);
 }
+const APPROVAL_AREA_RENDERERS = new Map([
+    ['command', renderCommandApproval],
+    ['tool', renderToolApproval],
+    ['file', renderFileApproval],
+    ['permissions', renderPermissionsApproval],
+    ['question', renderQuestionApproval],
+]);
 /**
  * Render the approval area for a run card.
  * Returns an array of CardKit 2.0 elements to append to the card body.
@@ -83,21 +90,10 @@ export function renderApprovalArea(approval, opts) {
             text: { tag: 'lark_md', content: `ℹ️ ${neutralized}` },
         });
     }
-    if (approval.kind === 'command') {
-        elements.push(...renderCommandApproval(approval, opts?.expired, opts?.runId));
-    }
-    else if (approval.kind === 'tool') {
-        elements.push(...renderToolApproval(approval, opts?.expired, opts?.runId));
-    }
-    else if (approval.kind === 'file') {
-        elements.push(...renderFileApproval(approval, opts?.expired, opts?.runId));
-    }
-    else if (approval.kind === 'permissions') {
-        elements.push(...renderPermissionsApproval(approval, opts?.expired, opts?.runId));
-    }
-    else if (approval.kind === 'question') {
-        elements.push(...renderQuestionApproval(approval, opts?.expired, opts?.runId));
-    }
+    // kind → 渲染器查表（Map 保持插入顺序，未知 kind 与原先无 else 分支一致：不追加）。
+    const render = APPROVAL_AREA_RENDERERS.get(approval.kind);
+    if (render)
+        elements.push(...render(approval, opts?.expired, opts?.runId));
     // 响应发送失败：明确告知原因 + 可重试，而不是静默停在可点状态。
     if (approval.deliveryError) {
         const neutralized = capApprovalText(approval.deliveryError);
@@ -429,9 +425,26 @@ function renderFileDiff(diff) {
 }
 /** Per-diff render cap (chars), see TOTAL_DIFF_CHARS for the approval-area cap. */
 const MAX_DIFF_CHARS = 1200;
-// =============================================================================
-// Permissions Approval
-// =============================================================================
+/** 单个权限条目：label div + toggle 按钮（模块级命名函数，供循环逐个调用）。 */
+function renderPermissionItem(item, requestId, runId) {
+    const icon = item.selected ? '✅' : '⬜';
+    // label 仅展示（payload 用 item.id），可安全截断。
+    const label = capApprovalText(item.label, APPROVAL_LABEL_BYTES);
+    return [
+        {
+            tag: 'div',
+            text: { tag: 'lark_md', content: `${icon} ${label}` },
+        },
+        cardButton(item.selected ? '取消授予' : '授予', {
+            cmd: 'approval.toggle',
+            requestId,
+            permId: item.id,
+            selected: !item.selected,
+            runId,
+            nonce: mkNonce(),
+        }, { type: item.selected ? 'default' : 'primary', size: 'small' }),
+    ];
+}
 function renderPermissionsApproval(approval, expired, runId) {
     const elements = [];
     elements.push({
@@ -445,21 +458,7 @@ function renderPermissionsApproval(approval, expired, runId) {
         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} ${label}` },
-            });
-            elements.push(cardButton(item.selected ? '取消授予' : '授予', {
-                cmd: 'approval.toggle',
-                requestId: approval.requestId,
-                permId: item.id,
-                selected: !item.selected,
-                runId,
-                nonce: mkNonce(),
-            }, { type: item.selected ? 'default' : 'primary', size: 'small' }));
+            elements.push(...renderPermissionItem(item, approval.requestId, runId));
         }
         if (omittedItems > 0) {
             elements.push({

package/dist/card/card-budget.js

@@ -160,125 +160,130 @@ function enforceElementBudget(card, opts = {}, bytesBefore) {
     // 它最终会落到最小卡（节点数固定很小）。
     return enforceByteBudget(card, opts, bytesBefore);
 }
-/**
- * Byte-budget enforcement, extracted so table-limit fix can delegate to it
- * when table truncation alone doesn't bring the card under the byte limit.
- *
- * 裁剪判定是**结构化**的：所有 collapsible_panel 都是待裁剪对象，不看面板
- * 标题文本。历史教训：旧实现用
- * emoji 标题模式（🤖👤💭🔧🟢🔴）识别「会话事件面板」，但真实
- * sessionEventPanel 产出的标题是裸英文 type 名（emoji 在事件正文而非标题），
- * 导致裁剪阶段对真实 resume 卡零命中，任何 >28KB 的卡片无裁剪直通极端降级，
- * 整卡被替换成一句话。
- *
- * 渐进式降级（每级仍超限才进入下一级）：
- *   阶段1 逐面板截断内容（maxPanelContentBytes）
- *   阶段2 限制面板数量（删除最老，maxEventPanels）
- *   阶段3 丢弃全部面板，保留骨架（header/usage/按钮）+ 省略提示
- *   阶段4 截断剩余顶层 div 文本
- *   阶段5 最终兜底 minimal card（骨架本身已超限的病理场景）
- */
-function enforceByteBudget(truncated, opts = {}, bytesBefore) {
+function makeByteBudgetContext(truncated, opts, bytesBefore) {
     const { maxEventPanels = 5, maxPanelContentBytes = 2000, truncationHint = '📜 还有 {count} 个事件未显示', } = opts;
-    const reasons = [];
-    const elements = truncated.body?.elements ?? [];
-    const size = () => Buffer.byteLength(JSON.stringify(truncated), 'utf8');
-    const done = (wasTruncated) => ({
-        card: truncated,
+    return {
+        truncated,
+        elements: truncated.body?.elements ?? [],
+        reasons: [],
+        omitted: 0,
+        modifications: 0,
+        textTruncations: 0,
+        maxEventPanels,
+        maxPanelContentBytes,
+        truncationHint,
+        bytesBefore,
+    };
+}
+/** 原 size 闭包：当前卡片序列化字节数。 */
+function byteBudgetSize(ctx) {
+    return Buffer.byteLength(JSON.stringify(ctx.truncated), 'utf8');
+}
+/** 原 done 闭包：构造结果对象（reason 由各阶段累积）。 */
+function byteBudgetDone(ctx, wasTruncated) {
+    return {
+        card: ctx.truncated,
         wasTruncated,
-        reason: reasons.join('+') || undefined,
-        bytesBefore: bytesBefore ?? size(),
-        bytesAfter: size(),
-    });
-    // ========== 阶段1：裁剪所有面板的内容 ==========
-    let modifications = 0;
-    for (const el of elements) {
+        reason: ctx.reasons.join('+') || undefined,
+        bytesBefore: ctx.bytesBefore ?? byteBudgetSize(ctx),
+        bytesAfter: byteBudgetSize(ctx),
+    };
+}
+/** 原 elementsWithinBudgetWithHint 闭包（含 hint 预留位）。 */
+function byteBudgetElementsWithin(ctx) {
+    return countCardElements(ctx.truncated) + (ctx.omitted > 0 ? 1 : 0) <= MAX_CARD_ELEMENTS;
+}
+/** 原 `size() <= ... && elementsWithinBudgetWithHint()` 达标判定。 */
+function byteBudgetFits(ctx) {
+    return byteBudgetSize(ctx) <= CARD_BUDGET_BYTES && byteBudgetElementsWithin(ctx);
+}
+function comparePanelIndexDesc(a, b) {
+    return b - a;
+}
+/** 原 dropOldestPanels 闭包：按文档顺序删最旧的 count 个面板。 */
+function dropOldestPanels(ctx, count) {
+    const indices = getPanelIndices(ctx.elements).slice(0, count).sort(comparePanelIndexDesc);
+    for (const idx of indices) {
+        ctx.elements.splice(idx, 1);
+        ctx.omitted++;
+    }
+}
+/** 达标则插入 hint 并返回结果；未达标返回 undefined，交给下一阶段继续降级。 */
+function byteBudgetTryFinish(ctx, wasTruncated) {
+    if (!byteBudgetFits(ctx))
+        return undefined;
+    insertOmittedHint(ctx.elements, ctx.omitted, ctx.truncationHint);
+    return byteBudgetDone(ctx, wasTruncated);
+}
+// ========== 阶段1：裁剪所有面板的内容 ==========
+function truncatePanelContents(ctx) {
+    for (const el of ctx.elements) {
         if (el.tag !== 'collapsible_panel')
             continue;
         for (const inner of el.elements ?? []) {
             if (inner.tag === 'div' && inner.text?.content) {
                 const content = inner.text.content;
-                if (Buffer.byteLength(content, 'utf8') > maxPanelContentBytes) {
-                    inner.text.content = truncateUtf8(content, maxPanelContentBytes);
-                    modifications++;
+                if (Buffer.byteLength(content, 'utf8') > ctx.maxPanelContentBytes) {
+                    inner.text.content = truncateUtf8(content, ctx.maxPanelContentBytes);
+                    ctx.modifications++;
                 }
             }
         }
     }
-    if (modifications > 0) {
-        reasons.push('panel_content_truncated');
-    }
-    // ========== 阶段2：限制面板数量（删除最老） ==========
-    let omitted = 0;
-    const dropOldestPanels = (count) => {
-        const indices = getPanelIndices(elements)
-            .slice(0, count)
-            .sort((a, b) => b - a);
-        for (const idx of indices) {
-            elements.splice(idx, 1);
-            omitted++;
-        }
-    };
-    const panelCount = getPanelIndices(elements).length;
-    if (panelCount > maxEventPanels) {
-        dropOldestPanels(panelCount - maxEventPanels);
-        reasons.push('event_count_limited');
-    }
-    // 元素数预算必须与字节预算同查（含 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);
+    if (ctx.modifications > 0) {
+        ctx.reasons.push('panel_content_truncated');
     }
-    // ========== 阶段3：丢弃全部面板，保留卡片骨架 ==========
-    // header（cwd/sessionId/标题）、usage、操作按钮等信息量高、体积小的元素
-    // 必须保留——整卡替换为一句话是信息损失最大的降级方式。
-    dropOldestPanels(getPanelIndices(elements).length);
-    if (omitted > 0) {
-        reasons.push('panels_dropped');
+}
+// ========== 阶段2：限制面板数量（删除最老） ==========
+function limitPanelCount(ctx) {
+    const panelCount = getPanelIndices(ctx.elements).length;
+    if (panelCount > ctx.maxEventPanels) {
+        dropOldestPanels(ctx, panelCount - ctx.maxEventPanels);
+        ctx.reasons.push('event_count_limited');
     }
-    if (size() <= CARD_BUDGET_BYTES && elementsWithinBudgetWithHint()) {
-        insertOmittedHint(elements, omitted, truncationHint);
-        return done(true);
+}
+// ========== 阶段3：丢弃全部面板，保留卡片骨架 ==========
+// header（cwd/sessionId/标题）、usage、操作按钮等信息量高、体积小的元素
+// 必须保留——整卡替换为一句话是信息损失最大的降级方式。
+function dropAllPanels(ctx) {
+    dropOldestPanels(ctx, getPanelIndices(ctx.elements).length);
+    if (ctx.omitted > 0) {
+        ctx.reasons.push('panels_dropped');
     }
-    // ========== 阶段4：截断剩余顶层 div 文本 ==========
-    // 骨架元素（header/usage 等）自身超限的情况（如超大 displayTitle）。
-    let textTruncations = 0;
-    for (const el of elements) {
+}
+// ========== 阶段4：截断剩余顶层 div 文本 ==========
+// 骨架元素（header/usage 等）自身超限的情况（如超大 displayTitle）。
+function truncateTopLevelDivs(ctx) {
+    for (const el of ctx.elements) {
         if (el.tag === 'div' && el.text?.content) {
             const content = el.text.content;
-            if (Buffer.byteLength(content, 'utf8') > maxPanelContentBytes) {
-                el.text.content = truncateUtf8(content, maxPanelContentBytes);
-                textTruncations++;
+            if (Buffer.byteLength(content, 'utf8') > ctx.maxPanelContentBytes) {
+                el.text.content = truncateUtf8(content, ctx.maxPanelContentBytes);
+                ctx.textTruncations++;
             }
         }
     }
-    if (textTruncations > 0) {
-        reasons.push('text_truncated');
+    if (ctx.textTruncations > 0) {
+        ctx.reasons.push('text_truncated');
     }
-    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);
+}
+// ========== 阶段4.5：元素数兜底（无面板可删的元素超限） ==========
+// 阶段1-4 只会裁内容/删面板；元素超限且无面板时在此按序丢弃最旧的顶层
+// 元素直到达标（与 table/panel 的「删最旧、留最新」口径一致，尾部操作
+// 按钮保留）。留 ≥3 个元素兜底，仍不达标则交给阶段5 的最小卡。
+function dropExcessElements(ctx) {
+    if (countCardElements(ctx.truncated) > MAX_CARD_ELEMENTS) {
+        while (countCardElements(ctx.truncated) > MAX_CARD_ELEMENTS && ctx.elements.length > 3) {
+            ctx.elements.shift();
+            ctx.omitted++;
         }
+        ctx.reasons.push('element_budget_elements_dropped');
+        return byteBudgetTryFinish(ctx, true);
     }
-    // ========== 阶段5：最终兜底（原 extreme_fallback） ==========
+    return undefined;
+}
+// ========== 阶段5：最终兜底（原 extreme_fallback） ==========
+function byteBudgetMinimalCard(ctx) {
     const minimalCard = cardWithHeader({
         template: 'orange',
         title: '⚠️ 内容已截断',
@@ -296,10 +301,30 @@ function enforceByteBudget(truncated, opts = {}, bytesBefore) {
         card: minimalCard,
         wasTruncated: true,
         reason: 'extreme_fallback',
-        bytesBefore: bytesBefore ?? size(),
+        bytesBefore: ctx.bytesBefore ?? byteBudgetSize(ctx),
         bytesAfter: Buffer.byteLength(JSON.stringify(minimalCard), 'utf8'),
     };
 }
+function enforceByteBudget(truncated, opts = {}, bytesBefore) {
+    const ctx = makeByteBudgetContext(truncated, opts, bytesBefore);
+    truncatePanelContents(ctx);
+    limitPanelCount(ctx);
+    let result = byteBudgetTryFinish(ctx, ctx.modifications > 0 || ctx.omitted > 0);
+    if (result)
+        return result;
+    dropAllPanels(ctx);
+    result = byteBudgetTryFinish(ctx, true);
+    if (result)
+        return result;
+    truncateTopLevelDivs(ctx);
+    result = byteBudgetTryFinish(ctx, true);
+    if (result)
+        return result;
+    result = dropExcessElements(ctx);
+    if (result)
+        return result;
+    return byteBudgetMinimalCard(ctx);
+}
 /**
  * 在卡片头部插入「N 个事件未显示」提示（仅在有面板被移除时）。
  */

package/dist/card/run-renderer.js

@@ -1048,6 +1048,86 @@ function buildChronologicalContent(state, prepared, groups) {
     }
     return elements;
 }
+/** running 时不显示统计（仍在生成）；原分支直接 return，不追加元素。 */
+function summaryRunning(_state, _elements) { }
+function summaryFinalizing(_state, elements) {
+    elements.push(markdownDiv('⏳ **等待进程退出…**'));
+}
+function summaryError(state, elements) {
+    // 服务方内容审核截断（多为误报）不是「程序出错」：照抄英文内部报文会让
+    // 用户以为代码或配置坏了。文案说清三件事——谁拦的、改动还在、下一步。
+    if (isContentFilterFailure(state.errorMsg)) {
+        elements.push(markdownDiv('⚠️ **服务方内容审核拦截**\n\n' +
+            '模型输出被上游安全策略截断（`content_filter`），多数是误报，不是代码或配置问题。\n' +
+            '本回合已中止；已写入磁盘的改动都还在。重试仍被拦截时，可换模型或稍后再试。'));
+    }
+    else {
+        elements.push(markdownDiv(`⚠️ **运行出错**\n\n${state.errorMsg ?? '未知错误'}`));
+    }
+}
+function summaryInterrupted(state, elements) {
+    // 中断来源三元：审批超时 / 用户取消审批 / 用户主动终止。
+    // 显式原因优先：approvalExpired 是粘性标记（cancel 语义下 agent 可能继续跑），
+    // 用户随后主动 /stop 时若仍按过期渲染，就把「我自己停的」误报成自动取消。
+    const expiredApproval = state.interruptedReason === 'approval_timeout' ||
+        (state.interruptedReason === undefined &&
+            (state.approvalExpired === true || (state.approvals ?? []).some((a) => a.expired)));
+    elements.push(markdownDiv(expiredApproval
+        ? '⏰ **审批超时未响应，已自动取消**'
+        : state.interruptedReason === 'approval_cancelled'
+            ? '⏹ **已取消审批，任务终止**'
+            : '⏹ **已被用户终止**'));
+}
+function summaryIdleTimeout(state, elements) {
+    elements.push(markdownDiv(`⏱ **已超时**\n\n${state.idleTimeoutMinutes ?? 0} 分钟无响应，已自动终止`));
+}
+/** 成功/目标继续/其它终态：usage 统计 + 后台任务（原 else 兜底分支）。 */
+function summaryResult(state, elements) {
+    const result = state.resultSubtype ?? 'success';
+    const hasContent = state.blocks.length > 0 || !!state.finalAnswer?.content.trim();
+    // 压缩（operationKind='compaction'）不会返回 agent 正文——引擎只压缩上下文
+    // 窗口，空内容属正常，不能沿用普通 run 的「（未返回内容）」异常信号。
+    // 所有会压缩的 agent（codex/claude/kimi/opencode/pi）
+    // 都经 streamCompact 走这条共享渲染路径，一处覆盖全部。
+    const empty = hasContent
+        ? ''
+        : state.operationKind === 'compaction'
+            ? '\n\n🗜 Compact 完成'
+            : '\n\n（未返回内容）';
+    // goal 本 run 读不到（known=false）时不能写「已完成」：这是 GoalStateEvent
+    // 契约里明令禁止的推断（读不到 ≠ 没有目标）。run 本身成功，只是目标维度未知。
+    const goalUnknown = state.terminal === 'done' && state.goalKnown === false;
+    // RunState 的用量字段就是 formatUsageStats 的入参形态（同为
+    // `UsageSnapshot`）——原先这里逐字段抄了 17 行，加一个字段要同时改
+    // RunState、FinishMeta 和这张清单（§9.21）。
+    const usageStatsStr = formatUsageStats(state, {
+        showResult: true,
+        result,
+        // 本轮结束但目标继续：不能报"已完成"，也不能说"出错"。
+        ...(state.terminal === 'goal_continuing'
+            ? { completedLabel: '⏳ 本轮结束 · 目标仍在继续' }
+            : goalUnknown
+                ? { completedLabel: '✅ 本轮完成 · 目标状态未确认' }
+                : {}),
+    });
+    elements.push(markdownDiv(usageStatsStr + empty));
+    // 后台任务：跨 turn 生命周期，必须显式告知并可逐个停止。
+    elements.push(...buildBackgroundJobsSection(state));
+}
+/**
+ * terminal → summary handler。用 Map 而非对象字面量（constructor/toString 等
+ * 键会命中 Object.prototype）；未登记的 terminal 走 summaryResult，与原 else
+ * 兜底分支一致。
+ */
+const SUMMARY_HANDLERS = new Map([
+    ['running', summaryRunning],
+    ['finalizing', summaryFinalizing],
+    ['error', summaryError],
+    ['interrupted', summaryInterrupted],
+    ['idle_timeout', summaryIdleTimeout],
+    ['done', summaryResult],
+    ['goal_continuing', summaryResult],
+]);
 /** Build summary tab content */
 function buildSummaryContent(state, options = {}) {
     const elements = [];
@@ -1059,74 +1139,8 @@ function buildSummaryContent(state, options = {}) {
             elements.push(renderNoticeRow(notice));
         }
     }
-    // running 时不显示统计（仍在生成）；finalizing 显示等待提示
-    if (state.terminal === 'running') {
-        return elements;
-    }
-    if (state.terminal === 'finalizing') {
-        elements.push(markdownDiv('⏳ **等待进程退出…**'));
-        return elements;
-    }
-    if (state.terminal === 'error') {
-        // 服务方内容审核截断（多为误报）不是「程序出错」：照抄英文内部报文会让
-        // 用户以为代码或配置坏了。文案说清三件事——谁拦的、改动还在、下一步。
-        if (isContentFilterFailure(state.errorMsg)) {
-            elements.push(markdownDiv('⚠️ **服务方内容审核拦截**\n\n' +
-                '模型输出被上游安全策略截断（`content_filter`），多数是误报，不是代码或配置问题。\n' +
-                '本回合已中止；已写入磁盘的改动都还在。重试仍被拦截时，可换模型或稍后再试。'));
-        }
-        else {
-            elements.push(markdownDiv(`⚠️ **运行出错**\n\n${state.errorMsg ?? '未知错误'}`));
-        }
-    }
-    else if (state.terminal === 'interrupted') {
-        // 中断来源三元：审批超时 / 用户取消审批 / 用户主动终止。
-        // 显式原因优先：approvalExpired 是粘性标记（cancel 语义下 agent 可能继续跑），
-        // 用户随后主动 /stop 时若仍按过期渲染，就把「我自己停的」误报成自动取消。
-        const expiredApproval = state.interruptedReason === 'approval_timeout' ||
-            (state.interruptedReason === undefined &&
-                (state.approvalExpired === true || (state.approvals ?? []).some((a) => a.expired)));
-        elements.push(markdownDiv(expiredApproval
-            ? '⏰ **审批超时未响应，已自动取消**'
-            : state.interruptedReason === 'approval_cancelled'
-                ? '⏹ **已取消审批，任务终止**'
-                : '⏹ **已被用户终止**'));
-    }
-    else if (state.terminal === 'idle_timeout') {
-        elements.push(markdownDiv(`⏱ **已超时**\n\n${state.idleTimeoutMinutes ?? 0} 分钟无响应，已自动终止`));
-    }
-    else {
-        const result = state.resultSubtype ?? 'success';
-        const hasContent = state.blocks.length > 0 || !!state.finalAnswer?.content.trim();
-        // 压缩（operationKind='compaction'）不会返回 agent 正文——引擎只压缩上下文
-        // 窗口，空内容属正常，不能沿用普通 run 的「（未返回内容）」异常信号。
-        // 所有会压缩的 agent（codex/claude/kimi/opencode/pi）
-        // 都经 streamCompact 走这条共享渲染路径，一处覆盖全部。
-        const empty = hasContent
-            ? ''
-            : state.operationKind === 'compaction'
-                ? '\n\n🗜 Compact 完成'
-                : '\n\n（未返回内容）';
-        // goal 本 run 读不到（known=false）时不能写「已完成」：这是 GoalStateEvent
-        // 契约里明令禁止的推断（读不到 ≠ 没有目标）。run 本身成功，只是目标维度未知。
-        const goalUnknown = state.terminal === 'done' && state.goalKnown === false;
-        // RunState 的用量字段就是 formatUsageStats 的入参形态（同为
-        // `UsageSnapshot`）——原先这里逐字段抄了 17 行，加一个字段要同时改
-        // RunState、FinishMeta 和这张清单（§9.21）。
-        const usageStatsStr = formatUsageStats(state, {
-            showResult: true,
-            result,
-            // 本轮结束但目标继续：不能报"已完成"，也不能说"出错"。
-            ...(state.terminal === 'goal_continuing'
-                ? { completedLabel: '⏳ 本轮结束 · 目标仍在继续' }
-                : goalUnknown
-                    ? { completedLabel: '✅ 本轮完成 · 目标状态未确认' }
-                    : {}),
-        });
-        elements.push(markdownDiv(usageStatsStr + empty));
-        // 后台任务：跨 turn 生命周期，必须显式告知并可逐个停止。
-        elements.push(...buildBackgroundJobsSection(state));
-    }
+    const handler = SUMMARY_HANDLERS.get(state.terminal) ?? summaryResult;
+    handler(state, elements);
     return elements;
 }
 /** 终态卡最多列几个后台任务（多出来的只报数）。 */

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

@@ -213,20 +213,6 @@ export declare function removeBackgroundJob(state: RunState, jobId: string): Run
  * 按钮，等于逼用户拿「停止」当查询用。
  */
 export declare function isLiveBackgroundJob(job: BackgroundJobRoster): boolean;
-/**
- * 收尾后把宿主推来的整份任务名单同步进终态卡状态。
- *
- * 与 reducer 的分工：reducer 处理的是"收尾那一刻的名单"，只在 run 还在消费
- * 事件时有效；终态之后 `reduceRunState` 直接早退（终态幂等），名单只能由
- * 这里更新。
- *
- * 三条规则：
- * - 名单里消失 = 宿主已结算（`job/list` 是整份替换，摘掉即结束）→ `ended`；
- * - 名单里还在、宿主却给了终态词 → `ended`（有些宿主会把已结束的行留在名单里）；
- * - `ended` 是终态，不回退成 running —— 同一个 job id 不会重新开始跑。
- *
- * 无变化时返回**同一个 state 引用**：bridge 靠它跳过无谓的卡片 patch。
- */
 export declare function syncBackgroundJobs(state: RunState, roster: ReadonlyArray<BackgroundJobRoster>): RunState;
 /**
  * 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」。