lark-remote 0.5.12 → 0.5.14

package/dist/bridge/index.js

@@ -4,18 +4,22 @@ 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 { isRunActive, isRunTerminal, removeBackgroundJob, } from '../card/run-state.js';
+import { buildSessionHistoryCard } from '../card/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 { AGENT_KINDS } from '../agent-kinds.js';
+import { supportsCompact } from '../runner/types.js';
 import { QueueManager, } from './queue-manager.js';
-import { ApprovalCoordinator, decisionToApprovalAction } from './approval-coordinator.js';
+import { ApprovalActions } from './approval-actions.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 +28,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 且进程已停」的死缓存，防止随访问过的工作区数量
@@ -141,6 +143,10 @@ export class Bridge {
     activeRuns = new Map();
     /** Approval coordinators keyed by runId. */
     approvalCoordinators = new Map();
+    /** 审批卡动作的实现（只读上面那张表；见 approval-actions.ts）。 */
+    approvalActions = new ApprovalActions({
+        coordinatorFor: (runId) => this.approvalCoordinators.get(runId),
+    });
     /**
      * 最近若干次已完成的、runner 有 runCompact 的 run（cwd → runId → 记录）。
      * run 结束后 activeRuns 已清空，而终态卡上的 Compact 按钮只带 runId，
@@ -223,13 +229,8 @@ export class Bridge {
         }
         // Create new runner for this (cwd, kind) slot
         const runner = this.agentRegistry.get(kind, cwd);
-        // Call lifecycle methods for agent runners created via factory
-        if (runner && typeof runner.killOrphan === 'function') {
-            runner.killOrphan();
-        }
-        if (runner && typeof runner.registerExitHandlers === 'function') {
-            runner.registerExitHandlers();
-        }
+        runner.killOrphan();
+        runner.registerExitHandlers();
         // Store in nested map: Map<cwd, Map<kind, Runner>>。必须重新取一次：
         // replaceStale 刚把槽位 evict 掉，上面的局部 workspaceMap 可能已随空槽
         // 从 this.runners 移除——继续写它会生成一个「缓存里查不到」的 runner，
@@ -588,7 +589,7 @@ export class Bridge {
         for (const [_cwd, active] of this.activeRuns) {
             const state = active.session.currentState;
             // Only include non-terminal runs
-            if (state.terminal === 'running' || state.terminal === 'finalizing') {
+            if (isRunActive(state.terminal)) {
                 result.push({
                     runId: active.runId,
                     sessionId: state.sessionId ?? '',
@@ -814,10 +815,33 @@ 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.
      *
-     * Used by /config cardAction handlers (config.toggle/set/input/save) so the
+     * Used by /config cardAction handlers (config.set/input/save) so the
      * user sees the card refresh on the same message bubble rather than getting
      * a new card per click — same-message-bubble update pattern.
      *
@@ -863,7 +887,8 @@ export class Bridge {
             return true;
         }
         catch (err) {
-            getLogger().debug(`[lark-remote] patchCard failed messageId=${messageId}: ${errorMessage(err)}`);
+            // 调用方会据此把卡片从集合里永久剔除——这是用户可见的退化，warn 起步。
+            getLogger().warn(`[lark-remote] patchCard failed messageId=${messageId}: ${errorMessage(err)}`);
             return false;
         }
     }
@@ -901,10 +926,7 @@ export class Bridge {
         const killed = await runner.killJob(sessionId, jobId);
         if (!killed)
             return false;
-        snapshot.state = {
-            ...snapshot.state,
-            backgroundJobs: (snapshot.state.backgroundJobs ?? []).filter((job) => job.id !== jobId),
-        };
+        snapshot.state = removeBackgroundJob(snapshot.state, jobId);
         await this.updateCardInPlace(renderRunCard(snapshot.state, snapshot.options), ctx);
         return true;
     }
@@ -968,7 +990,7 @@ export class Bridge {
         }
         const entry = this.sessionStore.get(ctx.userId);
         getLogger().debug(`[lark-remote] forward entry userId=${ctx.userId} chatId=${ctx.chatId} cwd=${cwd} ` +
-            `agent=${agentKind} sessionId=${opts?.binding?.sessionId ?? entry?.sessions?.get(agentKind) ?? '(none)'} message=${message.slice(0, 100)}`);
+            `agent=${agentKind} sessionId=${opts?.binding?.sessionId ?? entry?.sessions.get(agentKind) ?? '(none)'} message=${message.slice(0, 100)}`);
         // Check if current cwd already has a run in progress
         if (this.activeRuns.has(cwd)) {
             getLogger().warn(`[lark-remote] cwd busy, dropping message userId=${ctx.userId} cwd=${cwd}`);
@@ -1156,6 +1178,139 @@ export class Bridge {
             stop,
         };
     }
+    /**
+     * result 事件的 pre-init 守卫（§9.22）。
+     *
+     * Claude CLI `--resume` 会在 system.init 之前先吐一条**上一轮**的陈旧 result。
+     * 认了它就会过早置 sawResult / 抓错 usage / 让 run-state reducer 提前进入
+     * finalizing（reducer 用 sessionId===undefined 守卫，同一条红线）。本轮真正的
+     * result 在 system.init 之后才到。
+     *
+     * 例外：app-server runner（usageAuthority==='live'）的 init 是 runner 自己补发
+     * 的 synthetic init（2026-08-13 修复）。此分支保留为防御性兜底：live runner 若
+     * 在无 init 时发出 result（旧构建等），session 写回照常执行，但 sawResult 不置
+     * 真——卡片不会把半初始化的 run 当作已收尾。
+     *
+     * @param dropFromCard 该 result 是陈旧重放，不得进卡片（调用方 continue 跳过 push）
+     */
+    observeResultEvent(event, opts) {
+        const { sawInit, usageAuthority, usage, writeback, runId } = opts;
+        const preInitResult = !sawInit;
+        const preInitTerminal = preInitResult && (event.subtype === 'error' || event.subtype === 'interrupted')
+            ? {
+                subtype: event.subtype,
+                errorMessage: event.errorMessage,
+            }
+            : undefined;
+        if (preInitResult && usageAuthority !== 'live') {
+            getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
+            return { sawResult: false, dropFromCard: true, preInitTerminal };
+        }
+        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}`);
+        // app-server 模式 setup 失败路径（thread/start 成功后 turn/start 失败）不会有
+        // turn_started 事件，store 不会写回新线程 id；runner 已在 result 里兜底上报。
+        // 仅当 runner 声明 live usage（app-server）且会话指针未动时写回，避免下条消息
+        // 再开一个孤儿线程。其余 agent 不在此列（各自有 system.init / turn_started 写回）。
+        if (usageAuthority === 'live')
+            writeBackResultSession(writeback, event.session_id);
+        return { sawResult: !preInitResult, dropFromCard: false, preInitTerminal };
+    }
+    /**
+     * 审批三事件的派发（requested / resolved / view_updated）。
+     *
+     * coordinator 一 run 一个，首次 requested 时惰性建好并登记，`finally` 里统一
+     * onTurnEnded + 摘除。
+     */
+    dispatchApprovalEvent(event, opts) {
+        const { runId, runner, cardSession, ctx, agentKind } = opts;
+        if (event.type === 'approval_requested') {
+            // 审批请求到达：撤回 Typing 表情再重发，让飞书重新触发提醒，把用户
+            // 注意力拉回待审批的卡片（run 在等待人工决策，Typing 应重新闪烁）。
+            remindPendingApproval(this.connector, ctx.messageId, runId);
+            let coordinator = this.approvalCoordinators.get(runId);
+            if (!coordinator) {
+                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}`);
+            }
+            coordinator.onRequested(event);
+            return;
+        }
+        const coordinator = this.approvalCoordinators.get(runId);
+        if (event.type === 'approval_resolved') {
+            coordinator?.onResolved(event.requestId);
+            return;
+        }
+        // 乱序流：审批先到、item/started 后到，补全审批卡内容。coordinator
+        // 仅在 pending 时更新（已响应/过期不复活）。
+        coordinator?.updateView(event.requestId, event.view);
+    }
+    /**
+     * 进程退出（for-await 自然结束）后的终态矩阵——它是本轮的唯一终态触发源。
+     *
+     * 1) finalizing（result 已收到）→ 三态映射 + usage meta
+     * 2) running（未收到 result）→ 错误路径；pre-init 终态优先当唯一线索
+     * 3) 已终态 + sawResult → 首终态不动，仅补 usage meta
+     * 4) 已终态且未收到 result（如 spawn 失败后 interrupted）→ 无 usage 可补，跳过
+     */
+    async finishRunAfterStream(opts) {
+        const { cardSession, usage, sawResult, pendingPreInitTerminal, agentKind, runId } = opts;
+        const finalState = cardSession.currentState;
+        if (finalState.terminal === 'finalizing') {
+            // 三态终态映射（2026-08-14）：interrupted（审批超时/取消、/stop）是独立
+            // 终态，不再归因于 Agent 错误；error 保持「运行出错」；其余为 done。
+            const subtype = finalState.resultSubtype;
+            const isError = subtype === 'error' || !!finalState.errorMsg;
+            // goal 仍 active = 宿主会自动起下一轮：这不是"完成"，而是"本轮结束"。
+            // 用独立终态而不是 done，既不改 header 文案也不用谎报。
+            const goalContinues = !isError && subtype !== 'interrupted' && finalState.goal?.phase === 'active';
+            const terminal = isError
+                ? 'error'
+                : subtype === 'interrupted'
+                    ? 'interrupted'
+                    : goalContinues
+                        ? 'goal_continuing'
+                        : 'done';
+            await cardSession.finish(terminal, {
+                resultSubtype: subtype,
+                errorMsg: finalState.errorMsg,
+                ...usage.meta(),
+            });
+            return;
+        }
+        if (finalState.terminal === 'running') {
+            if (pendingPreInitTerminal) {
+                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, {
+                    ...usage.meta(),
+                    errorMsg: pendingPreInitTerminal.errorMessage ??
+                        agentDisplayName(agentKind) + (terminal === 'interrupted' ? ' 已中断' : ' 启动失败'),
+                });
+            }
+            else {
+                await cardSession.finish('error', {
+                    ...usage.meta(),
+                    errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
+                });
+            }
+            return;
+        }
+        if (sawResult) {
+            // 已终态（interrupted/idle_timeout）+ result 已收到：首终态优先，
+            // 仅补充 usage meta（finalizing 期间被 /stop 或 idle 超时也展示 token 统计）
+            await cardSession.finish(finalState.terminal, usage.meta());
+        }
+    }
     /**
      * Step 2 of forwardToClaude: Run the agent and consume its event stream.
      * Handles idle watchdog, event processing, session sync, and state transitions.
@@ -1173,60 +1328,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 发最终
@@ -1256,7 +1358,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);
@@ -1267,6 +1368,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 事件后，后台任务输出仍能被正确处理
@@ -1279,34 +1388,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') {
@@ -1316,160 +1398,39 @@ 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
-                    // (from the previous turn) before system.init. Ignoring it prevents
-                    // premature sawResult/usage capture and the run-state reducer (which
-                    // also guards on sessionId === undefined) from transitioning to
-                    // finalizing too early. The real result for this run arrives after
-                    // system.init.
-                    //
-                    // Exception: app-server runners (usageAuthority === 'live') 的 init
-                    // 是 runner 补发的 synthetic init（2026-08-13 修复）。此分支保留为
-                    // 防御性兜底：任何 live runner 若在无 init 时发出 result（如旧构建、
-                    // 其它 live runner），session 写回仍执行，但 sawResult 保持 false，
-                    // 卡片不会把半初始化的 run 当作已收尾。
-                    const preInitResult = !sawInit;
-                    if (preInitResult && usageAuthority !== 'live') {
-                        getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
-                        if (event.subtype === 'error' || event.subtype === 'interrupted') {
-                            pendingPreInitTerminal ??= {
-                                subtype: event.subtype,
-                                errorMessage: event.errorMessage,
-                            };
-                        }
-                        // Still reset idle timer — the CLI is alive and producing events.
+                    const outcome = this.observeResultEvent(event, {
+                        sawInit,
+                        usageAuthority,
+                        usage,
+                        writeback,
+                        runId,
+                    });
+                    if (outcome.preInitTerminal)
+                        pendingPreInitTerminal ??= outcome.preInitTerminal;
+                    if (outcome.sawResult)
+                        sawResult = true;
+                    // 陈旧 result 不进卡片：run-state reducer 本来也会因 sessionId 未定而
+                    // 跳过，在 bridge 层就拦掉可以省下一次无谓的 push + render。
+                    if (outcome.dropFromCard) {
+                        // 仍然重置 idle 计时——CLI 活着并且在产事件。
                         watchdog?.touch();
-                        // Do NOT push to cardSession: the run-state reducer would also
-                        // skip it (sessionId === undefined), but skipping at the bridge
-                        // layer avoids the push + render overhead for a no-op event.
                         continue;
                     }
-                    if (preInitResult && (event.subtype === 'error' || event.subtype === 'interrupted')) {
-                        pendingPreInitTerminal ??= {
-                            subtype: event.subtype,
-                            errorMessage: event.errorMessage,
-                        };
-                    }
-                    if (!preInitResult) {
-                        sawResult = true;
-                    }
-                    resultNotSuccess = event.subtype !== 'success';
-                    getLogger().info(preInitResult
-                        ? `[lark-remote] pre-init result from live runner (app-server setup failure) runId=${runId}`
-                        : `[lark-remote] result event received runId=${runId}`);
-                    // app-server 模式 setup 失败路径（thread/start 成功后 turn/start 失败）
-                    // 不会有 turn_started 事件，store 不会写回新线程 id；runner 已在 result
-                    // 里兜底上报。此处仅当 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;
-                        }
-                    }
                 }
                 // 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)}`);
-                        }
-                    })();
-                    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);
-                            },
-                        });
-                        this.approvalCoordinators.set(runId, coordinator);
-                        getLogger().info(`[lark-remote] approval coordinator created runId=${runId.slice(0, 8)} requestId=${event.requestId}`);
-                    }
-                    coordinator.onRequested(event);
-                }
-                else if (event.type === 'approval_resolved') {
-                    const coordinator = this.approvalCoordinators.get(runId);
-                    coordinator?.onResolved(event.requestId);
-                }
-                else if (event.type === 'approval_view_updated') {
-                    // 乱序流：审批先到、item/started 后到，补全审批卡内容。coordinator
-                    // 仅在 pending 时更新（已响应/过期不复活）。
-                    const coordinator = this.approvalCoordinators.get(runId);
-                    coordinator?.updateView(event.requestId, event.view);
+                if (event.type === 'approval_requested' ||
+                    event.type === 'approval_resolved' ||
+                    event.type === 'approval_view_updated') {
+                    this.dispatchApprovalEvent(event, { runId, runner, cardSession, ctx, agentKind });
                 }
                 // §9.12 红线：每个事件（含 result）无条件刷新
                 // lastEventTs 重新武装看门狗。result 后 CLI 进程做 jsonl flush/清理（finalizing
@@ -1493,94 +1454,20 @@ 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'}`);
-            // for-await 自然结束 = stream 关闭 = CLI 进程退出。
-            // 进程退出（for-await end）= 唯一终态触发源。
-            // 1) finalizing（result 已收到）-> 转 done/error + usage meta
-            // 2) running（未收到 result）-> 错误路径
-            // 3) 已终态 + sawResult -> 补充 usage meta（不改 terminal）
-            const finalState = cardSession.currentState;
-            if (finalState.terminal === 'finalizing') {
-                // 三态终态映射（2026-08-14）：interrupted（审批超时/取消、/stop）是独立
-                // 终态，不再归因于 Agent 错误；error 保持「运行出错」；其余为 done。
-                const subtype = finalState.resultSubtype;
-                const isError = subtype === 'error' || !!finalState.errorMsg;
-                // goal 仍 active = 宿主会自动起下一轮：这不是"完成"，而是"本轮结束"。
-                // 用独立终态而不是 done，既不改 header 文案也不用谎报。
-                const goalContinues = !isError && subtype !== 'interrupted' && finalState.goal?.phase === 'active';
-                const terminal = isError
-                    ? 'error'
-                    : subtype === 'interrupted'
-                        ? 'interrupted'
-                        : goalContinues
-                            ? 'goal_continuing'
-                            : 'done';
-                await cardSession.finish(terminal, {
-                    resultSubtype: subtype,
-                    errorMsg: finalState.errorMsg,
-                    ...usageMeta(),
-                });
-            }
-            else if (finalState.terminal === 'running') {
-                if (pendingPreInitTerminal) {
-                    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(),
-                        errorMsg: pendingPreInitTerminal.errorMessage ??
-                            agentDisplayName(agentKind) + (terminal === 'interrupted' ? ' 已中断' : ' 启动失败'),
-                    });
-                }
-                else {
-                    await cardSession.finish('error', {
-                        ...usageMeta(),
-                        errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
-                    });
-                }
-            }
-            else if (sawResult) {
-                // 已终态（interrupted/idle_timeout）+ result 已收到：首终态优先，
-                // 仅补充 usage meta（finalizing 期间被 /stop 或 idle 超时也展示 token 统计）
-                await cardSession.finish(finalState.terminal, usageMeta());
-            }
-            // else: 已终态且未收到 result（如 spawn 失败后 interrupted）-> 无 usage 可补，跳过
+            usage.finalize(finalUsage, usageAuthority);
+            getLogger().info(usage.logSummary(runId));
+            // for-await 自然结束 = stream 关闭 = CLI 进程退出 → 终态矩阵
+            await this.finishRunAfterStream({
+                cardSession,
+                usage,
+                sawResult,
+                pendingPreInitTerminal,
+                agentKind,
+                runId,
+            });
         }
         catch (err) {
             getLogger().error(`[lark-remote] claude run error runId=${runId}:`, err);
@@ -1595,18 +1482,18 @@ export class Bridge {
             // 终态守卫：running 或 finalizing（非终态）-> 转 error；
             // 已终态（interrupted/idle_timeout/done/error）-> 保留首终态，仅补充 usage。
             const catchTerminal = cardSession.currentState.terminal;
-            if (catchTerminal === 'running' || catchTerminal === 'finalizing') {
+            if (isRunActive(catchTerminal)) {
                 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());
                 }
             }
         }
@@ -1659,10 +1546,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 {
@@ -1675,6 +1563,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));
         }
@@ -1758,94 +1649,36 @@ export class Bridge {
     // =============================================================================
     // Approval action handlers
     // =============================================================================
-    /**
-     * Resolve the ApprovalCoordinator for a run, or throw the standard
-     * "已结束" error. Shared preamble of all approval card-action handlers.
-     */
-    withCoordinator(runId, fn) {
-        const coordinator = this.approvalCoordinators.get(runId);
-        if (!coordinator) {
-            // run 已结束（coordinator 已释放）时点击审批按钮必须给用户明确反馈，
-            // 不能静默。router 会把该异常转成 error toast。
-            getLogger().warn(`[lark-remote] no approval coordinator for runId=${runId.slice(0, 8)}`);
-            throw new Error('任务已结束，审批无法响应');
-        }
-        return fn(coordinator);
-    }
-    /**
-     * Handle an approval response from a card button click.
-     * Routes to the ApprovalCoordinator for the given run.
-     */
+    // 实现住在 approval-actions.ts（审计 #32）：这 7 个入口只碰
+    // approvalCoordinators 一张表，不碰其余 Bridge 状态。方法名保持 Bridge 的
+    // 公开 API 不变——router 的 APPROVAL_ACTION_SPECS 按名字分发。
+    /** 审批响应（卡片按钮）→ ApprovalCoordinator.submit。 */
     async handleApprovalRespond(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalRespond runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} decision=${opts.decision}`);
-        return this.withCoordinator(opts.runId, async (coordinator) => {
-            // Build ApprovalAction from the decision string
-            const action = decisionToApprovalAction(opts.decision);
-            await coordinator.submit(action, { requestId: opts.requestId, nonce: opts.nonce });
-        });
+        return this.approvalActions.handleApprovalRespond(opts);
     }
-    /**
-     * 计划审批修改意见（ExitPlanMode 输入框）：记录到 coordinator 并回流卡片。
-     * 「拒绝并附意见」/「批准并采纳修改」按钮复用该文本。
-     */
+    /** 计划审批修改意见（ExitPlanMode 输入框）→ coordinator.planFeedback。 */
     async handleApprovalPlanFeedback(opts) {
-        return this.withCoordinator(opts.runId, async (coordinator) => {
-            await coordinator.planFeedback({ text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce });
-        });
+        return this.approvalActions.handleApprovalPlanFeedback(opts);
     }
-    /**
-     * Handle a permission toggle from a card button click.
-     * Routes to the ApprovalCoordinator for the given run.
-     */
+    /** 权限条目勾选（卡片按钮）→ coordinator.togglePerm。 */
     async handleApprovalToggle(opts) {
-        const log = getLogger();
-        log.info(`[lark-remote] handleApprovalToggle runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} permId=${opts.permId}`);
-        return this.withCoordinator(opts.runId, async (coordinator) => {
-            // selected 由卡片根据当前渲染状态传回（取反），不再硬编码只授不撤。
-            const toggleAction = {
-                permId: opts.permId,
-                selected: opts.selected ?? true,
-            };
-            await coordinator.togglePerm(toggleAction, { requestId: opts.requestId });
-        });
+        return this.approvalActions.handleApprovalToggle(opts);
     }
-    /**
-     * Claude AskUserQuestion 选项点击（单选即时提交 / 多选切换勾选）。
-     * 路由到 ApprovalCoordinator.toggleAnswer。
-     */
+    /** AskUserQuestion 选项点击 → coordinator.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.approvalActions.handleApprovalAnswer(opts);
     }
-    /**
-     * Claude AskUserQuestion 多选问题的「提交答案」按钮。
-     * 路由到 ApprovalCoordinator.submitAnswers。
-     */
+    /** AskUserQuestion 多选「提交答案」→ coordinator.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.approvalActions.handleApprovalAnswerSubmit(opts);
     }
-    /**
-     * Claude AskUserQuestion 自定义答案（Other）：自由文本直接
-     * 作为该单选问题的答案提交。路由到 ApprovalCoordinator.answerCustom。
-     */
+    /** AskUserQuestion 自定义答案（Other）→ coordinator.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.approvalActions.handleApprovalAnswerCustom(opts);
     }
-    /**
-     * Codex AskUserQuestion 补充说明（user_note，2026-08-18 live 验证模型理解
-     * "user_note: <text>" 条目）：记录到 coordinator，随答案一起提交。
-     * 路由到 ApprovalCoordinator.answerNote。
-     */
+    /** AskUserQuestion 补充说明（user_note）→ coordinator.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.approvalActions.handleApprovalAnswerNote(opts);
     }
     /**
      * 记下一次「可压缩 run」：终态卡上的 Compact 按钮点击时据此反查
@@ -1967,14 +1800,14 @@ export class Bridge {
         });
     }
     /**
-     * §5.3: kimi 压缩在途检测——reader 鸭子实现 `readCompactionState` 时，若
+     * §5.3: kimi 压缩在途检测——reader 实现契约的 `readCompactionState` 时，若
      * wire 状态机判定当前有未终结的压缩（最后一次 begin 无 terminal 记录），
      * 直接回文本「已有一次 Compact 正在进行」并返回 true（调用方不开卡、不发
      * session/prompt）。codex/claude 等 reader 无此方法 → 返回 false，行为不变。
      */
     async rejectIfCompactionInFlight(sessionId, cwd, agentKind, ctx) {
         const reader = this.sessionReaderRegistry.get(agentKind);
-        if (!reader || !('readCompactionState' in reader))
+        if (!reader?.readCompactionState)
             return false;
         try {
             const state = reader.readCompactionState(sessionId, cwd);
@@ -2102,20 +1935,9 @@ export class Bridge {
             await cardSession.finish(terminal, {
                 resultSubtype: resultSubtype ?? 'error',
                 errorMsg: terminal === 'error' ? (resultError ?? '未收到压缩结果') : undefined,
-                contextLength: finalUsage?.contextLength,
-                contextLimit: finalUsage?.contextLimit,
-                compactPreContextLength: finalUsage?.compactPreContextLength,
-                compactCount: finalUsage?.compactCount,
-                cacheReadTokens: finalUsage?.cacheReadTokens,
-                cacheCreationTokens: finalUsage?.cacheCreationTokens,
-                totalTokens: finalUsage?.totalTokens,
-                inputTokens: finalUsage?.inputTokens,
-                outputTokens: finalUsage?.outputTokens,
-                cumulativeTotalTokens: finalUsage?.cumulativeTotalTokens,
-                cumulativeInputTokens: finalUsage?.cumulativeInputTokens,
-                cumulativeOutputTokens: finalUsage?.cumulativeOutputTokens,
-                cumulativeCacheReadTokens: finalUsage?.cumulativeCacheReadTokens,
-                cumulativeCacheCreationTokens: finalUsage?.cumulativeCacheCreationTokens,
+                // finalUsage 的字段形态就是 FinishMeta 的用量部分（同为 UsageSnapshot），
+                // 逐字段抄的那 14 行随单源一起去掉。
+                ...(finalUsage ?? {}),
             });
             log.info(`[lark-remote] streamCompact finished sessionId=${sessionId} sawResult=${sawResult} subtype=${resultSubtype ?? 'none'}`);
         }
@@ -2326,8 +2148,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)) {