lark-remote 0.5.14 → 0.5.15

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.15] - 2026-10-31
+
+### 修复
+
+- **`/stop` 落在「刚发消息、卡片还没建好」的窗口里不再空跑整轮**：此前卡片已经定格成「已中断」，但 agent 进程还没起来、没有可杀的进程，`run()` 入口又会把停止标记重置回去，于是整轮照常跑完并继续改动工作区。现在卡片一旦进入终态就直接收口，不再启动 agent
+- **中断归因不再串台**：显式 `/stop` 不再被上一次遗留的粘性「审批超时」状态盖掉；在审批卡上点「取消」现在会如实归因成用户取消并由卡片透传，终态卡不再显示「审批超时」（该文案此前实际不可达）
+- **目标状态读不到时不再谎报「已完成」**：终态复核探测不到目标状态时显式标记为「未知」；投影里缺少目标域按「明确没有目标」处理，不会把普通会话误标成「目标未确认」
+- **opencode / kimi 卡片「本 run」token 低报或虚高**：ACP 的用量通知只带上下文占用与花费、没有输入输出拆分，这两个 agent 的卡片只能从会话文件兜底读取。opencode 取的是「最后一条 assistant 消息」而一条消息等于一次模型请求，实测一条 25 次请求的 run 卡片显示 Input 543 / Output 1,250，真实消耗是 20,040 / 10,358（相邻两张卡的「累计」差值反而对得上）；kimi 更直接把整条会话的总量当本 run。现在两个 reader 都汇总**末个 turn** 的采样：opencode 以它自带的 turn 结束标记为边界（文件停在回合中间时就是当前回合），kimi 以 `turn.prompt` 为边界；`Context` 仍是末次请求的窗口水位，`累计` 仍是会话总量，口径不变；没有 turn 标记的旧数据沿用原语义
+- **opencode 冷启动失败不再引导用户重启服务**：daemon 刚重启时模型目录还在加载，`/api/model` 会连续几分钟返 503，旧退避（0.5/1.5/3 秒）整段落在这个窗口里、四次重试无一命中，失败文案又叫用户 `opencode service restart`——重启只会清掉已热状态、重新进入同一个窗口。现在退避改为 0.5/2/8/20/45 秒（连每次请求自身约 10 秒超时，覆盖约 2 分钟窗口），重试耗尽后丢弃该工作目录的缓存连接、下一轮重新拉起 agent server，不再复用一个没激活的子进程；文案改成「冷启动/模型目录加载期间的临时状态，等 1–2 分钟重发」
+- **`/compact` 的卡片流启动失败时补发静态终态卡**，不再只剩一条「Compact 已触发」加一个表情；兜底的完成通知卡标题跟随真实终态
+- **收尾报文更如实**：区分「没收到结果」与「结果没落到卡片上」，不再用同一句话盖掉两种原因
+
+### 变更
+
+- run 终态卡文案更如实：目标被阻断 / 已暂停分别显示「目标被阻断」「目标已暂停」，不再统一写「已完成」；目标读取失败时标题写「完成（目标未确认）」、摘要首行同步；`goal_continuing` 的原消息表情由 Done 改为 OnIt；run 是否活跃改用统一的终态判据收口
+
 ## [0.5.14] - 2026-10-28
 
 ### 修复

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

@@ -37,6 +37,15 @@ export declare class ApprovalCoordinator {
     private approvals;
     /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
     private submittedNonces;
+    /**
+     * 用户是否在审批卡上主动点了「取消」。
+     *
+     * run 的终态归因需要它：cancel 在真实协议里是「停止等待」，agent 可能继续
+     * 跑，turn 结束时只剩一个泛化的 interrupted。桥据此把终态写成
+     * approval_cancelled，与 /stop（user_stop）、审批超时（approval_timeout）
+     * 区分开。仅在 responder 成功后置位——提交失败仍可重试。
+     */
+    private userCancelled;
     private readonly approvalTimeoutMs;
     private readonly responder;
     private readonly interruptTurn;
@@ -139,6 +148,10 @@ export declare class ApprovalCoordinator {
      * approvals must not be resurrected or rewritten.
      */
     updateView(requestId: number | string, view: ApprovalView): void;
+    /**
+     * 用户是否在审批卡上主动点了「取消」（终态归因用；提交失败不置位）。
+     */
+    get cancelledByUser(): boolean;
     /**
      * Get the number of pending approvals.
      */

package/dist/bridge/approval-coordinator.js

@@ -16,6 +16,15 @@ export class ApprovalCoordinator {
     approvals = new Map();
     /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
     submittedNonces = new Map();
+    /**
+     * 用户是否在审批卡上主动点了「取消」。
+     *
+     * run 的终态归因需要它：cancel 在真实协议里是「停止等待」，agent 可能继续
+     * 跑，turn 结束时只剩一个泛化的 interrupted。桥据此把终态写成
+     * approval_cancelled，与 /stop（user_stop）、审批超时（approval_timeout）
+     * 区分开。仅在 responder 成功后置位——提交失败仍可重试。
+     */
+    userCancelled = false;
     approvalTimeoutMs;
     responder;
     interruptTurn;
@@ -131,6 +140,9 @@ export class ApprovalCoordinator {
         try {
             await this.responder(ctx.requestId, effectiveAction);
             tracked.state = 'resolved';
+            // 终态归因：用户主动取消才置位（accept/decline 都是"继续本轮"）。
+            if (effectiveAction.action === 'cancel')
+                this.userCancelled = true;
             // nonce 在 responder 成功后才消费：失败可原按钮重试，
             // 不会被自己的 nonce 去重挡掉（失败后已回滚 pending 并重新计时）。
             this.consumeNonce(ctx.requestId, ctx.nonce);
@@ -301,6 +313,12 @@ export class ApprovalCoordinator {
             return;
         tracked.view = view;
     }
+    /**
+     * 用户是否在审批卡上主动点了「取消」（终态归因用；提交失败不置位）。
+     */
+    get cancelledByUser() {
+        return this.userCancelled;
+    }
     /**
      * Get the number of pending approvals.
      */

package/dist/bridge/index.js

@@ -50,10 +50,36 @@ const TERMINAL_REACTION_EMOJI = {
     error: 'ERROR',
     idle_timeout: 'Alarm',
     interrupted: 'SHHH',
+    // 本轮结束但目标继续：任务还没完，不能打 ✓（Done）。
+    goal_continuing: 'OnIt',
 };
 function terminalReactionEmoji(terminal) {
     return TERMINAL_REACTION_EMOJI[terminal] ?? 'Done';
 }
+/**
+ * 完成通知卡的标题 / 配色 / 结果行。
+ *
+ * 这张卡只在流式卡失败（settle==='unsent'）时补发，但终态必须如实反映：
+ * 写死「✅ 会话已完成」会把出错/中断的 run 报成成功。
+ */
+function completionNotificationPresentation(terminal) {
+    switch (terminal) {
+        case 'error':
+            return { title: '⚠️ 会话出错', template: 'red' };
+        case 'interrupted':
+            return { title: '⏹ 会话已中断', template: 'grey' };
+        case 'idle_timeout':
+            return { title: '⏱ 会话已超时', template: 'orange' };
+        case 'goal_continuing':
+            return { title: '⏳ 本轮结束，目标继续', template: 'orange' };
+        case 'finalizing':
+            return { title: '⏳ 会话仍在收尾', template: 'orange' };
+        case 'running':
+            return { title: '🔴 会话运行中', template: 'blue' };
+        case 'done':
+            return { title: '✅ 会话已完成', template: 'green', result: 'completed' };
+    }
+}
 /**
  * 单点化：`'runCompact' in runner` 鸭子探测
  * codex app-server + kimi/opencode ACP runner 满足。
@@ -1263,7 +1289,7 @@ export class Bridge {
      * 4) 已终态且未收到 result（如 spawn 失败后 interrupted）→ 无 usage 可补，跳过
      */
     async finishRunAfterStream(opts) {
-        const { cardSession, usage, sawResult, pendingPreInitTerminal, agentKind, runId } = opts;
+        const { cardSession, usage, sawResult, sawAnyResult, pendingPreInitTerminal, agentKind, runId, } = opts;
         const finalState = cardSession.currentState;
         if (finalState.terminal === 'finalizing') {
             // 三态终态映射（2026-08-14）：interrupted（审批超时/取消、/stop）是独立
@@ -1280,9 +1306,14 @@ export class Bridge {
                     : goalContinues
                         ? 'goal_continuing'
                         : 'done';
+            // 中断归因：用户主动取消审批（cancel）优先于"未归类"。用户 /stop 的
+            // 路径先置了终态（interrupted + user_stop），不会走到这里。
+            const approvalCancelled = terminal === 'interrupted' &&
+                this.approvalCoordinators.get(runId)?.cancelledByUser === true;
             await cardSession.finish(terminal, {
                 resultSubtype: subtype,
                 errorMsg: finalState.errorMsg,
+                ...(approvalCancelled ? { interruptedReason: 'approval_cancelled' } : {}),
                 ...usage.meta(),
             });
             return;
@@ -1300,7 +1331,13 @@ export class Bridge {
             else {
                 await cardSession.finish('error', {
                     ...usage.meta(),
-                    errorMsg: agentDisplayName(agentKind) + ' 输出流已结束，但未收到 result 事件',
+                    // sawAnyResult=true 说明 result 收到了、只是没能落到卡片（reducer 的
+                    // sessionId 守卫或 pre-init 守卫挡下）。报文不能再说"未收到 result
+                    // 事件"，否则排障会去查输出流而不是查守卫。
+                    errorMsg: agentDisplayName(agentKind) +
+                        (sawAnyResult
+                            ? ' 输出流已结束，但本轮结果未能落到卡片上'
+                            : ' 输出流已结束，但未收到 result 事件'),
                 });
             }
             return;
@@ -1322,6 +1359,8 @@ export class Bridge {
         // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
         let watchdog = null;
         let sawResult = false;
+        /** 收到过任何 result（含被守卫丢弃/未进卡片的）：收尾报文据此措辞。 */
+        let sawAnyResult = false;
         // A runner can fail before emitting its synthetic system/init (e.g. DSH
         // session/create -> 401). The pre-init guard below drops that result to
         // protect Claude resume replay, but if the stream ends without ever seeing
@@ -1345,9 +1384,14 @@ export class Bridge {
                 // Card stream failed - continue with static fallback below, but ensure
                 // we don't silently fail if the fallback also fails (covered in catch below).
             }
-            if (cardSession.currentState.terminal !== 'running') {
-                // Card session did not enter running state - still try to send static fallback
-                getLogger().info(`[lark-remote] cardSession not running, using static fallback`);
+            // /stop（或队列「立即执行」的中断）可能落在建卡窗口内：卡片已定格为
+            // 终态，但 runner 还没开始跑，runner.stop() 也没有进程可杀——spawn 型
+            // 与连接型 runner 的 stop() 在 run() 之前都是空操作，且 run() 入口会
+            // 重置停止标记。必须在这里收口，否则用户看到「已中断」，agent 仍会把
+            // 这一轮跑完并改写工作区。finalizeRun 仍会照常收尾（settle / reaction）。
+            if (isRunTerminal(cardSession.currentState.terminal)) {
+                getLogger().info(`[lark-remote] card terminal before run start, skip runner runId=${runId} terminal=${cardSession.currentState.terminal}`);
+                return;
             }
             // 单 interval 看门狗。事件到来时只刷新时间戳（无 timer 操作）；
             // interval 周期检查静默时长，超时才 finish('idle_timeout') + stop()。
@@ -1418,6 +1462,7 @@ export class Bridge {
                         pendingPreInitTerminal ??= outcome.preInitTerminal;
                     if (outcome.sawResult)
                         sawResult = true;
+                    sawAnyResult = true;
                     // 陈旧 result 不进卡片：run-state reducer 本来也会因 sessionId 未定而
                     // 跳过，在 bridge 层就拦掉可以省下一次无谓的 push + render。
                     if (outcome.dropFromCard) {
@@ -1464,6 +1509,7 @@ export class Bridge {
                 cardSession,
                 usage,
                 sawResult,
+                sawAnyResult,
                 pendingPreInitTerminal,
                 agentKind,
                 runId,
@@ -1561,7 +1607,7 @@ export class Bridge {
             // but NOT when streaming succeeded (card already shows completion).
             const sessionId = cardSession.currentState.sessionId;
             if (sessionId && runCardSent) {
-                await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind);
+                await this.sendCompletionNotificationCard(sessionId, cwd, ctx, activeRun.agentKind, cardSession.currentState.terminal);
             }
             if (finalRender.finalAnswerStatus === 'overflow' && finalRender.finalAnswerText) {
                 await this.sendFinalAnswerOverflow(finalRender.finalAnswerText, ctx);
@@ -1609,7 +1655,8 @@ export class Bridge {
      * It's sent as a new message (not updating the run card) so users can easily
      * find and return to this session without scrolling up.
      */
-    async sendCompletionNotificationCard(sessionId, cwd, ctx, agentKind = this.config.defaultAgent) {
+    async sendCompletionNotificationCard(sessionId, cwd, ctx, agentKind = this.config.defaultAgent, terminal = 'done') {
+        const presentation = completionNotificationPresentation(terminal);
         try {
             // cap the events read for the notification card — without
             // maxEvents claude returns every event after the last user message and
@@ -1626,10 +1673,10 @@ export class Bridge {
             }, {
                 agentKind,
                 headerText: `📂 \`${cwd}\`\n会话: **${sessionId}**`,
-                title: '✅ 会话已完成',
-                usageResult: 'completed',
+                title: presentation.title,
+                ...(presentation.result ? { usageResult: presentation.result } : {}),
                 actions: [resumeUseButton(sessionId, agentKind)],
-                headerTemplate: 'green',
+                headerTemplate: presentation.template,
             });
             // send through sendResult so enforceCardBudget guards the card
             // (previously sent via connector directly, bypassing the budget — long
@@ -1861,14 +1908,15 @@ export class Bridge {
         }
         await this.sendResult({ text: '🗜 Compact 已触发，正在压缩会话…' }, ctx);
         const compactRunId = randomUUID();
+        // 渲染选项同时用于流式卡与「卡片流没建起来」时的静态兜底卡——两者必须
+        // 同门控，否则兜底卡会渲染出与本次 run 不一致的按钮。
+        const renderOptions = { agentKind };
         const cardSession = new RunCardSession({
             connector: this.connector,
             chatId: ctx.chatId,
             replyTo: ctx.messageId,
             runId: compactRunId,
-            renderOptions: {
-                agentKind,
-            },
+            renderOptions,
         });
         // 压缩与普通 run 共用同一套生命周期——注册进 activeRuns（/stop 有对象可停、
         // /active 看得见）、挂 §9.12 空闲看门狗、终态后补 reaction。缺任何一环，卡住的
@@ -1955,6 +2003,15 @@ export class Bridge {
         }
         finally {
             watchdog?.stop();
+            // 与 run 路径同口径的降级：卡片流没建起来（start 失败 / stream 未收尾）时，
+            // 终态只存在于内存里。settle() 释放 producer 并等 stream 收尾；'unsent'
+            // 表示用户手里没有卡，必须补一张静态终态卡，否则只剩「Compact 已触发」
+            // 和一条 reaction，用户既不知道失败也不知道原因。
+            const settled = await cardSession.settle();
+            if (settled === 'unsent') {
+                const finalRender = renderRunCardDetailed(cardSession.currentState, renderOptions);
+                await this.sendResult({ card: finalRender.card }, ctx);
+            }
             // 只摘自己的槽位：/stop 可能已删掉本条并让排队的下一条占住同一 cwd。
             if (this.activeRuns.get(cwd) === activeRun) {
                 this.activeRuns.delete(cwd);

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

@@ -28,5 +28,10 @@ export declare class RunUsageCollector {
     observeResult(event: ResultEvent): void;
     finalize(finalUsage: FinalUsageSnapshot | undefined, authority: UsageAuthority | undefined): void;
     meta(): UsageSnapshot;
+    /**
+     * 收尾探针。input/output 必须在这里出现：卡片"本 run"的这两个数来自
+     * `resolveFinalUsage`（ACP 的 live 层只有 context 占用、没有 input/output），
+     * 不带它们时日志无法区分"本 run 合计"与"末次请求"。
+     */
     logSummary(runId: string): string;
 }

package/dist/bridge/run-usage.js

@@ -79,9 +79,14 @@ export class RunUsageCollector {
     meta() {
         return this.resolved;
     }
+    /**
+     * 收尾探针。input/output 必须在这里出现：卡片"本 run"的这两个数来自
+     * `resolveFinalUsage`（ACP 的 live 层只有 context 占用、没有 input/output），
+     * 不带它们时日志无法区分"本 run 合计"与"末次请求"。
+     */
     logSummary(runId) {
         const meta = this.meta();
-        return `[lark-remote] final usage runId=${runId} contextLength=${meta.contextLength} contextLimit=${meta.contextLimit ?? 'undefined'} compactCount=${meta.compactCount ?? 'undefined'} cacheRead=${meta.cacheReadTokens ?? 'undefined'} cacheCreate=${meta.cacheCreationTokens ?? 'undefined'}`;
+        return `[lark-remote] final usage runId=${runId} contextLength=${meta.contextLength} contextLimit=${meta.contextLimit ?? 'undefined'} compactCount=${meta.compactCount ?? 'undefined'} input=${meta.inputTokens ?? 'undefined'} output=${meta.outputTokens ?? 'undefined'} cacheRead=${meta.cacheReadTokens ?? 'undefined'} cacheCreate=${meta.cacheCreationTokens ?? 'undefined'} total=${meta.totalTokens ?? 'undefined'}`;
     }
 }
 //# sourceMappingURL=run-usage.js.map

package/dist/card/run-renderer.js

@@ -1137,13 +1137,12 @@ function buildSummaryContent(state, options = {}) {
         }
     }
     else if (state.terminal === 'interrupted') {
-        // 审批超时（approval_expired 已标记）是「无人响应被自动取消」，不是用户
-        // 主动终止；如实展示原因，避免用户误判为 Agent 出错或自己操作过。
-        // 顶层 approvalExpired 优先：approval_resolved 会移除审批条目，但标记
-        // 必须活到终态渲染（2026-08-15 事故回归）。
+        // 中断来源三元：审批超时 / 用户取消审批 / 用户主动终止。
+        // 显式原因优先：approvalExpired 是粘性标记（cancel 语义下 agent 可能继续跑），
+        // 用户随后主动 /stop 时若仍按过期渲染，就把「我自己停的」误报成自动取消。
         const expiredApproval = state.interruptedReason === 'approval_timeout' ||
-            state.approvalExpired === true ||
-            (state.approvals ?? []).some((a) => a.expired);
+            (state.interruptedReason === undefined &&
+                (state.approvalExpired === true || (state.approvals ?? []).some((a) => a.expired)));
         elements.push(markdownDiv(expiredApproval
             ? '⏰ **审批超时未响应，已自动取消**'
             : state.interruptedReason === 'approval_cancelled'
@@ -1165,6 +1164,9 @@ function buildSummaryContent(state, options = {}) {
             : state.operationKind === 'compaction'
                 ? '\n\n🗜 Compact 完成'
                 : '\n\n（未返回内容）';
+        // goal 本 run 读不到（known=false）时不能写「已完成」：这是 GoalStateEvent
+        // 契约里明令禁止的推断（读不到 ≠ 没有目标）。run 本身成功，只是目标维度未知。
+        const goalUnknown = state.terminal === 'done' && state.goalKnown === false;
         // RunState 的用量字段就是 formatUsageStats 的入参形态（同为
         // `UsageSnapshot`）——原先这里逐字段抄了 17 行，加一个字段要同时改
         // RunState、FinishMeta 和这张清单（§9.21）。
@@ -1174,7 +1176,9 @@ function buildSummaryContent(state, options = {}) {
             // 本轮结束但目标继续：不能报"已完成"，也不能说"出错"。
             ...(state.terminal === 'goal_continuing'
                 ? { completedLabel: '⏳ 本轮结束 · 目标仍在继续' }
-                : {}),
+                : goalUnknown
+                    ? { completedLabel: '✅ 本轮完成 · 目标状态未确认' }
+                    : {}),
         });
         elements.push(markdownDiv(usageStatsStr + empty));
         // 后台任务：跨 turn 生命周期，必须显式告知并可逐个停止。
@@ -1302,7 +1306,17 @@ function headerTitle(state, options = {}) {
     if (state.terminal === 'goal_continuing')
         return `⏳ ${agent} · 本轮结束（目标继续）`;
     if (state.terminal === 'done') {
-        return state.goal?.phase === 'complete' ? `✅ ${agent} · 目标已完成` : `✅ ${agent} · 已完成`;
+        // goal 维度优先于「完成」：blocked/paused 不是任务做完了，complete 才是；
+        // 读不到（goalKnown=false）时也不能替宿主宣布完成。
+        if (state.goal?.phase === 'complete')
+            return `✅ ${agent} · 目标已完成`;
+        if (state.goal?.phase === 'blocked')
+            return `⛔ ${agent} · 目标被阻断`;
+        if (state.goal?.phase === 'paused')
+            return `⏸ ${agent} · 目标已暂停`;
+        if (state.goalKnown === false)
+            return `✅ ${agent} · 完成（目标未确认）`;
+        return `✅ ${agent} · 已完成`;
     }
     if (state.terminal === 'error')
         return `⚠️ ${agent} · 出错`;

package/dist/router/index.js

@@ -12,6 +12,7 @@ import { AGENT_KINDS, resolveAgentKind } from '../agent-kinds.js';
 import { getLogger } from '../logger/index.js';
 import { stripPlaceholders } from '../inbound/placeholder.js';
 import { clampInt } from '../common/clamp.js';
+import { isRunTerminal } from '../card/run-state.js';
 import { activeRunUsage } from './active-run-usage.js';
 import { markdownDiv, buildSessionHistoryCard, paginationBar, parseJumpOffset, SEARCH_INPUT_NAME, PAGE_JUMP_INVALID_HINT, } from '../card/card-helpers.js';
 import { MAX_FILE_UPLOAD_SIZE } from '../connector/file-limits.js';
@@ -2496,14 +2497,10 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         }
         const { events, usage, aiTitle, recap, displayTitle } = reader.readSessionContent(sessionId, cwd, { maxEvents: opts?.maxEvents });
         const activeRun = this.bridge.getActiveRunFor(cwd);
-        // 只检查内存中的 activeRun 状态
-        // 只有当 activeRun 存在且不是终态时，才认为任务仍在进行中
+        // 只检查内存中的 activeRun 状态：存在且未收尾才算进行中。
+        // 终态集合取 run-state 的单源判据（新增终态时不会漏掉这一处）。
         const activeRunning = activeRun !== undefined &&
-            activeRun.terminal !== 'done' &&
-            activeRun.terminal !== 'error' &&
-            activeRun.terminal !== 'interrupted' &&
-            activeRun.terminal !== 'idle_timeout' &&
-            activeRun.terminal !== 'goal_continuing' &&
+            !isRunTerminal(activeRun.terminal) &&
             activeRun.sessionId === sessionId;
         const activeUsage = activeRunUsage(activeRun);
         return {

package/dist/runner/common/acp/base-acp-runner.d.ts

@@ -73,6 +73,22 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
      */
     protected abstract onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: TTranslator, sessionId: string, opts: SpawnOptions, baselineTotalCount: number): void;
     private withSessionSetupRetry;
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    private setupSessionWithRetry;
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    private discardConnection;
     protected currentSessionId(): string | null;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;

package/dist/runner/common/acp/base-acp-runner.js

@@ -58,6 +58,40 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             }
         }
     }
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    async setupSessionWithRetry(cwd, fn) {
+        try {
+            return await this.withSessionSetupRetry(fn);
+        }
+        catch (err) {
+            if (this.isRetryableSessionSetupError(err)) {
+                await this.discardConnection(cwd);
+            }
+            throw err;
+        }
+    }
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    async discardConnection(cwd) {
+        try {
+            await this.connectionManager.release(cwd);
+            getLogger().warn(`[${this.logTag}] dropped cached connection after session setup failure cwd=${cwd}`);
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] failed to drop cached connection cwd=${cwd}: ${err.message}`);
+        }
+    }
     currentSessionId() {
         return this.activeSessionId;
     }
@@ -203,13 +237,13 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
                 sessionId: opts.sessionId,
                 cwd: opts.cwd,
             };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             sessionId = opts.sessionId;
         }
         else {
             const newParams = { cwd: opts.cwd, mcpServers: [] };
-            const newResult = await this.withSessionSetupRetry(() => client.request('session/new', newParams));
+            const newResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/new', newParams));
             this.onSessionEstablished(newResult);
             sessionId = newResult.sessionId;
         }
@@ -286,7 +320,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             // memory. On a reused connection the session is already loaded —
             // resume is idempotent and harmless.
             const resumeParams = { sessionId, cwd: opts.cwd };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             const translator = this.createTranslator();
             translator.setOperationKind('compact');

package/dist/runner/dsh/client.js

@@ -430,6 +430,11 @@ export class DshClient {
         // 拿不到投影 = 宿主没这个会话的投影，不等于"没有 goal"。
         if (!snapshot)
             return { known: false, goal: null };
+        // 投影快照存在但没有 goal 域 = 宿主明确没有目标（未用过 goal 的会话就是这样）。
+        // 不能把缺失当成"读不懂"：goalFromProjection(undefined) 也返回 undefined，
+        // 那会把每次普通会话都误报成「目标状态未确认」。
+        if (!('goal' in snapshot.values))
+            return { known: true, goal: null };
         const parsed = goalFromProjection(snapshot.values.goal);
         if (parsed === undefined)
             return { known: false, goal: null };

package/dist/runner/dsh/runner.js

@@ -482,10 +482,17 @@ export class DshRunner {
                 timeoutMs: GOAL_PROBE_TIMEOUT_MS,
             });
             const lastGoal = seedGoal.known ? seedGoal.goal : undefined;
-            // 只有确实存在 goal 才产事件：没有 goal 的会话保持事件序列不变（少一次
-            // 渲染，也不让"读不到"变成一张多出来的卡片事件）。
-            if (seedGoal.known && seedGoal.goal)
-                yield goalStateEvent(seedGoal.goal, true);
+            if (seedGoal.known) {
+                // 只有确实存在 goal 才产事件：没有 goal 的会话保持事件序列不变（少一次
+                // 渲染，也不让"读不到"变成一张多出来的卡片事件）。
+                if (seedGoal.goal)
+                    yield goalStateEvent(seedGoal.goal, true);
+            }
+            else {
+                // 读不到 ≠ 没有目标。必须显式把 unknown 交给卡片，否则收尾只能按
+                // 「没有 goal」写成「已完成」——正是 GoalStateEvent 契约禁止的推断。
+                yield goalStateEvent(null, false);
+            }
             try {
                 const submitted = await this.submitPrompt(sessionId, opts.cwd, message, abort.signal);
                 promptRequestId = submitted.promptRequestId;
@@ -497,7 +504,7 @@ export class DshRunner {
                     return;
                 }
                 try {
-                    for await (const ev of this.runTurn(sessionId, opts.cwd, submitted.prePromptSeq, promptRequestId, abort, { last: lastGoal })) {
+                    for await (const ev of this.runTurn(sessionId, opts.cwd, submitted.prePromptSeq, promptRequestId, abort, { last: lastGoal, known: seedGoal.known })) {
                         yield ev;
                         if (ev.type === 'result') {
                             terminalEmitted = true;
@@ -734,7 +741,16 @@ export class DshRunner {
                                 signal,
                                 timeoutMs: GOAL_PROBE_TIMEOUT_MS,
                             });
-                            if (finalGoal.known && !sameGoal(finalGoal.goal, goal.last)) {
+                            if (!finalGoal.known) {
+                                // 收尾读不到：seed 已报过 unknown 就不重复发，否则把状态降级
+                                // 交给卡片（卡片据此不再宣布完成）。
+                                if (goal.known) {
+                                    goal.known = false;
+                                    yield goalStateEvent(null, false);
+                                }
+                            }
+                            else if (!goal.known || !sameGoal(finalGoal.goal, goal.last)) {
+                                goal.known = true;
                                 goal.last = finalGoal.goal;
                                 yield goalStateEvent(finalGoal.goal, true);
                             }

package/dist/runner/opencode/acp/runner.d.ts

@@ -91,9 +91,20 @@ export declare class OpencodeAcpRunner extends BaseAcpRunner<OpencodeAcpTranslat
      * starting or still activating location plugins when the first session is
      * created; both surface as a JSON-RPC internal error. Retry a few times
      * before failing the turn.
+     *
+     * 单次 attempt 自身还要等 opencode 侧超时（~10s），所以真实窗口 ≈ Σdelay +
+     * 每次的等待。2026-10-30 现场：daemon 刚重启，`/api/model` 因模型目录拉取
+     * 超时连续 503 约 7 分钟，旧退避 0.5/1.5/3s（合计 ~45s）全落在这段里，4 次
+     * 重试无一成功。现在铺到 ~75s + 每次超时 ≈ 2 分钟，覆盖一次冷启动窗口，
+     * 又不至于让真故障的用户干等太久。
      */
     protected sessionSetupRetryDelaysMs(): number[];
     protected isRetryableSessionSetupError(err: unknown): boolean;
+    /**
+     * 用户可见文案。这里刻意**不**建议 `opencode service restart`：卡住的是
+     * opencode 的模型目录/位置服务冷启动，重启只会清掉刚热好的状态、重新回到
+     * 同一个窗口（2026-10-30 现场：照提示重启两次仍然失败，等几分钟自己好了）。
+     */
     protected enrichSessionSetupError(err: unknown): Error;
     getStatusInfo(): AgentStatusInfo;
     /**

package/dist/runner/opencode/acp/runner.js

@@ -173,20 +173,31 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
      * starting or still activating location plugins when the first session is
      * created; both surface as a JSON-RPC internal error. Retry a few times
      * before failing the turn.
+     *
+     * 单次 attempt 自身还要等 opencode 侧超时（~10s），所以真实窗口 ≈ Σdelay +
+     * 每次的等待。2026-10-30 现场：daemon 刚重启，`/api/model` 因模型目录拉取
+     * 超时连续 503 约 7 分钟，旧退避 0.5/1.5/3s（合计 ~45s）全落在这段里，4 次
+     * 重试无一成功。现在铺到 ~75s + 每次超时 ≈ 2 分钟，覆盖一次冷启动窗口，
+     * 又不至于让真故障的用户干等太久。
      */
     sessionSetupRetryDelaysMs() {
-        return [500, 1500, 3000];
+        return [500, 2000, 8000, 20000, 45000];
     }
     isRetryableSessionSetupError(err) {
         const message = err instanceof Error ? err.message : String(err);
         return /ServiceUnavailableError|Location plugins did not finish activating|Internal service failure|ECONNREFUSED|fetch failed/i.test(message);
     }
+    /**
+     * 用户可见文案。这里刻意**不**建议 `opencode service restart`：卡住的是
+     * opencode 的模型目录/位置服务冷启动，重启只会清掉刚热好的状态、重新回到
+     * 同一个窗口（2026-10-30 现场：照提示重启两次仍然失败，等几分钟自己好了）。
+     */
     enrichSessionSetupError(err) {
         if (!this.isRetryableSessionSetupError(err)) {
             return super.enrichSessionSetupError(err);
         }
         const message = err instanceof Error ? err.message : String(err);
-        return new Error(`opencode 2.0 后台服务不可用（${message}）。请在终端执行 \`opencode service restart\` 后重试。`, { cause: err });
+        return new Error(`opencode 后台服务尚未就绪（${message}）。这是 opencode 冷启动 / 模型目录加载期间的临时状态：等 1–2 分钟重发即可，重启服务只会重新进入同一窗口。`, { cause: err });
     }
     getStatusInfo() {
         return {

package/dist/session/kimi/sessions.js

@@ -347,7 +347,15 @@ export class KimiSessionReader {
             // is an independent window). Aggregation covers the whole wire.jsonl
             // and is independent of the maxEvents display slice
             // (usage = the session's overall token cost).
-            const accumulateUsage = (u, updateContextLength) => {
+            //
+            // 本 run 的 flow 字段是**末个 turn**（最后一个 turn.prompt 之后）的记录之和：
+            // kimi 每次模型调用写一条 usage.record，带工具往返的 turn 会有多条。只取
+            // 末条会低报，取会话总量（旧实现）又会把历史所有 run 的消耗算进这一轮。
+            // 子 agent 的 wire 没有 turn 标记，只能进会话累计（无法归属到某一轮）；
+            // 整份 wire 都没有 turn.prompt（旧数据）时沿用「整份文件 = 一个 turn」。
+            let turnAcc = null;
+            let lastMainUsage;
+            const accumulateUsage = (u, scope) => {
                 hasUsageRecord = true;
                 // Malformed records (missing usage object or missing fields) must
                 // not poison the accumulators with NaN: count missing fields as 0.
@@ -355,18 +363,21 @@ export class KimiSessionReader {
                 const output = u?.output ?? 0;
                 const inputCacheRead = u?.inputCacheRead ?? 0;
                 const inputCacheCreation = u?.inputCacheCreation ?? 0;
-                acc.add({
+                const record = {
                     input: inputOther,
                     output,
                     cacheRead: inputCacheRead,
                     cacheCreation: inputCacheCreation,
-                });
-                if (updateContextLength) {
-                    // unified contract (§9.21): input + output + cacheRead + cacheCreation.
-                    // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
-                    // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
-                    mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
-                }
+                };
+                acc.add(record);
+                if (scope !== 'main')
+                    return;
+                lastMainUsage = record;
+                turnAcc?.add(record);
+                // unified contract (§9.21): input + output + cacheRead + cacheCreation.
+                // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
+                // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
+                mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
             };
             for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
                 const line = lines[lineIndex];
@@ -374,7 +385,7 @@ export class KimiSessionReader {
                     const entry = JSON.parse(line);
                     // Extract usage from usage.record.
                     if (isUsageRecord(entry)) {
-                        accumulateUsage(entry.usage, true);
+                        accumulateUsage(entry.usage, 'main');
                         continue;
                     }
                     // §6.3: Count compaction events and track pre-compact context length.
@@ -401,6 +412,8 @@ export class KimiSessionReader {
                     // prompt), which is the correct catch-up title.
                     // Extract display title from turn.prompt
                     if (isTurnPrompt(entry)) {
+                        // turn.prompt 是 turn 的起点：本 turn 的 flow 从这里重新累计。
+                        turnAcc = new UsageAccumulator();
                         if (entry.input && entry.input.length > 0) {
                             displayTitle = entry.input[0].text;
                         }
@@ -470,7 +483,7 @@ export class KimiSessionReader {
                         try {
                             const subEntry = JSON.parse(subLine);
                             if (isUsageRecord(subEntry)) {
-                                accumulateUsage(subEntry.usage, false);
+                                accumulateUsage(subEntry.usage, 'subagent');
                             }
                         }
                         catch {
@@ -482,18 +495,23 @@ export class KimiSessionReader {
             catch {
                 // agents dir unreadable — fall back to main-only usage
             }
-            // Build the final AgentSessionUsage from accumulator totals + main contextLength.
+            // Build the final AgentSessionUsage from the last turn's flow + session
+            // cumulative + main contextLength.
             const t = acc.totals;
+            // 有 turn.prompt 时本 run = 末个 turn 的 flow（末 turn 还没有记录时退回
+            // 末条主 wire 记录）；整份 wire 都没有 turn.prompt（旧数据/截断）时无从
+            // 分段，沿用「整份文件 = 一个 turn」的旧口径（含子 agent wire）。
+            const flow = turnAcc ? (turnAcc.count > 0 ? turnAcc.totals : (lastMainUsage ?? t)) : t;
             // Kimi semantics: preserve 0 values (not undefined) for cache fields to match original
             const totalUsage = {
-                inputTokens: t.input,
-                outputTokens: t.output,
+                inputTokens: flow.input,
+                outputTokens: flow.output,
                 contextLength: mainContextLength,
-                cacheReadTokens: t.cacheRead > 0 ? t.cacheRead : 0,
-                cacheCreationTokens: t.cacheCreation > 0 ? t.cacheCreation : 0,
-                totalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
-                // Cumulative (session-wide): kimi sums all usage.records; mirrors
-                // inputTokens/outputTokens which are already session totals.
+                cacheReadTokens: flow.cacheRead > 0 ? flow.cacheRead : 0,
+                cacheCreationTokens: flow.cacheCreation > 0 ? flow.cacheCreation : 0,
+                totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheCreation,
+                // Cumulative (session-wide): sums every usage.record across all turns
+                // (subagent wires included) — the "累计" line, never the per-run value.
                 ...cumulativeUsageFields(t),
                 // §6.3: compaction stats from wire.jsonl
                 compactCount,

package/dist/session/opencode/sessions.js

@@ -81,6 +81,55 @@ function v2ToolOutput(state) {
         return state.result;
     return undefined;
 }
+/**
+ * v2 assistant 消息 → 用量采样。total 为 0 的退化消息（模型在 reasoning 中被
+ * 截断）不算采样：信任它会抹掉整轮真实用量。
+ */
+function usageSample(msg) {
+    if (msg?.type !== 'assistant' || !msg.tokens)
+        return undefined;
+    const input = msg.tokens.input ?? 0;
+    const output = msg.tokens.output ?? 0;
+    const cacheRead = msg.tokens.cache?.read ?? 0;
+    const cacheCreation = msg.tokens.cache?.write ?? 0;
+    const total = input + output + (msg.tokens.reasoning ?? 0) + cacheRead + cacheCreation;
+    if (total === 0)
+        return undefined;
+    return { input, output, cacheRead, cacheCreation, total };
+}
+/**
+ * 末个 turn 的起点（其后才是"本 run"的采样）。
+ *
+ * `idle` 是 opencode 自带的 turn 结束标记（真实 export 里每个 idle 前一条是
+ * assistant、后一条是 user/synthetic/system）。取「最后一个其后仍有采样的 idle」：
+ * - 文件以 idle 收尾（/resume 常态）时，末个 idle 之后没有采样，边界自动落到
+ *   再上一个 idle，即最后那个完整 turn；
+ * - 文件停在 turn 中间（run 收尾读盘）时，末个 idle 就是当前 turn 的起点。
+ *
+ * 老数据没有 idle：退回最后一个 turn 起跑标记（user/synthetic/system），与
+ * codex/dsh「无 turn 标记则退回末条采样」的既有兜底一致。
+ */
+function lastTurnStartIndex(messages) {
+    let lastSample = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (usageSample(messages[i]) !== undefined) {
+            lastSample = i;
+            break;
+        }
+    }
+    if (lastSample < 0)
+        return -1;
+    for (let i = lastSample - 1; i >= 0; i--) {
+        if (messages[i]?.type === 'idle')
+            return i;
+    }
+    for (let i = lastSample - 1; i >= 0; i--) {
+        const type = messages[i]?.type;
+        if (type === 'user' || type === 'synthetic' || type === 'system')
+            return i;
+    }
+    return -1;
+}
 /**
  * 把会话级累计 token 落到 usage 上（v1 export 与 v2 export 两条读取路径共用）。
  *
@@ -196,6 +245,8 @@ export class OpencodeSessionReader {
             }
             const events = [];
             let usage;
+            /** 本 turn 的 flow 累计：末条 user 消息之后的全部 step-finish。 */
+            let turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
             let aiTitle;
             let displayTitle;
             // Find the last user message position (for catch-up tail).
@@ -262,28 +313,34 @@ export class OpencodeSessionReader {
                         }
                     }
                 }
-                // Track usage from step-finish parts
+                // Track usage from step-finish parts. v1 没有 idle 标记，turn 边界就是
+                // 上面那段"最后一条 user 消息"；同一 turn 可能有多个 step-finish
+                // （每次模型请求一条），flow 要全加起来，只留末条会把多步 run 低报。
                 for (const part of msg.parts) {
                     if (part.type === 'step-finish' && part.tokens) {
-                        // Use the last NON-EMPTY step-finish tokens. A long autonomous run
-                        // can end on a degenerate step (model cut off mid-reasoning) whose
-                        // step-finish reports all-zero tokens; trusting it would wipe out
-                        // the run's real per-turn usage (contextLength/input/output/total
-                        // all render 0). Skip zero-total steps so per-turn usage reflects
-                        // the last step that actually consumed tokens.
+                        // Skip zero-total steps（模型在 reasoning 中被截断）——它们没有消耗，
+                        // 也不该把本次请求当成一条真实采样。
                         // ccusage-aligned: cache.write -> cacheCreationTokens.
                         // contextLength = input + output + cacheRead + cacheCreation —
                         // the unified context-window occupancy contract across all readers
                         // (§9.21：末轮 output 已进入历史、下一 prompt 全量携带，与 compact
                         // postTokens 水位同语义).
                         if ((part.tokens.total ?? 0) !== 0) {
+                            const input = part.tokens.input ?? 0;
+                            const output = part.tokens.output ?? 0;
+                            const cacheRead = part.tokens.cache?.read ?? 0;
+                            const cacheWrite = part.tokens.cache?.write ?? 0;
+                            turn = {
+                                input: turn.input + input,
+                                output: turn.output + output,
+                                cacheRead: turn.cacheRead + cacheRead,
+                                cacheCreation: turn.cacheCreation + cacheWrite,
+                                total: turn.total + part.tokens.total,
+                            };
                             usage = {
-                                inputTokens: part.tokens.input,
-                                outputTokens: part.tokens.output,
-                                contextLength: (part.tokens.input ?? 0) +
-                                    (part.tokens.output ?? 0) +
-                                    (part.tokens.cache?.read ?? 0) +
-                                    (part.tokens.cache?.write ?? 0),
+                                inputTokens: input,
+                                outputTokens: output,
+                                contextLength: input + output + cacheRead + cacheWrite,
                                 cacheReadTokens: part.tokens.cache?.read,
                                 cacheCreationTokens: part.tokens.cache?.write,
                                 totalTokens: part.tokens.total,
@@ -292,6 +349,14 @@ export class OpencodeSessionReader {
                     }
                 }
             }
+            // flow 覆盖末条采样值，contextLength 保留末条（水位不求和）。
+            if (usage) {
+                usage.inputTokens = turn.input;
+                usage.outputTokens = turn.output;
+                usage.cacheReadTokens = turn.cacheRead;
+                usage.cacheCreationTokens = turn.cacheCreation;
+                usage.totalTokens = turn.total;
+            }
             // Cumulative (session-wide): sum input/output/total across ALL step-finish
             // parts in the whole session. The catch-up loop above only scans from
             // the last user message (= last run) for per-turn usage; cumulative
@@ -461,31 +526,45 @@ export class OpencodeSessionReader {
         let cumTotal = 0;
         let cumCacheRead = 0;
         let cumCacheWrite = 0;
-        for (const msg of messages) {
-            if (msg?.type !== 'assistant' || !msg.tokens)
+        // 本 turn（= 本 run）的 flow：末个 turn 内每次模型请求之和。contextLength
+        // 仍取末次请求的窗口水位（水位不可求和）。只取末条会把多步 run 低报
+        // （实测一条 25 请求的 run：input 20,040 显示成 543、output 10,358 显示成 1,250）。
+        const turnStart = lastTurnStartIndex(messages);
+        const turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
+        for (let i = 0; i < messages.length; i++) {
+            const sample = usageSample(messages[i]);
+            if (!sample)
                 continue;
-            const tokens = msg.tokens;
-            const cacheRead = tokens.cache?.read ?? 0;
-            const cacheWrite = tokens.cache?.write ?? 0;
-            const total = tokens.input + tokens.output + tokens.reasoning + cacheRead + cacheWrite;
-            cumInput += tokens.input;
-            cumOutput += tokens.output;
-            cumTotal += total;
-            cumCacheRead += cacheRead;
-            cumCacheWrite += cacheWrite;
-            // A long autonomous run can end on a degenerate assistant message with
-            // zero tokens; skip it so the card reflects the last real step.
-            if (total !== 0) {
-                latest = {
-                    inputTokens: tokens.input,
-                    outputTokens: tokens.output,
-                    // §9.21 口径：含末轮 output（与 postTokens 水位同语义）。
-                    contextLength: tokens.input + tokens.output + cacheRead + cacheWrite,
-                    cacheReadTokens: cacheRead,
-                    cacheCreationTokens: cacheWrite,
-                    totalTokens: total,
-                };
+            cumInput += sample.input;
+            cumOutput += sample.output;
+            cumTotal += sample.total;
+            cumCacheRead += sample.cacheRead;
+            cumCacheWrite += sample.cacheCreation;
+            if (i > turnStart) {
+                turn.input += sample.input;
+                turn.output += sample.output;
+                turn.cacheRead += sample.cacheRead;
+                turn.cacheCreation += sample.cacheCreation;
+                turn.total += sample.total;
             }
+            latest = {
+                inputTokens: sample.input,
+                outputTokens: sample.output,
+                // §9.21 口径：含末轮 output（与 postTokens 水位同语义）。
+                contextLength: sample.input + sample.output + sample.cacheRead + sample.cacheCreation,
+                cacheReadTokens: sample.cacheRead,
+                cacheCreationTokens: sample.cacheCreation,
+                totalTokens: sample.total,
+            };
+        }
+        // turnStart 严格小于最后一个采样下标，所以 latest 存在时 turn 至少含一条
+        // 采样：flow 覆盖末条值，只有 contextLength 保留末条。
+        if (latest) {
+            latest.inputTokens = turn.input;
+            latest.outputTokens = turn.output;
+            latest.cacheReadTokens = turn.cacheRead;
+            latest.cacheCreationTokens = turn.cacheCreation;
+            latest.totalTokens = turn.total;
         }
         latest = withCumulativeUsage(latest, {
             total: cumTotal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",