lark-remote 0.5.10 → 0.5.13

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/card-session.d.ts

@@ -117,5 +117,7 @@ export declare abstract class CardSession<S, RO = unknown> {
      * connector.updateCard if the controller is unavailable or fails.
      */
     protected updateCard(): Promise<void>;
+    private waitForControllerReady;
+    protected prepareTerminalUpdate(): Promise<void>;
     protected release(): void;
 }

package/dist/card/card-session.js

@@ -138,17 +138,7 @@ export class CardSession {
             // 二次调用也套 timeout 保护：若 controllerReady 永不 settle（首次超时失败），
             // 不能永久挂起。复用同样的 startTimeoutMs 超时。streamOutcome 已存在，
             // 不重复创建 stream。
-            let timer;
-            const timeout = new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`${this.errorPrefix} stream start timeout`)), this.startTimeoutMs);
-            });
-            try {
-                await Promise.race([this.controllerReady, timeout]);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
+            await this.waitForControllerReady();
             return;
         }
         // NOTE: the two renderCard calls below are NOT redundant. The streamCard
@@ -177,17 +167,7 @@ export class CardSession {
                 this.rejectController(error);
             return { ok: false, error };
         });
-        let timer;
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`${this.errorPrefix} stream start timeout`)), this.startTimeoutMs);
-        });
-        try {
-            await Promise.race([this.controllerReady, timeout]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
+        await this.waitForControllerReady();
     }
     async settle() {
         this.release();
@@ -247,6 +227,24 @@ export class CardSession {
             }
         }
     }
+    async waitForControllerReady() {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${this.errorPrefix} stream start timeout`)), this.startTimeoutMs);
+        });
+        try {
+            await Promise.race([this.controllerReady, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async prepareTerminalUpdate() {
+        this.cancelPendingFlush();
+        if (this.flushP)
+            await this.flushP;
+    }
     release() {
         if (this.released)
             return;

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

@@ -1,10 +1,10 @@
-import { type AgentKind } from '../runner/index.js';
+import { type AgentKind } from '../runner/types.js';
 /**
  * Display name for an agent kind in the run card header.
  *
- * Reads from the global `AgentRegistry` (set up in `index.ts` at startup)
- * when available. Falls back to a hardcoded map for callers that don't
- * wire up the registry (notably unit tests of pure render helpers).
+ * Display names are static UI labels, so the constant is the single source.
+ * Keeping a second mutable registry here made render helpers depend on startup
+ * order and forced tests to reset global state.
  */
 export declare function agentDisplayName(kind: string): string;
 export declare function terminalToLabel(terminal: string): string;

package/dist/card/card-shared.js

@@ -1,18 +1,12 @@
-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.
  *
- * Reads from the global `AgentRegistry` (set up in `index.ts` at startup)
- * when available. Falls back to a hardcoded map for callers that don't
- * wire up the registry (notably unit tests of pure render helpers).
+ * Display names are static UI labels, so the constant is the single source.
+ * Keeping a second mutable registry here made render helpers depend on startup
+ * order and forced tests to reset global state.
  */
 export function agentDisplayName(kind) {
-    const globalReg = AgentRegistry.getGlobalInstance();
-    if (globalReg) {
-        return globalReg.getDisplayName(kind);
-    }
-    // Fallback for render helpers that run without the global registry.
     return AGENT_DISPLAY_NAMES[kind] ?? kind;
 }
 const TERMINAL_LABELS = {

package/dist/card/collapsible.js

@@ -76,8 +76,9 @@ export function markdownDiv(content, textSize) {
  * to be interpreted as a literal. Escape it to preserve the raw backslash.
  *
  * Note: Square brackets [] and pipe | are NOT escaped -- they are valid markdown
- * (links, tables) and escaping them breaks link rendering. Verified safe via
- * tests/escape-bracket-experiment.test.ts: unescaped []| does not trigger 11311.
+ * (links, tables) and escaping them breaks link rendering. Verified by the live
+ * regression test tests/feishu-live/escape-bracket-regression.test.ts: unescaped
+ * []| does not trigger 11311.
  */
 function escapeMarkdown(content) {
     if (!content)

package/dist/card/final-answer-overflow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Split an authoritative final answer into plain-text messages without losing
+ * any content. Feishu cards have a hard size budget; a long answer must spill
+ * rather than being silently truncated inside the progress card.
+ */
+export declare const FINAL_ANSWER_CHUNK_BYTES = 20000;
+export declare function splitFinalAnswer(text: string, maxBytes?: number): string[];

package/dist/card/final-answer-overflow.js

@@ -0,0 +1,46 @@
+/**
+ * Split an authoritative final answer into plain-text messages without losing
+ * any content. Feishu cards have a hard size budget; a long answer must spill
+ * rather than being silently truncated inside the progress card.
+ */
+export const FINAL_ANSWER_CHUNK_BYTES = 20_000;
+export function splitFinalAnswer(text, maxBytes = FINAL_ANSWER_CHUNK_BYTES) {
+    if (!text || maxBytes <= 0)
+        return text ? [text] : [];
+    const chunks = [];
+    let rest = text;
+    let remainingBytes = Buffer.byteLength(rest, 'utf8');
+    while (remainingBytes > maxBytes) {
+        let bytes = 0;
+        let end = 0;
+        let lastNewline = 0;
+        for (const char of rest) {
+            const charBytes = Buffer.byteLength(char, 'utf8');
+            if (bytes + charBytes > maxBytes)
+                break;
+            bytes += charBytes;
+            end += char.length;
+            if (char === '\n')
+                lastNewline = end;
+        }
+        if (end === 0) {
+            // A caller can choose a byte limit smaller than one codepoint. Keep one
+            // codepoint per chunk rather than looping forever with a zero-length cut.
+            const first = Array.from(rest)[0];
+            chunks.push(first);
+            rest = rest.slice(first.length);
+            remainingBytes -= Buffer.byteLength(first, 'utf8');
+            continue;
+        }
+        // Prefer a paragraph/line boundary when it does not waste most of a chunk.
+        const cut = lastNewline > 0 && lastNewline >= Math.floor(end * 0.6) ? lastNewline : end;
+        const chunk = rest.slice(0, cut);
+        chunks.push(chunk);
+        rest = rest.slice(cut);
+        remainingBytes -= Buffer.byteLength(chunk, 'utf8');
+    }
+    if (rest)
+        chunks.push(rest);
+    return chunks;
+}
+//# sourceMappingURL=final-answer-overflow.js.map

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

@@ -46,13 +46,8 @@ export class RunCardSession extends CardSession {
     }
     async finish(terminal, meta = {}) {
         // 终态必须即时显示（spec）：取消合批窗口，不等延迟 flush 调度。
-        this.cancelPendingFlush();
-        // 若有 in-flight flush 正在 await updateCard，必须等它完成后再发终态 patch。
-        // 否则两条并发 controller.update 无 FIFO 保证，in-flight 的 pre-terminal
-        // patch 可能在终态 patch 之后 resolve → 用户看到"思考中"终帧。
-        // await 保证顺序：pre-terminal 先落地 → terminal 后落地 → terminal 胜出。
-        if (this.flushP)
-            await this.flushP;
+        // 终态 patch 必须排在已开始的 pre-terminal flush 之后。
+        await this.prepareTerminalUpdate();
         this.state = finishRun(this.state, terminal, meta);
         await this.updateCard();
         this.release();

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

@@ -20,6 +20,12 @@ export interface RunCardRenderOptions {
      */
     sessionFallbackAvailable?: boolean;
 }
+export interface RunCardRenderOutcome {
+    card: object;
+    finalAnswerStatus: 'none' | 'full' | 'overflow';
+    /** Full text to deliver outside the card when finalAnswerStatus is overflow. */
+    finalAnswerText?: string;
+}
 type BlockGroup = {
     kind: 'thinking';
     content: string;
@@ -73,4 +79,12 @@ export declare function estimateCardBytes(state: RunState, options?: RunCardRend
  * CardKit 2.0 renderer - simplified for streaming (no tabs)
  */
 export declare function renderRunCard(state: RunState, options?: RunCardRenderOptions): object;
+/**
+ * Render a run card with metadata the bridge needs to deliver an answer that
+ * cannot fit in one Feishu card. `renderRunCard` remains the card-only API used
+ * by streaming sessions.
+ */
+export declare function renderRunCardDetailed(state: RunState, options?: RunCardRenderOptions): RunCardRenderOutcome;
+/** Exact-match marker used in the card before the answer is sent separately. */
+export declare const FINAL_ANSWER_OVERFLOW_MARKER = "_\u6700\u7EC8\u56DE\u7B54\u8F83\u957F\uFF0C\u5B8C\u6574\u5185\u5BB9\u5DF2\u968F\u540E\u53D1\u9001_";
 export {};

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`;
 }
@@ -848,6 +867,20 @@ function measurePanelBytes(title, expanded, border, content) {
  * CardKit 2.0 renderer - simplified for streaming (no tabs)
  */
 export function renderRunCard(state, options = {}) {
+    return renderRunCardDetailed(state, options).card;
+}
+/**
+ * Render a run card with metadata the bridge needs to deliver an answer that
+ * cannot fit in one Feishu card. `renderRunCard` remains the card-only API used
+ * by streaming sessions.
+ */
+export function renderRunCardDetailed(state, options = {}) {
+    if (state.finalAnswer?.content.trim()) {
+        return buildFinalAnswerPriorityCard(state, options);
+    }
+    return { card: renderLegacyRunCard(state, options), finalAnswerStatus: 'none' };
+}
+function renderLegacyRunCard(state, options) {
     // 先估后建：用廉价估算预测是否超 28KB 预算，明显超预算直接跳过完整卡构建走
     // degraded。groups/prepared 只算一次，测量与正式渲染共用同一份截断结果，
     // 避免影子测量 + 正式渲染对每个超限块双倍截断。
@@ -885,26 +918,133 @@ 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),
             ],
         },
     };
     return truncatedSkeleton;
 }
+/** Exact-match marker used in the card before the answer is sent separately. */
+export const FINAL_ANSWER_OVERFLOW_MARKER = '_最终回答较长，完整内容已随后发送_';
+/**
+ * Build a card around the authoritative final answer.
+ *
+ * The answer is measured first with the fixed controls. Progress groups are
+ * added newest-first only while the whole card still fits. If the answer
+ * cannot fit even without progress/summary, the card carries an explicit
+ * marker and the bridge sends the complete answer separately.
+ */
+function buildFinalAnswerPriorityCard(state, options) {
+    const finalAnswer = state.finalAnswer;
+    const groups = groupBlocks(state.blocks);
+    const prepared = prepareGroupContent(groups);
+    const safeAnswer = truncateMarkdownTables(finalAnswer.content);
+    const requiresOverflow = safeAnswer !== finalAnswer.content;
+    const ts = formatTimestamp(finalAnswer.timestamp);
+    const answerElements = renderTextBlock(safeAnswer, ts, state.terminal !== 'running');
+    const fixedStart = [statusRow(state), ...omittedBlocksHint(state)];
+    const summary = buildSummaryContent(state, { includeNotices: false });
+    const controls = [...actionRow(state, options), ...approvalArea(state)];
+    const buildWithProgress = (start, includeSummary) => {
+        const renderedProgress = buildAnswerProgressContent(state, prepared, groups.slice(start));
+        const progress = start < groups.length
+            ? [markdownDiv(`_💡 已省略 ${start} 个早期步骤_`), ...renderedProgress]
+            : renderedProgress;
+        return assembleRunCard(state, options, [
+            ...fixedStart,
+            ...progress,
+            ...(requiresOverflow ? [markdownDiv(FINAL_ANSWER_OVERFLOW_MARKER)] : []),
+            ...answerElements,
+            ...(includeSummary ? summary : []),
+            ...controls,
+        ]);
+    };
+    let best = buildWithProgress(groups.length, true);
+    if (withinRunCardBudget(best)) {
+        for (let start = groups.length - 1; start >= 0; start--) {
+            const candidate = buildWithProgress(start, true);
+            if (!withinRunCardBudget(candidate))
+                break;
+            best = candidate;
+        }
+        return {
+            card: best,
+            finalAnswerStatus: requiresOverflow ? 'overflow' : 'full',
+            ...(requiresOverflow ? { finalAnswerText: finalAnswer.content } : {}),
+        };
+    }
+    // The answer outranks the usage summary. Keep the answer and controls first,
+    // then retry without the summary before declaring a physical overflow.
+    const withoutSummary = buildWithProgress(groups.length, false);
+    if (withinRunCardBudget(withoutSummary)) {
+        return {
+            card: withoutSummary,
+            finalAnswerStatus: requiresOverflow ? 'overflow' : 'full',
+            ...(requiresOverflow ? { finalAnswerText: finalAnswer.content } : {}),
+        };
+    }
+    const overflowCard = assembleRunCard(state, options, [
+        ...fixedStart,
+        markdownDiv(FINAL_ANSWER_OVERFLOW_MARKER),
+        ...controls,
+    ]);
+    return {
+        card: overflowCard,
+        finalAnswerStatus: 'overflow',
+        finalAnswerText: finalAnswer.content,
+    };
+}
+/** Render a contiguous progress suffix for the answer-priority card. */
+function buildAnswerProgressContent(state, prepared, visible) {
+    const elements = [];
+    const outputMax = toolOutputBudget(state);
+    const contentItems = mergeNoticesIntoContent(visible, state.notices);
+    for (const item of contentItems) {
+        if (item.kind === 'notice') {
+            elements.push(renderNoticeRow(item.notice));
+            continue;
+        }
+        const group = item;
+        if (group.kind === 'tool') {
+            elements.push(renderTool(group.tool, outputMax));
+            continue;
+        }
+        if (group.kind === 'text') {
+            const content = prepared.get(group) ?? '';
+            const ts = formatTimestamp(group.timestamp);
+            elements.push(...renderTextBlock(content, ts, state.terminal !== 'running'));
+            continue;
+        }
+        const spec = describePanelGroup(group, prepared);
+        if (!spec)
+            continue;
+        elements.push(collapsibleMarkdownPanel({
+            title: spec.title,
+            expanded: spec.expanded,
+            border: spec.border,
+            content: spec.content,
+            textSize: 'notation',
+        }));
+    }
+    return elements;
+}
 /**
  * Run 卡片的双预算检查：UTF-8 字节 ≤ 28KB **且** 元素数 ≤ `MAX_CARD_ELEMENTS`。
  *
@@ -1015,7 +1155,7 @@ function buildSummaryContent(state, options = {}) {
     }
     else {
         const result = state.resultSubtype ?? 'success';
-        const hasContent = state.blocks.length > 0;
+        const hasContent = state.blocks.length > 0 || !!state.finalAnswer?.content.trim();
         // 压缩（operationKind='compaction'）不会返回 agent 正文——引擎只压缩上下文
         // 窗口，空内容属正常，不能沿用普通 run 的「（未返回内容）」异常信号
         // （2026-09 用户反馈）。所有会压缩的 agent（codex/claude/kimi/opencode/pi）

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

@@ -13,7 +13,7 @@ export type RunTerminal = 'running' | 'finalizing' | 'done' | 'error' | 'interru
  * 禁止各自再抄一份字面量——三处漂移过一次（goal_continuing 只进白名单不进
  * 按钮判据），新增终态时必漏一处的风险是结构性的。
  */
-export declare const RUN_TERMINAL_STATES: readonly ["done", "error", "interrupted", "idle_timeout", "goal_continuing"];
+declare const RUN_TERMINAL_STATES: readonly ["done", "error", "interrupted", "idle_timeout", "goal_continuing"];
 export type RunFinalTerminal = (typeof RUN_TERMINAL_STATES)[number];
 /** 该状态是否已收尾（非 running/finalizing）。 */
 export declare function isRunTerminal(terminal: RunTerminal): terminal is RunFinalTerminal;
@@ -85,6 +85,12 @@ export interface RunNotice {
     text: string;
     timestamp?: string;
 }
+export interface FinalAnswerState {
+    content: string;
+    timestamp?: string;
+    complete: boolean;
+    source: 'protocol' | 'inferred';
+}
 export interface RunState {
     runId: string;
     terminal: RunTerminal;
@@ -94,6 +100,11 @@ export interface RunState {
     /** 本 run 结束时间（epoch ms）：终态后耗时定格，不再随渲染时刻增长。 */
     finishedAt?: number;
     blocks: RunBlock[];
+    /**
+     * The answer the user is waiting for. Kept outside `blocks` so progress
+     * traffic cannot evict or consume its display budget.
+     */
+    finalAnswer?: FinalAnswerState;
     sessionId?: string;
     resultSubtype?: 'success' | 'error' | 'interrupted';
     /** interrupted 终态的中断来源；undefined = 未归类（渲染默认文案）。 */