lark-remote 0.1.6 → 0.1.7

package/dist/card/run-renderer.js

@@ -1,11 +1,10 @@
 import { terminalToColor, terminalToLabel, newSessionButton, stopButton, compactButton, agentDisplayName, } from './card-shared.js';
 import { collapsibleMarkdownPanel, markdownDiv } from './collapsible.js';
 import { toolBodyMd, toolHeaderText } from './tool-render.js';
-import { truncateUtf8, truncateMarkdownTables } from './text-truncate.js';
+import { truncateUtf8, truncateMarkdownTables, CARD_BUDGET_BYTES } from './text-truncate.js';
 import { formatTimestamp } from './time.js';
-import { formatUsageStats } from '../router/index.js';
+import { formatUsageStats } from '../router/utils.js';
 import { renderApprovalArea } from './approval-render.js';
-const CARD_BUDGET_BYTES = 28_000;
 const REASONING_BYTES = 4_500;
 const TEXT_BYTES = 10_000;
 const DEGRADED_THINKING_KEEP = 2;
@@ -189,83 +188,20 @@ function toolTitle(tool) {
     const title = toolHeaderText(tool);
     return ts ? `${title} (${ts})` : title;
 }
-/**
- * Build degraded elements when full card exceeds 28KB budget.
- * Strategy: text fully preserved, thinking keeps last 2, tools keep last N (compressed).
- *
- * 性能优化：单遍遍历 state.blocks 按 kind 分桶（thinking/tool/other），替代原先
- * 多次 state.blocks.filter() 扫描。分桶时保持原相对顺序，后续用 groupBlocks
- * 渲染时序不变。
- */
-function buildDegradedElements(state, options) {
-    const elements = [];
-    elements.push(statusRow(state));
-    // 单遍分桶：thinking / tool / other（保持原相对顺序）
-    const { thinking: allThinkingBlocks, tool: allToolBlocks } = bucketThinkingAndTool(state.blocks);
-    if (allThinkingBlocks.length > DEGRADED_THINKING_KEEP) {
-        const omitted = allThinkingBlocks.length - DEGRADED_THINKING_KEEP;
-        elements.push(markdownDiv(`_💡 ${omitted} 个早期思考已省略_`));
-    }
-    // Keep only the last N thinking blocks for display
-    const thinkingBlocksToShow = allThinkingBlocks.slice(-DEGRADED_THINKING_KEEP);
-    const toolsToShow = allToolBlocks.slice(-DEGRADED_TOOL_KEEP);
-    const toolsOmitted = allToolBlocks.length - DEGRADED_TOOL_KEEP;
-    // Add omit hint for tools if any were omitted
-    if (toolsOmitted > 0) {
-        elements.push(markdownDiv(`_💡 另外 ${toolsOmitted} 个工具调用已省略_`));
-    }
-    // Build a filtered blocks list that only includes the thinking blocks we want to show
-    // and the tool blocks we want to show.
-    // P2-6: use object references (like the extreme path) instead of timestamps.
-    // RunBlock.timestamp has millisecond precision; ≥2 thinking blocks sharing a
-    // timestamp collapse to one Set entry, so `has(block.timestamp)` lets ALL
-    // same-timestamp blocks (including ones meant to be omitted) pass through —
-    // inflating the degraded card past 28KB and contradicting the "N omitted"
-    // hint. `thinkingBlocksToShow` is a slice of `allThinkingBlocks`, so the
-    // blocks retain stable references and the Set membership check is exact.
-    const thinkingSetToShow = new Set(thinkingBlocksToShow);
-    const toolIdsToShow = new Set(toolsToShow.map((b) => b.tool.id));
-    const filteredBlocks = state.blocks.filter((block) => {
-        if (block.kind === 'thinking') {
-            return thinkingSetToShow.has(block);
-        }
-        if (block.kind === 'tool') {
-            return toolIdsToShow.has(block.tool.id);
-        }
-        return true; // keep all non-thinking, non-tool blocks
-    });
-    // Render thinking/text/tool in chronological order using groupBlocks
-    for (const group of groupBlocks(filteredBlocks)) {
-        if (group.kind === 'thinking') {
-            if (options.showThinking === false)
-                continue;
-            const ts = formatTimestamp(group.timestamp);
-            const title = '💭 **思考完成**';
-            const content = truncateUtf8(group.content, REASONING_BYTES);
-            const header = ts ? `${title} (${ts})` : title;
-            elements.push(collapsibleMarkdownPanel({
-                title: header,
-                expanded: false,
-                border: 'grey',
-                content,
-                textSize: 'notation',
-            }));
-        }
-        else if (group.kind === 'text') {
-            const content = truncateUtf8(group.content, TEXT_BYTES, true, '…（已截断）\n');
-            const ts = formatTimestamp(group.timestamp);
-            const els = renderTextBlock(content, ts, true);
-            elements.push(...els);
-        }
-        else if (group.kind === 'tool') {
-            // Degraded: show tool individually (each tool is independent now)
-            if (options.showToolUse === false)
-                continue;
-            elements.push(renderTool(group.tool, true, options.showToolResult !== false)); // finalized=true
-        }
-    }
-    elements.push(...buildSummaryContent(state));
-    // Bottom action row: stop (if running) + compact (if applicable) + new session (always)
+const DEGRADED_TIER = {
+    thinkingKeep: DEGRADED_THINKING_KEEP,
+    thinkingBytes: REASONING_BYTES,
+    toolKeep: DEGRADED_TOOL_KEEP,
+    textBytes: TEXT_BYTES,
+};
+const EXTREME_TIER = {
+    thinkingKeep: 1,
+    thinkingBytes: DEGRADED_THINKING_BYTES,
+    toolKeep: EXTREME_TOOL_KEEP,
+    textBytes: DEGRADED_TEXT_BYTES,
+};
+/** Bottom action row: stop (if running) + compact (if applicable) + new session (always). */
+function actionRow(state) {
     const actionButtons = [];
     // finalizing 也显示停止按钮（进程未退出，用户可 /stop）
     const showStop = state.terminal === 'running' || state.terminal === 'finalizing';
@@ -277,8 +213,10 @@ function buildDegradedElements(state, options) {
         actionButtons.push(compactButton(state.runId));
     }
     actionButtons.push(newSessionButton());
-    if (actionButtons.length > 0) {
-        elements.push({ tag: 'div', text: { content: '‎', tag: 'lark_md' } }, // spacer
+    if (actionButtons.length === 0)
+        return [];
+    return [
+        { tag: 'div', text: { content: '‎', tag: 'lark_md' } }, // spacer
         {
             tag: 'column_set',
             columns: actionButtons.map((btn) => ({
@@ -286,10 +224,12 @@ function buildDegradedElements(state, options) {
                 width: 'auto',
                 elements: [btn],
             })),
-        });
-    }
-    // 审批区位于 body 最底部（底部操作行之后）：待审批时决策按钮不遮挡内容流。
-    // 多槽渲染（review P2-3）：并发审批全部展示，互不顶掉。
+        },
+    ];
+}
+/** 审批区位于 body 最底部（底部操作行之后）：待审批时决策按钮不遮挡内容流。 */
+function approvalArea(state) {
+    const elements = [];
     for (const slot of state.approvals ?? []) {
         elements.push(...renderApprovalArea(slot.view, {
             expired: slot.expired,
@@ -299,49 +239,65 @@ function buildDegradedElements(state, options) {
     }
     return elements;
 }
+/** Assemble the card shell (schema/config/header) around body elements. */
+function assembleRunCard(state, options, elements) {
+    return {
+        schema: '2.0',
+        config: { wide_screen_mode: true, update_multi: true },
+        header: {
+            template: headerTemplate2(state),
+            title: { content: headerTitle2(state, options), tag: 'plain_text' },
+        },
+        body: { elements },
+    };
+}
 /**
- * Extreme fallback when even degraded card exceeds 28KB.
- * Strategy: text truncated to 5KB tail, thinking only last 1 truncated to 1KB,
- * tools keep last N (more aggressive than degraded).
- *
- * 性能优化：单遍分桶替代多次 state.blocks.filter()。
+ * Build a budget-fallback tier (degraded or extreme): keep the last N thinking
+ * blocks and last N tools, truncate text/thinking per tier, then render in
+ * chronological order. Shared by buildDegradedElements / buildExtremeFallback.
  */
-function buildExtremeFallbackElements(state, options) {
+function buildFallbackElements(state, options, tier) {
     const elements = [];
     elements.push(statusRow(state));
-    // 单遍分桶：thinking / tool
+    // 单遍分桶：thinking / tool（保持原相对顺序）
     const { thinking: allThinkingBlocks, tool: allToolBlocks } = bucketThinkingAndTool(state.blocks);
-    // Thinking: only keep last 1 for extreme fallback
-    if (allThinkingBlocks.length > 1) {
-        const omitted = allThinkingBlocks.length - 1;
+    if (allThinkingBlocks.length > tier.thinkingKeep) {
+        const omitted = allThinkingBlocks.length - tier.thinkingKeep;
         elements.push(markdownDiv(`_💡 ${omitted} 个早期思考已省略_`));
     }
-    const thinkingBlockToShow = allThinkingBlocks.length > 0 ? allThinkingBlocks[allThinkingBlocks.length - 1] : null;
-    const toolsToShow = allToolBlocks.slice(-EXTREME_TOOL_KEEP);
-    const toolsOmitted = allToolBlocks.length - EXTREME_TOOL_KEEP;
+    const thinkingBlocksToShow = allThinkingBlocks.slice(-tier.thinkingKeep);
+    const toolsToShow = allToolBlocks.slice(-tier.toolKeep);
+    const toolsOmitted = allToolBlocks.length - tier.toolKeep;
     // Add omit hint for tools if any were omitted
     if (toolsOmitted > 0) {
         elements.push(markdownDiv(`_💡 另外 ${toolsOmitted} 个工具调用已省略_`));
     }
-    // Build filtered blocks: only last thinking, last N tools, all text
+    // P2-6: use object references (like the extreme path) instead of timestamps.
+    // RunBlock.timestamp has millisecond precision; ≥2 thinking blocks sharing a
+    // timestamp collapse to one Set entry, so `has(block.timestamp)` lets ALL
+    // same-timestamp blocks (including ones meant to be omitted) pass through —
+    // inflating the card past 28KB and contradicting the "N omitted" hint.
+    // `thinkingBlocksToShow` is a slice of `allThinkingBlocks`, so the blocks
+    // retain stable references and the Set membership check is exact.
+    const thinkingSetToShow = new Set(thinkingBlocksToShow);
     const toolIdsToShow = new Set(toolsToShow.map((b) => b.tool.id));
     const filteredBlocks = state.blocks.filter((block) => {
         if (block.kind === 'thinking') {
-            return block === thinkingBlockToShow;
+            return thinkingSetToShow.has(block);
         }
         if (block.kind === 'tool') {
             return toolIdsToShow.has(block.tool.id);
         }
-        return true; // keep all text and other blocks
+        return true; // keep all non-thinking, non-tool blocks
     });
-    // Render in chronological order
+    // Render thinking/text/tool in chronological order using groupBlocks
     for (const group of groupBlocks(filteredBlocks)) {
         if (group.kind === 'thinking') {
             if (options.showThinking === false)
                 continue;
             const ts = formatTimestamp(group.timestamp);
             const title = '💭 **思考完成**';
-            const content = truncateUtf8(group.content, DEGRADED_THINKING_BYTES);
+            const content = truncateUtf8(group.content, tier.thinkingBytes);
             const header = ts ? `${title} (${ts})` : title;
             elements.push(collapsibleMarkdownPanel({
                 title: header,
@@ -352,56 +308,40 @@ function buildExtremeFallbackElements(state, options) {
             }));
         }
         else if (group.kind === 'text') {
-            const content = truncateUtf8(group.content, DEGRADED_TEXT_BYTES, true, '…（已截断）\n');
+            const content = truncateUtf8(group.content, tier.textBytes, true, '…（已截断）\n');
             const ts = formatTimestamp(group.timestamp);
-            const els = renderTextBlock(content, ts, true);
-            elements.push(...els);
+            elements.push(...renderTextBlock(content, ts, true));
         }
         else if (group.kind === 'tool') {
-            // Extreme fallback: show tool individually
+            // Show tool individually (each tool is independent now)
             if (options.showToolUse === false)
                 continue;
-            elements.push(renderTool(group.tool, true, options.showToolResult !== false));
+            elements.push(renderTool(group.tool, true, options.showToolResult !== false)); // finalized=true
         }
     }
-    if (elements.length === 0) {
+    if (elements.length === 0 && tier === EXTREME_TIER) {
         elements.push(markdownDiv('_暂无输出_'));
     }
     elements.push(...buildSummaryContent(state));
-    // Bottom action row: stop (if running) + compact (if applicable) + new session (always)
-    const actionButtons = [];
-    // finalizing 也显示停止按钮（进程未退出，用户可 /stop）
-    const showStop = state.terminal === 'running' || state.terminal === 'finalizing';
-    if (showStop) {
-        actionButtons.push(stopButton(state.runId));
-    }
-    // Compact 按钮：普通 turn 到达任意终态即可压缩（含异常退出），compaction 卡除外
-    if (shouldShowCompactButton(state)) {
-        actionButtons.push(compactButton(state.runId));
-    }
-    actionButtons.push(newSessionButton());
-    if (actionButtons.length > 0) {
-        elements.push({ tag: 'div', text: { content: '‎', tag: 'lark_md' } }, // spacer
-        {
-            tag: 'column_set',
-            columns: actionButtons.map((btn) => ({
-                tag: 'column',
-                width: 'auto',
-                elements: [btn],
-            })),
-        });
-    }
-    // 审批区位于 body 最底部（底部操作行之后）：待审批时决策按钮不遮挡内容流。
-    // 多槽渲染（review P2-3）：并发审批全部展示，互不顶掉。
-    for (const slot of state.approvals ?? []) {
-        elements.push(...renderApprovalArea(slot.view, {
-            expired: slot.expired,
-            runId: state.runId,
-            terminal: state.terminal,
-        }));
-    }
+    elements.push(...actionRow(state));
+    elements.push(...approvalArea(state));
     return elements;
 }
+/**
+ * Build degraded elements when full card exceeds 28KB budget.
+ * Strategy: text fully preserved, thinking keeps last 2, tools keep last N (compressed).
+ */
+function buildDegradedElements(state, options) {
+    return buildFallbackElements(state, options, DEGRADED_TIER);
+}
+/**
+ * Extreme fallback when even degraded card exceeds 28KB.
+ * Strategy: text truncated to 5KB tail, thinking only last 1 truncated to 1KB,
+ * tools keep last N (more aggressive than degraded).
+ */
+function buildExtremeFallbackElements(state, options) {
+    return buildFallbackElements(state, options, EXTREME_TIER);
+}
 /** Build the status row element (shared across full/degraded/extreme). */
 function statusRow(state) {
     const statusLabel = statusTagLabel(state.terminal);
@@ -442,24 +382,7 @@ function buildSkeletonElements(state) {
     elements.push(...buildSummaryContent(state));
     // Bottom action row: stop (if running/finalizing) + compact (if applicable) + new session (always).
     // Degraded paths must keep the action buttons reachable (design constraint).
-    const actionButtons = [];
-    const showStop = state.terminal === 'running' || state.terminal === 'finalizing';
-    if (showStop) {
-        actionButtons.push(stopButton(state.runId));
-    }
-    if (shouldShowCompactButton(state)) {
-        actionButtons.push(compactButton(state.runId));
-    }
-    actionButtons.push(newSessionButton());
-    elements.push({ tag: 'div', text: { content: '‎', tag: 'lark_md' } }, // spacer
-    {
-        tag: 'column_set',
-        columns: actionButtons.map((btn) => ({
-            tag: 'column',
-            width: 'auto',
-            elements: [btn],
-        })),
-    });
+    elements.push(...actionRow(state));
     return elements;
 }
 /**
@@ -616,105 +539,41 @@ function measurePanelBytes(title, expanded, border, content) {
  * CardKit 2.0 renderer - simplified for streaming (no tabs)
  */
 export function renderRunCard(state, options = {}) {
-    const { terminal, runId } = state;
     // 先估后建：用廉价估算预测是否超 28KB 预算，明显超预算直接跳过完整卡构建走
     // degraded。P1-2：groups/prepared 只算一次，测量与正式渲染共用同一份截断结果，
     // 避免影子测量 + 正式渲染对每个超限块双倍截断。
     const groups = groupBlocks(state.blocks);
     const prepared = prepareGroupContent(groups);
     const estimate = estimateCardBytes(state, options, { groups, prepared });
-    // Stop button: show when running or finalizing (process not yet exited)
-    const showStop = terminal === 'running' || terminal === 'finalizing';
     // 构建完整卡（仅在估算低于阈值时，避免大 state 浪费 render + stringify）
     if (estimate < DEGRADED_THRESHOLD) {
         const elements = [
             statusRow(state),
             ...buildChronologicalContent(state, options, prepared, groups),
             ...buildSummaryContent(state),
+            ...actionRow(state),
+            ...approvalArea(state),
         ];
-        // Bottom action row: stop (if running) + compact (if applicable) + new session (always)
-        const actionButtons = [];
-        if (showStop) {
-            actionButtons.push(stopButton(runId));
-        }
-        if (shouldShowCompactButton(state)) {
-            actionButtons.push(compactButton(runId));
-        }
-        actionButtons.push(newSessionButton());
-        if (actionButtons.length > 0) {
-            elements.push({ tag: 'div', text: { content: '‎', tag: 'lark_md' } }, // spacer
-            {
-                tag: 'column_set',
-                columns: actionButtons.map((btn) => ({
-                    tag: 'column',
-                    width: 'auto',
-                    elements: [btn],
-                })),
-            });
-        }
-        // 审批区位于 body 最底部（底部操作行之后）：待审批时决策按钮不遮挡内容流。
-        // 多槽渲染（review P2-3）：并发审批全部展示，互不顶掉。
-        for (const slot of state.approvals ?? []) {
-            elements.push(...renderApprovalArea(slot.view, {
-                expired: slot.expired,
-                runId: state.runId,
-                terminal: state.terminal,
-            }));
-        }
-        const card = {
-            schema: '2.0',
-            config: { wide_screen_mode: true, update_multi: true },
-            header: {
-                template: headerTemplate2(state),
-                title: { content: headerTitle2(state, options), tag: 'plain_text' },
-            },
-            body: { elements },
-        };
+        const card = assembleRunCard(state, options, elements);
         // Check budget — stringify 兜底（估算可能低估，仍保留安全网）
         if (Buffer.byteLength(JSON.stringify(card), 'utf8') <= CARD_BUDGET_BYTES)
             return card;
         // 超预算 → 继续走 degraded（不 return，fallthrough）
     }
     // 估算 ≥ 阈值 或 完整卡 stringify 超预算 — 走 degraded 渲染
-    const degradedElements = buildDegradedElements(state, options);
-    const degradedCard = {
-        schema: '2.0',
-        config: { wide_screen_mode: true, update_multi: true },
-        header: {
-            template: headerTemplate2(state),
-            title: { content: headerTitle2(state, options), tag: 'plain_text' },
-        },
-        body: { elements: degradedElements },
-    };
+    const degradedCard = assembleRunCard(state, options, buildDegradedElements(state, options));
     if (Buffer.byteLength(JSON.stringify(degradedCard), 'utf8') <= CARD_BUDGET_BYTES) {
         return degradedCard;
     }
     // Extreme fallback: even degraded exceeds budget
-    const extremeElements = buildExtremeFallbackElements(state, options);
-    const extremeCard = {
-        schema: '2.0',
-        config: { wide_screen_mode: true, update_multi: true },
-        header: {
-            template: headerTemplate2(state),
-            title: { content: headerTitle2(state, options), tag: 'plain_text' },
-        },
-        body: { elements: extremeElements },
-    };
+    const extremeCard = assembleRunCard(state, options, buildExtremeFallbackElements(state, options));
     // Final safety net: extreme fallback 是最后一层，但高转义内容（反斜杠 4× 膨胀）
     // 可能让 extreme 产物本身 >28KB。补上 stringify 兜底（与 normal/degraded 对称）：
     // 超预算则降级到结构性保证 ≤28KB 的 skeleton 卡，避免飞书 11310 整卡不可用。
     if (Buffer.byteLength(JSON.stringify(extremeCard), 'utf8') <= CARD_BUDGET_BYTES) {
         return extremeCard;
     }
-    const skeletonCard = {
-        schema: '2.0',
-        config: { wide_screen_mode: true, update_multi: true },
-        header: {
-            template: headerTemplate2(state),
-            title: { content: headerTitle2(state, options), tag: 'plain_text' },
-        },
-        body: { elements: buildSkeletonElements(state) },
-    };
+    const skeletonCard = assembleRunCard(state, options, buildSkeletonElements(state));
     // skeleton 卡是静态结构，理论上必 ≤28KB；保留兜底断言以防未来结构膨胀
     if (Buffer.byteLength(JSON.stringify(skeletonCard), 'utf8') <= CARD_BUDGET_BYTES) {
         return skeletonCard;
@@ -823,8 +682,16 @@ function buildSummaryContent(state) {
     else if (state.terminal === 'interrupted') {
         // 审批超时（approval_expired 已标记）是「无人响应被自动取消」，不是用户
         // 主动终止；如实展示原因，避免用户误判为 Agent 出错或自己操作过。
-        const expiredApproval = (state.approvals ?? []).some((a) => a.expired);
-        elements.push(markdownDiv(expiredApproval ? '⏰ **审批超时未响应，已自动取消**' : '⏹ **已被用户终止**'));
+        // 顶层 approvalExpired 优先：approval_resolved 会移除审批条目，但标记
+        // 必须活到终态渲染（2026-08-15 事故回归）。
+        const expiredApproval = state.interruptedReason === 'approval_timeout' ||
+            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} 分钟无响应，已自动终止`));

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

@@ -1,6 +1,8 @@
 import type { AgentEvent, ApprovalView } from '../runner/index.js';
 export type RunTerminal = 'running' | 'finalizing' | 'done' | 'error' | 'interrupted' | 'idle_timeout';
 export type RunFooter = 'thinking' | 'tool_running' | 'streaming' | null;
+/** 中断来源（interrupted 终态的原因），供卡片如实归因。 */
+export type InterruptedReason = 'approval_timeout' | 'user_stop' | 'approval_cancelled';
 type ToolStatus = 'running' | 'ok' | 'error';
 export interface ToolEntry {
     id: string;
@@ -61,6 +63,8 @@ export interface RunState {
     blocks: RunBlock[];
     sessionId?: string;
     resultSubtype?: 'success' | 'error' | 'interrupted';
+    /** interrupted 终态的中断来源；undefined = 未归类（渲染默认文案）。 */
+    interruptedReason?: InterruptedReason;
     contextLength?: number;
     /** 当前模型 context window 上限（codex jsonl 提供）；卡片据此渲染百分比。 */
     contextLimit?: number;
@@ -98,9 +102,18 @@ export interface RunState {
         view: ApprovalView;
         expired?: boolean;
     }>;
+    /**
+     * 审批是否曾过期（桥侧 timer 触发，approval_expired 事件置位）。
+     * 独立于 approvals 数组持久保存：cancel 送达后 server 会回
+     * approval_resolved，把对应审批条目从数组移除，但过期原因必须活到
+     * 终态渲染（2026-08-15 事故：标记被消费后卡片误报「已被用户终止」）。
+     */
+    approvalExpired?: boolean;
 }
 export interface FinishMeta {
     resultSubtype?: 'success' | 'error' | 'interrupted';
+    /** 中断来源：由桥侧在 finish 时显式传入（/stop → user_stop、审批卡取消 → approval_cancelled）。 */
+    interruptedReason?: InterruptedReason;
     contextLength?: number;
     /** 当前模型 context window 上限；透传到 RunState 供 done 卡片显示百分比。 */
     contextLimit?: number;

package/dist/card/run-state.js

@@ -1,3 +1,4 @@
+import { keepTail } from '../common/truncate.js';
 const MAX_REASONING_CHARS = 4_000;
 const MAX_TEXT_CHARS = 12_000;
 const MAX_TOOL_DETAIL_CHARS = 3_000;
@@ -64,6 +65,7 @@ export function reduceRunState(state, event) {
     if (event.type === 'approval_expired') {
         return {
             ...state,
+            approvalExpired: true,
             approvals: (state.approvals ?? []).map((a) => a.view.requestId === event.requestId ? { ...a, expired: true } : a),
         };
     }
@@ -100,14 +102,14 @@ function reduceTurnDiffEvent(state, event) {
             blocks: keepLatestBlocks(upsertSnapshotBlock(blocks, (b) => b.kind === 'text' && b.itemId === event.itemId, () => ({
                 kind: 'text',
                 itemId: event.itemId,
-                content: keepLatest(event.text, MAX_TEXT_CHARS),
+                content: keepTail(event.text, MAX_TEXT_CHARS),
                 timestamp: ts,
                 ...(complete ? { completedAt: ts } : {}),
             }), (existing) => {
                 const textBlock = existing;
                 return {
                     ...textBlock,
-                    content: keepLatest(event.text, MAX_TEXT_CHARS),
+                    content: keepTail(event.text, MAX_TEXT_CHARS),
                     ...(complete ? { completedAt: ts } : {}),
                 };
             }, !complete)),
@@ -120,7 +122,7 @@ function reduceTurnDiffEvent(state, event) {
             blocks: keepLatestBlocks(upsertSnapshotBlock(next.blocks, (b) => b.kind === 'thinking' && b.itemId === event.itemId, () => ({
                 kind: 'thinking',
                 itemId: event.itemId,
-                content: keepLatest(event.reasoning, MAX_REASONING_CHARS),
+                content: keepTail(event.reasoning, MAX_REASONING_CHARS),
                 active: !complete,
                 timestamp: ts,
                 ...(complete ? { completedAt: ts } : {}),
@@ -128,7 +130,7 @@ function reduceTurnDiffEvent(state, event) {
                 const thinkingBlock = existing;
                 return {
                     ...thinkingBlock,
-                    content: keepLatest(event.reasoning, MAX_REASONING_CHARS),
+                    content: keepTail(event.reasoning, MAX_REASONING_CHARS),
                     active: !complete,
                     ...(complete ? { completedAt: ts } : {}),
                 };
@@ -145,7 +147,7 @@ function reduceTurnDiffEvent(state, event) {
                     id: event.itemId,
                     name: 'command',
                     input: '',
-                    output: keepLatest(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
+                    output: keepTail(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
                     status: complete ? (event.toolStatus ?? 'ok') : 'running',
                     startedAt: ts,
                     ...(complete ? { completedAt: ts } : {}),
@@ -154,7 +156,7 @@ function reduceTurnDiffEvent(state, event) {
                 kind: 'tool',
                 tool: {
                     ...existing.tool,
-                    output: keepLatest(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
+                    output: keepTail(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
                     status: complete
                         ? (event.toolStatus ?? 'ok')
                         : existing.tool.status,
@@ -165,7 +167,7 @@ function reduceTurnDiffEvent(state, event) {
         };
     }
     if (event.plan !== undefined) {
-        const newPlan = keepLatest(event.plan, MAX_REASONING_CHARS * 2);
+        const newPlan = keepTail(event.plan, MAX_REASONING_CHARS * 2);
         next = {
             ...next,
             plan: newPlan,
@@ -298,7 +300,7 @@ function reduceAssistantEvent(state, event) {
                     ...next.blocks.slice(0, -1),
                     {
                         kind: 'thinking',
-                        content: keepLatest(last.content + '\n' + content.thinking, MAX_REASONING_CHARS),
+                        content: keepTail(last.content + '\n' + content.thinking, MAX_REASONING_CHARS),
                         active: true,
                         timestamp: last.timestamp ?? event.timestamp,
                     },
@@ -307,7 +309,7 @@ function reduceAssistantEvent(state, event) {
                     ...next.blocks,
                     {
                         kind: 'thinking',
-                        content: keepLatest(content.thinking, MAX_REASONING_CHARS),
+                        content: keepTail(content.thinking, MAX_REASONING_CHARS),
                         active: true,
                         timestamp: event.timestamp,
                     },
@@ -326,7 +328,7 @@ function reduceAssistantEvent(state, event) {
                     ...blocks.slice(0, -1),
                     {
                         kind: 'text',
-                        content: keepLatest(last.content + content.text, MAX_TEXT_CHARS),
+                        content: keepTail(last.content + content.text, MAX_TEXT_CHARS),
                         timestamp: last.timestamp ?? event.timestamp,
                     },
                 ]
@@ -334,7 +336,7 @@ function reduceAssistantEvent(state, event) {
                     ...blocks,
                     {
                         kind: 'text',
-                        content: keepLatest(content.text, MAX_TEXT_CHARS),
+                        content: keepTail(content.text, MAX_TEXT_CHARS),
                         timestamp: event.timestamp,
                     },
                 ];
@@ -412,7 +414,7 @@ function reducePlanEvent(state, event) {
     if (event.type !== 'plan')
         return state;
     const currentPlan = state.plan ?? '';
-    const newPlan = keepLatest(currentPlan + '\n' + event.plan, MAX_REASONING_CHARS * 2);
+    const newPlan = keepTail(currentPlan + '\n' + event.plan, MAX_REASONING_CHARS * 2);
     // Plan is a single evolving document — replace the existing plan block
     // instead of appending a new one (avoids N overlapping blocks after N events).
     const withoutOldPlan = state.blocks.filter((b) => b.kind !== 'plan');
@@ -458,12 +460,18 @@ export function finishRun(state, terminal, meta = {}) {
             return state;
         return { ...state, ...sanitizeMeta(meta) };
     }
+    // interrupted 终态的中断来源：显式传入优先；否则从顶层持久标记推导
+    // （approval_expired 已置位但调用方未传 reason 的路径，如协调器过期自动
+    // cancel。原因必须在终态确定，不依赖调用方记得传参）。
+    const derivedReason = meta.interruptedReason ??
+        (terminal === 'interrupted' && state.approvalExpired === true ? 'approval_timeout' : undefined);
     return {
         ...state,
         terminal,
         footer: null,
         blocks: markThinkingInactive(state.blocks),
         ...sanitizeMeta(meta),
+        ...(derivedReason !== undefined ? { interruptedReason: derivedReason } : {}),
     };
 }
 /** Remove undefined/null meta fields to avoid overwriting existing state with nullish values. */
@@ -483,7 +491,11 @@ function stringifyUnknown(value) {
     if (typeof value === 'string')
         return value;
     try {
-        return JSON.stringify(value);
+        // JSON.stringify(undefined) returns the value undefined, which would
+        // violate this function's string contract and crash callers that take
+        // .length on the result (2026-08-17 kimi ACP tool_call without rawInput
+        // → truncateDetail TypeError). Normalize to ''.
+        return JSON.stringify(value) ?? '';
     }
     catch {
         return String(value);
@@ -507,9 +519,6 @@ function tryParseRecord(input) {
         return null;
     }
 }
-function keepLatest(value, maxChars) {
-    return value.length <= maxChars ? value : value.slice(-maxChars);
-}
 function keepLatestBlocks(blocks) {
     return blocks.length <= MAX_BLOCKS ? blocks : blocks.slice(-MAX_BLOCKS);
 }