lark-remote 0.5.10 → 0.5.13

package/dist/bridge/index.js

@@ -4,18 +4,21 @@ 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';
-import { renderRunCard } from '../card/run-renderer.js';
+import { renderRunCard, renderRunCardDetailed, } from '../card/run-renderer.js';
+import { splitFinalAnswer } from '../card/final-answer-overflow.js';
 import { renderBashCard } from '../card/bash-renderer.js';
 import { BashCardSession, capBashOutput } from '../card/bash-card-session.js';
 import { isRunTerminal } from '../card/run-state.js';
 import { buildSessionHistoryCard } from '../router/card-helpers.js';
 import { agentDisplayName, resumeUseButton } from '../card/card-shared.js';
 import { enforceCardBudget } from '../card/card-budget.js';
-import { normalizeResultUsage } from '../runner/common/result-usage.js';
+import { RunUsageCollector } from './run-usage.js';
 import { BashProcessRunner } from '../runner/index.js';
 import { AGENT_KINDS, supportsCompact } from '../runner/types.js';
 import { QueueManager, } from './queue-manager.js';
-import { ApprovalCoordinator, decisionToApprovalAction } from './approval-coordinator.js';
+import { decisionToApprovalAction } from './approval-coordinator.js';
+import { createRunApprovalCoordinator, remindPendingApproval } from './run-approval.js';
+import { writeBackInitSession, writeBackResultSession, writeBackTurnStarted, } from './session-writeback.js';
 import { InboundMediaHandler } from './inbound-media.js';
 /**
  * Max events to read for the completion notification card (mirror router's
@@ -24,8 +27,6 @@ import { InboundMediaHandler } from './inbound-media.js';
  * budget.
  */
 const COMPLETION_NOTIFICATION_MAX_EVENTS = 5;
-/** Approval request timeout (ms) — pending approval expires after this. */
-const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000;
 /**
  * runner 缓存的工作区数量上限：超过后创建新工作区槽位时
  * 顺带回收「非 active 且进程已停」的死缓存，防止随访问过的工作区数量
@@ -682,8 +683,10 @@ export class Bridge {
         for (const [runId, b] of bashTargets) {
             getLogger().info(`[lark-remote] interrupt hit bash runId=${runId} cwd=${b.cwd} userId=${input.userId}`);
             await b.bashRunner.stop({ immediate: true });
-            // Update card to show interrupted state
-            await b.cardSession.finish('interrupted', { exitCode: -1 });
+            // Update card to show interrupted state. exitCode 不传（保持 null）：
+            // bash-renderer 的「已手动终止」文案要求 exitCode === null；传 -1 会让
+            // 该分支不可达，中断卡退化成「退出码: -1」的失败样式。
+            await b.cardSession.finish('interrupted');
             this.activeBashRuns.delete(runId);
             getLogger().info(`[lark-remote] interrupt bash stop done runId=${runId}`);
             stoppedCount++;
@@ -812,6 +815,29 @@ export class Bridge {
             return false;
         }
     }
+    /**
+     * Deliver a final answer that cannot fit in the run card. Plain text avoids
+     * markdown parser limits and preserves every character; sequence labels make
+     * multi-message delivery unambiguous.
+     */
+    async sendFinalAnswerOverflow(text, ctx) {
+        const chunks = splitFinalAnswer(text);
+        try {
+            for (let i = 0; i < chunks.length; i++) {
+                const prefix = chunks.length > 1 ? `完整回答（${i + 1}/${chunks.length}）\n\n` : '完整回答\n\n';
+                await this.connector.sendWithRetry(ctx.chatId, { text: prefix + chunks[i] }, { replyTo: ctx.messageId });
+            }
+        }
+        catch (err) {
+            getLogger().error('[lark-remote] failed to deliver complete final answer:', err);
+            try {
+                await this.connector.sendWithRetry(ctx.chatId, { text: `⚠️ 完整回答补发失败：${errorMessage(err)}` }, { replyTo: ctx.messageId });
+            }
+            catch (fallbackErr) {
+                getLogger().error('[lark-remote] final-answer failure notice also failed:', fallbackErr);
+            }
+        }
+    }
     /**
      * Update an existing card in place (原地更新) instead of sending a new one.
      *
@@ -1006,6 +1032,7 @@ export class Bridge {
         // 放在 finalize 之后：activeRuns 槽位已释放，续跑能正常开新卡片。
         await this.retryAfterContentFilter({
             cardSession,
+            activeRun,
             ctx,
             cwd,
             agentKind,
@@ -1042,6 +1069,12 @@ export class Bridge {
             getLogger().info(`[lark-remote] content_filter auto-retry skipped: session epoch moved runId=${state.runId}`);
             return;
         }
+        // 续跑必须接「本轮实际使用的 session」而非入队时刻快照（与 finalize 路径
+        // 的三级优先同口径：卡片状态 → activeRun → 起点快照）。快照只在 run 未建立
+        // 任何新会话时兜底。可证场景：新会话第一条消息（快照 undefined）被截断——
+        // init 已建立 S1，epoch 未动，传快照会让续跑落到全新空会话，本轮上下文
+        // 全部丢失；claude --resume fork 场景同理（init 上报的 id 才是权威）。
+        const retrySessionId = state.sessionId ?? params.activeRun.sessionId ?? params.sessionId;
         getLogger().warn(`[lark-remote] content_filter detected, auto-retrying once runId=${state.runId} cwd=${params.cwd}`);
         await this.sendResult({
             text: '🔁 上一回合被服务方内容审核截断（content_filter，通常是误报），已自动重试一次。',
@@ -1052,7 +1085,7 @@ export class Bridge {
                 cwdOverride: params.cwd,
                 binding: {
                     agent: params.agentKind,
-                    sessionId: params.sessionId,
+                    sessionId: retrySessionId,
                     sessionEpoch: params.sessionEpochAtStart,
                 },
                 autoRetry: true,
@@ -1164,60 +1197,7 @@ export class Bridge {
         // init the result was the only terminal signal we had. Keep it so the card
         // shows the real error instead of the generic "no result" fallback.
         let pendingPreInitTerminal;
-        // 记录 result 是否为 error: error 时跳过 jsonl usage 读取 (见 stream end 处说明)
-        let resultNotSuccess = false;
-        // Final usage read from jsonl after the run completes. live stream-json does
-        // not emit compact_boundary, so the live contextLength is unreliable.
-        let finalContextLength;
-        let finalContextLimit;
-        let finalCompactCount;
-        let finalCacheReadTokens;
-        let finalCacheCreationTokens;
-        let finalTotalTokens;
-        // Real input/output tokens captured from the live result event (codex/
-        // opencode carry them in ResultEvent.usage). Threaded to the card so the
-        // done card shows real values instead of the 10% estimate.
-        let liveInputTokens;
-        let liveOutputTokens;
-        // Real context window limit from the live result event (codex app-server
-        // carries it in ResultEvent.usage.context_limit). jsonl wins when present;
-        // live is the fallback (app-server error runs / jsonl 未落盘时).
-        let liveContextLimit;
-        // Final input/output for the done card: live value wins (codex/opencode
-        // carry per-run usage in the result event); jsonl is the fallback for
-        // agents whose live stream has no usage (kimi).
-        let finalInputTokens;
-        let finalOutputTokens;
-        // Session-cumulative input/output (all runs) read from jsonl; threaded to
-        // the done card's "累计" display. Always from jsonl (live has no cumulative).
-        let finalCumulativeTotalTokens;
-        let finalCumulativeInputTokens;
-        let finalCumulativeOutputTokens;
-        let finalCumulativeCacheReadTokens;
-        let finalCumulativeCacheCreationTokens;
-        // Reasoning tokens (pi usage.reasoning) from the live result event.
-        let finalReasoningTokens;
-        // 统一的 usage meta 构造（finalize 各分支共享，本方法内原先 5 处手写 11-15
-        // 字段对象；第 6 处 streamCompact 形状不同未收敛）。
-        // catch 路径需覆盖 flow 字段时在展开后覆写即可。catch error 路径亦复用此
-        // 闭包，相比旧手写对象补齐了累计 cache 字段（cumulativeCacheReadTokens/
-        // cumulativeCacheCreationTokens），属有意的口径对齐（向 done 路径看齐）。
-        const usageMeta = () => ({
-            contextLength: finalContextLength,
-            contextLimit: finalContextLimit,
-            compactCount: finalCompactCount,
-            cacheReadTokens: finalCacheReadTokens,
-            cacheCreationTokens: finalCacheCreationTokens,
-            totalTokens: finalTotalTokens,
-            inputTokens: finalInputTokens,
-            outputTokens: finalOutputTokens,
-            cumulativeTotalTokens: finalCumulativeTotalTokens,
-            cumulativeInputTokens: finalCumulativeInputTokens,
-            cumulativeOutputTokens: finalCumulativeOutputTokens,
-            cumulativeCacheReadTokens: finalCumulativeCacheReadTokens,
-            cumulativeCacheCreationTokens: finalCumulativeCacheCreationTokens,
-            reasoningTokens: finalReasoningTokens,
-        });
+        const usage = new RunUsageCollector();
         try {
             try {
                 // queue.immediate 的 run-start hold：目标槽位可能在 handler 发最终
@@ -1247,7 +1227,6 @@ export class Bridge {
                 runner,
                 pendingApprovals: () => this.approvalCoordinators.get(runId)?.pendingCount() ?? 0,
             });
-            let contextLength;
             getLogger().info(`[lark-remote] runner.run() begin runId=${runId} message=${message.slice(0, 100)}`);
             // Extract agent-specific options from config
             const agentOpts = this.getAgentRunOptions(agentKind);
@@ -1258,6 +1237,14 @@ export class Bridge {
             // ending (sawResult, usage capture, or cardSession.push would all
             // be wrong for the historical event).
             let sawInit = false;
+            const writeback = {
+                sessionStore: this.sessionStore,
+                userId: ctx.userId,
+                agentKind,
+                cwd,
+                sessionEpochAtStart,
+                runId,
+            };
             for await (const event of runner.run(message, runOpts)) {
                 // 只有终态才阻止事件处理。finalizing 是非终态，应该继续处理
                 // 这样在 result 事件后，后台任务输出仍能被正确处理
@@ -1270,34 +1257,7 @@ export class Bridge {
                     // 本轮真实使用的 session（不可变身份）：指针在 run 中被 /new 等移动时，
                     // 结束后的 usage 读取仍以它为准。
                     activeRun.sessionId = event.session_id;
-                    // 代际守卫：run 在途时 /new（或 new-session 卡片、/cd、/resume、
-                    // /config 切换）移动了 session 指针，此 init 的写回是 stale 的——
-                    // 跳过，否则 /new 的清空会被在途 run 静默撤销（2026-08-09 事故：
-                    // task-notification 注入触发 Claude 重发 init，已终止的 run 被复活）。
-                    const pointerMoved = this.sessionStore.getSessionEpoch(ctx.userId, agentKind) !== sessionEpochAtStart;
-                    if (pointerMoved) {
-                        getLogger().info(`[lark-remote] system.init write-back skipped: session pointer moved since run start runId=${runId} sessionId=${event.session_id}`);
-                    }
-                    else {
-                        // Use session's real directory from event.cwd (not runner's cwd parameter)
-                        // guard empty string too -- `??` only catches null/undefined, but a
-                        // translator (or older build) may emit cwd="", which must NOT overwrite
-                        // the good runner cwd.
-                        const hasCwd = !!this.sessionStore.getCwd(ctx.userId);
-                        const realCwd = event.cwd && event.cwd.length > 0 ? event.cwd : cwd;
-                        if (hasCwd && event.cwd && event.cwd !== cwd) {
-                            // Session has its own cwd (e.g. EnterWorktree relocate). Keep the
-                            // cwd unchanged; record the session's actual cwd in sessionCwds.
-                            getLogger().info(`[lark-remote] system.init: cwd=${cwd}, session cwd=${event.cwd}`);
-                            this.sessionStore.setSessionIdAndSessionCwd(ctx.userId, agentKind, event.session_id, realCwd);
-                        }
-                        else {
-                            // First use (no cwd yet) or event.cwd matches runner cwd:
-                            // set sessionId + cwd as before; on first use also bootstrap sessionCwds.
-                            const bootstrapSessionCwd = !hasCwd && event.cwd && event.cwd.length > 0 ? event.cwd : undefined;
-                            this.sessionStore.setSessionIdAndCwd(ctx.userId, agentKind, event.session_id, realCwd, bootstrapSessionCwd);
-                        }
-                    }
+                    writeBackInitSession(writeback, event);
                     getLogger().info(`[lark-remote] system.init received runId=${runId} sessionId=${event.session_id} cwd=${event.cwd}`);
                 }
                 if (event.type === 'turn_started') {
@@ -1307,20 +1267,13 @@ export class Bridge {
                     // 都新建线程（thread/start 而非 thread/resume），会话无法延续。
                     // init 缺失时以 threadId 作为本轮身份兜底。
                     activeRun.sessionId ??= event.threadId;
-                    const pointerMoved = this.sessionStore.getSessionEpoch(ctx.userId, agentKind) !== sessionEpochAtStart;
-                    if (!pointerMoved) {
-                        this.sessionStore.setSessionIdAndCwd(ctx.userId, agentKind, event.threadId, cwd);
-                        getLogger().info(`[lark-remote] turn_started session write-back runId=${runId} sessionId=${event.threadId}`);
-                    }
-                    else {
-                        getLogger().info(`[lark-remote] turn_started write-back skipped: session pointer moved since run start runId=${runId} sessionId=${event.threadId}`);
-                    }
+                    writeBackTurnStarted(writeback, event);
                 }
                 // Track context length from compaction events
                 if (event.type === 'system' &&
                     event.subtype === 'compact_boundary' &&
                     event.compactMetadata) {
-                    contextLength = event.compactMetadata.postTokens;
+                    usage.observeCompaction(event.compactMetadata.postTokens);
                 }
                 if (event.type === 'result') {
                     // Pre-init result guard: Claude CLI --resume emits a stale result
@@ -1360,7 +1313,7 @@ export class Bridge {
                     if (!preInitResult) {
                         sawResult = true;
                     }
-                    resultNotSuccess = event.subtype !== 'success';
+                    usage.observeResult(event);
                     getLogger().info(preInitResult
                         ? `[lark-remote] pre-init result from live runner (app-server setup failure) runId=${runId}`
                         : `[lark-remote] result event received runId=${runId}`);
@@ -1369,83 +1322,22 @@ export class Bridge {
                     // 里兜底上报。此处仅当 runner 声明 live usage（app-server）
                     // 且会话指针未动时写回，避免下条消息再开一个孤儿线程。其余 agent 不在
                     // 此列（它们各自有 system.init / turn_started 写回）。
-                    if (usageAuthority === 'live' &&
-                        event.session_id &&
-                        this.sessionStore.getSessionEpoch(ctx.userId, agentKind) === sessionEpochAtStart) {
-                        this.sessionStore.setSessionIdAndCwd(ctx.userId, agentKind, event.session_id, cwd);
-                        getLogger().info(`[lark-remote] result session write-back runId=${runId} sessionId=${event.session_id}`);
-                    }
-                    // result 后进入 finalizing 非终态（暂存 subtype/errorMsg），由 for-await
-                    // 自然结束后在 finally 转 done/error。提取 usage 信息。
-                    if (event.usage) {
-                        const u = normalizeResultUsage(event.usage);
-                        // input_tokens is non-cached (ccusage-aligned), so the context
-                        // length fallback must include cached tokens. Prefer the agent's
-                        // declared total; otherwise reconstruct from the parts.
-                        if (!contextLength) {
-                            contextLength = u.contextLength;
-                        }
-                        // Capture real input/output for the done card (avoiding the 10%
-                        // estimate in formatUsageStats). live 值优先：有 live input/output 时
-                        // 所有 flow 字段统一用 live scope（本 run），避免同一张卡片上
-                        // Input/Output 是本 run、Cache/Total 是 session 累计的混 scope 问题。
-                        liveInputTokens = u.inputTokens;
-                        liveOutputTokens = u.outputTokens;
-                        liveContextLimit = u.contextLimit;
-                        if (u.cacheReadTokens !== undefined) {
-                            finalCacheReadTokens = u.cacheReadTokens;
-                        }
-                        if (u.cacheCreationTokens !== undefined) {
-                            finalCacheCreationTokens = u.cacheCreationTokens;
-                        }
-                        if (u.totalTokens !== undefined) {
-                            finalTotalTokens = u.totalTokens;
-                        }
-                        if (u.reasoningTokens !== undefined) {
-                            finalReasoningTokens = u.reasoningTokens;
-                        }
-                    }
+                    if (usageAuthority === 'live')
+                        writeBackResultSession(writeback, event.session_id);
                 }
                 // Approval events (Codex app-server mode)
                 if (event.type === 'approval_requested') {
                     // 审批请求到达：撤回 Typing 表情再重发，让飞书重新触发提醒，把用户
                     // 注意力拉回待审批的卡片（run 在等待人工决策，Typing 应重新闪烁）。
-                    void (async () => {
-                        try {
-                            await this.connector.removeReactionByEmoji(ctx.messageId, 'Typing');
-                        }
-                        catch (err) {
-                            getLogger().warn(`[lark-remote] remove Typing reaction failed runId=${runId}: ${errorMessage(err)}`);
-                        }
-                        try {
-                            await this.connector.addReaction(ctx.messageId, 'Typing');
-                        }
-                        catch (err) {
-                            getLogger().warn(`[lark-remote] re-add Typing reaction failed runId=${runId}: ${errorMessage(err)}`);
-                        }
-                    })();
+                    remindPendingApproval(this.connector, ctx.messageId, runId);
                     let coordinator = this.approvalCoordinators.get(runId);
                     if (!coordinator) {
-                        coordinator = new ApprovalCoordinator({
-                            // claude 审批超时走 config（claude.approvalTimeoutMs，默认 5 分钟，
-                            // 对齐 codex 红线勿改短）；codex 维持模块常量。
-                            approvalTimeoutMs: agentKind === 'claude'
-                                ? (this.config.claude?.approvalTimeoutMs ?? APPROVAL_TIMEOUT_MS)
-                                : APPROVAL_TIMEOUT_MS,
-                            responder: async (requestId, response) => {
-                                const r = runner;
-                                if (typeof r.respondApproval === 'function') {
-                                    await r.respondApproval(requestId, response);
-                                }
-                            },
-                            interruptTurn: async () => {
-                                // DSH may return a StopOutcome; the coordinator only awaits.
-                                await runner.stop();
-                            },
-                            pushToCard: async (events) => {
-                                for (const ev of events)
-                                    await cardSession.push(ev);
-                            },
+                        coordinator = createRunApprovalCoordinator({
+                            runner,
+                            cardSession,
+                            config: this.config,
+                            runId,
+                            agentKind,
                         });
                         this.approvalCoordinators.set(runId, coordinator);
                         getLogger().info(`[lark-remote] approval coordinator created runId=${runId.slice(0, 8)} requestId=${event.requestId}`);
@@ -1484,44 +1376,11 @@ export class Bridge {
             // 优先级：卡片状态（本轮 init 写入）→ activeRun（本轮 init/turn_started）
             // → 本轮开始时捕获的 sessionId。三者都没有就跳过 usage，绝不回读全局指针。
             const finalSessionId = cardSession.currentState.sessionId ?? activeRun.sessionId ?? sessionId;
-            const finalUsage = resultNotSuccess
+            const finalUsage = usage.resultNotSuccess
                 ? undefined
                 : resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, finalSessionId, cwd, agentKind);
-            finalContextLength = finalUsage?.contextLength ?? contextLength;
-            finalContextLimit = finalUsage?.contextLimit ?? liveContextLimit;
-            finalCompactCount = finalUsage?.compactCount;
-            finalCumulativeTotalTokens = finalUsage?.cumulativeTotalTokens;
-            finalCumulativeInputTokens = finalUsage?.cumulativeInputTokens;
-            finalCumulativeOutputTokens = finalUsage?.cumulativeOutputTokens;
-            finalCumulativeCacheReadTokens = finalUsage?.cumulativeCacheReadTokens;
-            finalCumulativeCacheCreationTokens = finalUsage?.cumulativeCacheCreationTokens;
-            // 统一 flow 字段 scope：live 优先，jsonl 兜底。
-            // 当 live result 事件带了 input/output（即 liveInputTokens/liveOutputTokens
-            // 非 undefined），所有 flow 字段统一用 live scope（本 run），不用 jsonl
-            // 的 session 累计值覆盖，避免 cache%/Total 分子分母不同源。
-            // 无 live usage 时（如 kimi），jsonl 值兜底。
-            // contextLength/compactCount 保持 jsonl 优先（它们是水位/历史计数）。
-            const codexJsonlFirst = usageAuthority === 'jsonl';
-            if (!codexJsonlFirst && liveInputTokens !== undefined && liveOutputTokens !== undefined) {
-                // 非 codex 且 live 有 input/output → 所有 flow 字段用 live scope
-                finalInputTokens = liveInputTokens;
-                finalOutputTokens = liveOutputTokens;
-                // cacheReadTokens/cacheCreationTokens/totalTokens
-                // 已在上面 result 事件处理中赋了 live 值；若 live 没有则为 undefined，
-                // 由 formatUsageStats 的 max/兜底公式处理。
-            }
-            else {
-                // codex（jsonl 优先）或无 live usage → jsonl 兜底所有 flow 字段。
-                // jsonl 的非累计字段已是末轮（本 run）scope（claude reader 修复后对齐
-                // codex `last_token_usage` 语义，见 scalarScan），不再是 session 累计；
-                // session 累计只经 cumulative* 字段透传，卡片"本 run ≤ 累计"不变量成立。
-                finalInputTokens = finalUsage?.inputTokens ?? liveInputTokens;
-                finalOutputTokens = finalUsage?.outputTokens ?? liveOutputTokens;
-                finalCacheReadTokens = finalUsage?.cacheReadTokens ?? finalCacheReadTokens;
-                finalCacheCreationTokens = finalUsage?.cacheCreationTokens ?? finalCacheCreationTokens;
-                finalTotalTokens = finalUsage?.totalTokens ?? finalTotalTokens;
-            }
-            getLogger().info(`[lark-remote] final usage runId=${runId} contextLength=${finalContextLength} contextLimit=${finalContextLimit ?? 'undefined'} compactCount=${finalCompactCount ?? 'undefined'} cacheRead=${finalCacheReadTokens ?? 'undefined'} cacheCreate=${finalCacheCreationTokens ?? 'undefined'}`);
+            usage.finalize(finalUsage, usageAuthority);
+            getLogger().info(usage.logSummary(runId));
             // for-await 自然结束 = stream 关闭 = CLI 进程退出。
             // 进程退出（for-await end）= 唯一终态触发源。
             // 1) finalizing（result 已收到）-> 转 done/error + usage meta
@@ -1546,7 +1405,7 @@ export class Bridge {
                 await cardSession.finish(terminal, {
                     resultSubtype: subtype,
                     errorMsg: finalState.errorMsg,
-                    ...usageMeta(),
+                    ...usage.meta(),
                 });
             }
             else if (finalState.terminal === 'running') {
@@ -1554,14 +1413,14 @@ export class Bridge {
                     const terminal = pendingPreInitTerminal.subtype === 'interrupted' ? 'interrupted' : 'error';
                     getLogger().warn(`[lark-remote] stream ended without init; using pre-init ${terminal} result runId=${runId} error=${pendingPreInitTerminal.errorMessage ?? '(none)'}`);
                     await cardSession.finish(terminal, {
-                        ...usageMeta(),
+                        ...usage.meta(),
                         errorMsg: pendingPreInitTerminal.errorMessage ??
                             agentDisplayName(agentKind) + (terminal === 'interrupted' ? ' 已中断' : ' 启动失败'),
                     });
                 }
                 else {
                     await cardSession.finish('error', {
-                        ...usageMeta(),
+                        ...usage.meta(),
                         errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
                     });
                 }
@@ -1569,7 +1428,7 @@ export class Bridge {
             else if (sawResult) {
                 // 已终态（interrupted/idle_timeout）+ result 已收到：首终态优先，
                 // 仅补充 usage meta（finalizing 期间被 /stop 或 idle 超时也展示 token 统计）
-                await cardSession.finish(finalState.terminal, usageMeta());
+                await cardSession.finish(finalState.terminal, usage.meta());
             }
             // else: 已终态且未收到 result（如 spawn 失败后 interrupted）-> 无 usage 可补，跳过
         }
@@ -1588,16 +1447,16 @@ export class Bridge {
             const catchTerminal = cardSession.currentState.terminal;
             if (catchTerminal === 'running' || catchTerminal === 'finalizing') {
                 await cardSession.finish('error', {
-                    ...usageMeta(),
-                    inputTokens: liveInputTokens,
-                    outputTokens: liveOutputTokens,
+                    ...usage.meta(),
+                    inputTokens: usage.liveInputTokens,
+                    outputTokens: usage.liveOutputTokens,
                     errorMsg: errorMessage(err),
                 });
             }
             else {
                 getLogger().info(`[lark-remote] skip error finish: state already terminal (${catchTerminal}) runId=${runId}`);
                 if (sawResult) {
-                    await cardSession.finish(catchTerminal, usageMeta());
+                    await cardSession.finish(catchTerminal, usage.meta());
                 }
             }
         }
@@ -1650,10 +1509,11 @@ export class Bridge {
                 sessionFallbackAvailable: !!(cardSession.currentState.sessionId ??
                     this.sessionStore.getSessionId(ctx.userId, activeRun.agentKind)),
             };
+            const finalRender = renderRunCardDetailed(cardSession.currentState, finalRenderOptions);
             this.rememberRunCardSnapshot(runId, cardSession.currentState, finalRenderOptions, cwd, activeRun.agentKind);
             let runCardSent = false;
             if (settleResult === 'unsent') {
-                const sent = await this.sendResult({ card: renderRunCard(cardSession.currentState, finalRenderOptions) }, ctx);
+                const sent = await this.sendResult({ card: finalRender.card }, ctx);
                 runCardSent = sent;
             }
             else {
@@ -1666,6 +1526,9 @@ export class Bridge {
             if (sessionId && runCardSent) {
                 await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind);
             }
+            if (finalRender.finalAnswerStatus === 'overflow' && finalRender.finalAnswerText) {
+                await this.sendFinalAnswerOverflow(finalRender.finalAnswerText, ctx);
+            }
             // Add a terminal-state emoji reaction to the user's original message
             this.finishTurnReactions(ctx, terminalReactionEmoji(cardSession.currentState.terminal));
         }
@@ -1806,27 +1669,21 @@ export class Bridge {
      * 路由到 ApprovalCoordinator.toggleAnswer。
      */
     async handleApprovalAnswer(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalAnswer runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
-        return this.withCoordinator(opts.runId, (coordinator) => coordinator.toggleAnswer({ questionIndex: opts.questionIndex, option: opts.option }, { requestId: opts.requestId, nonce: opts.nonce }));
+        return this.dispatchQuestionAction(opts, 'handleApprovalAnswer', (coordinator) => coordinator.toggleAnswer({ questionIndex: opts.questionIndex, option: opts.option }, { requestId: opts.requestId, nonce: opts.nonce }));
     }
     /**
      * Claude AskUserQuestion 多选问题的「提交答案」按钮。
      * 路由到 ApprovalCoordinator.submitAnswers。
      */
     async handleApprovalAnswerSubmit(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalAnswerSubmit runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
-        return this.withCoordinator(opts.runId, (coordinator) => coordinator.submitAnswers({ questionIndex: opts.questionIndex }, { requestId: opts.requestId, nonce: opts.nonce }));
+        return this.dispatchQuestionAction(opts, 'handleApprovalAnswerSubmit', (coordinator) => coordinator.submitAnswers({ questionIndex: opts.questionIndex }, { requestId: opts.requestId, nonce: opts.nonce }));
     }
     /**
      * Claude AskUserQuestion 自定义答案（Other）：自由文本直接
      * 作为该单选问题的答案提交。路由到 ApprovalCoordinator.answerCustom。
      */
     async handleApprovalAnswerCustom(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalAnswerCustom runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
-        return this.withCoordinator(opts.runId, (coordinator) => coordinator.answerCustom({ questionIndex: opts.questionIndex, text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce }));
+        return this.dispatchQuestionAction(opts, 'handleApprovalAnswerCustom', (coordinator) => coordinator.answerCustom({ questionIndex: opts.questionIndex, text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce }));
     }
     /**
      * Codex AskUserQuestion 补充说明（user_note，2026-08-18 live 验证模型理解
@@ -1834,9 +1691,11 @@ export class Bridge {
      * 路由到 ApprovalCoordinator.answerNote。
      */
     async handleApprovalAnswerNote(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalAnswerNote runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
-        return this.withCoordinator(opts.runId, (coordinator) => coordinator.answerNote({ questionIndex: opts.questionIndex, text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce }));
+        return this.dispatchQuestionAction(opts, 'handleApprovalAnswerNote', (coordinator) => coordinator.answerNote({ questionIndex: opts.questionIndex, text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce }));
+    }
+    dispatchQuestionAction(opts, action, invoke) {
+        getLogger().info(`[lark-remote] ${action} runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
+        return this.withCoordinator(opts.runId, invoke);
     }
     /**
      * 记下一次「可压缩 run」：终态卡上的 Compact 按钮点击时据此反查
@@ -2317,8 +2176,8 @@ export class Bridge {
                 try {
                     await this.connector.sendWithRetry(ctx.chatId, { card: renderBashCard(cardSession.currentState, {}) }, { replyTo: ctx.messageId });
                 }
-                catch {
-                    /* ignore fallback errors */
+                catch (fallbackErr) {
+                    getLogger().error(`[lark-remote] bash terminal fallback card failed runId=${runId} chatId=${ctx.chatId}:`, fallbackErr);
                 }
             }
             if (this.activeBashRuns.has(runId)) {

package/dist/bridge/run-approval.d.ts

@@ -0,0 +1,15 @@
+import { type AppConfig } from '../config/index.js';
+import type { AgentKind, Runner } from '../runner/index.js';
+import type { RunCardSession } from '../card/run-card-session.js';
+import { ApprovalCoordinator } from './approval-coordinator.js';
+export declare function remindPendingApproval(connector: {
+    removeReactionByEmoji(messageId: string, emoji: string): Promise<void>;
+    addReaction(messageId: string, emoji: string): Promise<void>;
+}, messageId: string, runId: string): void;
+export declare function createRunApprovalCoordinator(opts: {
+    runner: Runner;
+    cardSession: RunCardSession;
+    config: AppConfig;
+    runId: string;
+    agentKind: AgentKind;
+}): ApprovalCoordinator;

package/dist/bridge/run-approval.js

@@ -0,0 +1,41 @@
+import { DEFAULT_APPROVAL_TIMEOUT_MS } from '../config/index.js';
+import { ApprovalCoordinator } from './approval-coordinator.js';
+import { getLogger } from '../logger/index.js';
+import { errorMessage } from './final-usage.js';
+export function remindPendingApproval(connector, messageId, runId) {
+    void (async () => {
+        try {
+            await connector.removeReactionByEmoji(messageId, 'Typing');
+        }
+        catch (err) {
+            getLogger().warn(`[lark-remote] remove Typing reaction failed runId=${runId}: ${errorMessage(err)}`);
+        }
+        try {
+            await connector.addReaction(messageId, 'Typing');
+        }
+        catch (err) {
+            getLogger().warn(`[lark-remote] re-add Typing reaction failed runId=${runId}: ${errorMessage(err)}`);
+        }
+    })();
+}
+export function createRunApprovalCoordinator(opts) {
+    return new ApprovalCoordinator({
+        approvalTimeoutMs: opts.agentKind === 'claude'
+            ? (opts.config.claude?.approvalTimeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MS)
+            : DEFAULT_APPROVAL_TIMEOUT_MS,
+        responder: async (requestId, response) => {
+            const runner = opts.runner;
+            if (typeof runner.respondApproval === 'function') {
+                await runner.respondApproval(requestId, response);
+            }
+        },
+        interruptTurn: async () => {
+            await opts.runner.stop();
+        },
+        pushToCard: async (events) => {
+            for (const event of events)
+                await opts.cardSession.push(event);
+        },
+    });
+}
+//# sourceMappingURL=run-approval.js.map

package/dist/bridge/run-usage.d.ts

@@ -0,0 +1,46 @@
+import type { ResultEvent } from '../runner/types.js';
+import type { FinalUsageSnapshot } from './final-usage.js';
+export type UsageAuthority = 'live' | 'jsonl';
+export declare class RunUsageCollector {
+    private contextLength?;
+    private finalContextLength?;
+    private finalContextLimit?;
+    private finalCompactCount?;
+    private finalCacheReadTokens?;
+    private finalCacheCreationTokens?;
+    private finalTotalTokens?;
+    private liveInput?;
+    private liveOutput?;
+    private liveContextLimit?;
+    private finalInputTokens?;
+    private finalOutputTokens?;
+    private finalCumulativeTotalTokens?;
+    private finalCumulativeInputTokens?;
+    private finalCumulativeOutputTokens?;
+    private finalCumulativeCacheReadTokens?;
+    private finalCumulativeCacheCreationTokens?;
+    private finalReasoningTokens?;
+    resultNotSuccess: boolean;
+    get liveInputTokens(): number | undefined;
+    get liveOutputTokens(): number | undefined;
+    observeCompaction(postTokens: number): void;
+    observeResult(event: ResultEvent): void;
+    finalize(finalUsage: FinalUsageSnapshot | undefined, authority: UsageAuthority | undefined): void;
+    meta(): {
+        contextLength?: number;
+        contextLimit?: number;
+        compactCount?: number;
+        cacheReadTokens?: number;
+        cacheCreationTokens?: number;
+        totalTokens?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        cumulativeTotalTokens?: number;
+        cumulativeInputTokens?: number;
+        cumulativeOutputTokens?: number;
+        cumulativeCacheReadTokens?: number;
+        cumulativeCacheCreationTokens?: number;
+        reasoningTokens?: number;
+    };
+    logSummary(runId: string): string;
+}