lark-remote 0.5.14 → 0.5.16

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/kimi/acp/runner.d.ts

@@ -56,6 +56,8 @@ export interface KimiAcpRunnerOptions {
     permissionMode?: 'manual' | 'auto' | 'yolo';
 }
 export declare class KimiAcpRunner extends BaseAcpRunner<KimiAcpTranslator> {
+    /** ACP usage_update 只有 context，没有 input/output：flow 走 jsonl。 */
+    getUsageAuthority(): 'jsonl';
     private permissionMode;
     private thinkingEffort?;
     private readonly compactIdleTimeoutMs;

package/dist/runner/kimi/acp/runner.js

@@ -134,6 +134,10 @@ function buildQuestionResponse(action, pending, response) {
 // Runner
 // =============================================================================
 export class KimiAcpRunner extends BaseAcpRunner {
+    /** ACP usage_update 只有 context，没有 input/output：flow 走 jsonl。 */
+    getUsageAuthority() {
+        return 'jsonl';
+    }
     permissionMode;
     thinkingEffort;
     compactIdleTimeoutMs;

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

@@ -53,6 +53,8 @@ export interface OpencodeAcpRunnerOptions {
     errorMonitorPollIntervalMs?: number;
 }
 export declare class OpencodeAcpRunner extends BaseAcpRunner<OpencodeAcpTranslator> {
+    /** ACP usage_update 只有 context，没有 input/output：flow 走 jsonl。 */
+    getUsageAuthority(): 'jsonl';
     /** Configured session mode applied via session/set_mode. */
     private configuredMode;
     /** Current session mode id, parsed from session/new|resume configOptions. */
@@ -91,9 +93,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

@@ -30,6 +30,10 @@ import { OpencodeLogErrorMonitor, resolveOpencodeLogPath } from './error-monitor
 // Runner
 // =============================================================================
 export class OpencodeAcpRunner extends BaseAcpRunner {
+    /** ACP usage_update 只有 context，没有 input/output：flow 走 jsonl。 */
+    getUsageAuthority() {
+        return 'jsonl';
+    }
     /** Configured session mode applied via session/set_mode. */
     configuredMode;
     /** Current session mode id, parsed from session/new|resume configOptions. */
@@ -173,20 +177,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/runner/types.d.ts

@@ -581,8 +581,15 @@ export interface AgentRunner extends Runner {
     readonly sessionReader: AgentSessionReader;
     /** Return current status info for /status display. */
     getStatusInfo(): AgentStatusInfo;
-    /** Whether this runner provides live usage data (vs. file-based). */
+    /** flow 字段的权威来源：live 有 input/output 用 live，否则用 jsonl。 */
     getUsageAuthority?(): 'live' | 'jsonl';
+    /**
+     * 该 runner 的 result 事件是否具备 live 语义（pre-init result 处理与
+     * session 写回）。与用量来源分开：ACP live 只有 context，用量来源是
+     * jsonl，但 result 事件仍需按 live 语义处理。
+     * 未实现 = 按 getUsageAuthority() === 'live' 兼容旧行为。
+     */
+    usesLiveResultEvents?(): boolean;
     /**
      * 回传审批决策（codex thread/permissions、ACP elicitation、DSH approval
      * resolve）。未实现的 agent 由协调器按「无人应答」超时收尾。

package/dist/session/claude/sessions.js

@@ -246,6 +246,32 @@ export function isClaudeSessionActive(sessionId, cwd, opts = {}) {
         }
     }
 }
+/**
+ * 是否是“真人发起新 turn”的 user 行。
+ *
+ * 只用于 turn 边界，不用于展示标题。排除：tool_result、compact summary、
+ * isMeta（skill/命令注入）、task notification、sidechain（子 agent prompt）。
+ * 不要求有可展示文本——attachment-only 的输入同样是一次真人 turn。
+ */
+function isRealUserPrompt(obj) {
+    if (obj.type !== 'user' || obj.isCompactSummary === true || obj.isMeta === true) {
+        return false;
+    }
+    if (obj.isSidechain === true)
+        return false;
+    const msg = obj.message;
+    if (msg?.role !== 'user' || msg.content === undefined)
+        return false;
+    const content = msg.content;
+    if (Array.isArray(content) &&
+        content.some((block) => block?.type === 'tool_result')) {
+        return false;
+    }
+    const text = extractText(content);
+    if (text && isTaskNotificationText(text))
+        return false;
+    return true;
+}
 /**
  * first-pass scan: stream the file once via `scanJsonlLines`
  * (no `string[]` materialized), parse each line exactly once, and collect
@@ -268,6 +294,8 @@ function scalarScan(filePath) {
     const usageByMessageId = new Map();
     let lastPostTokens = 0;
     let tailOffset = -1;
+    /** 真人 prompt 序号；末个 turn = 当前值。sidechain/注入/工具结果不递增。 */
+    let turnSeq = 0;
     let lastAiTitle;
     let lastRecap;
     let lastUserMessage;
@@ -285,6 +313,7 @@ function scalarScan(filePath) {
                         output: Math.max(prev?.output ?? 0, usage.output_tokens ?? 0),
                         cacheRead: Math.max(prev?.cacheRead ?? 0, usage.cache_read_input_tokens ?? 0),
                         cacheCreation: Math.max(prev?.cacheCreation ?? 0, usage.cache_creation_input_tokens ?? 0),
+                        turn: prev?.turn ?? turnSeq,
                     });
                 }
             }
@@ -337,16 +366,39 @@ function scalarScan(filePath) {
                 }
             }
         }
+        // --- turn boundary for per-run usage ---
+        // 真人 prompt 开启新 turn；注入/工具结果/sidechain 不递增。usage 记录在
+        // 解析到 assistant 行时已经带上当前 turnSeq，末尾只汇总末个 turn。
+        if (isRealUserPrompt(obj))
+            turnSeq++;
     });
     // Feed one best record per message id, in first-appearance order (Map
     // preserves insertion order), so acc.last is the LAST message's full usage
-    // and totals sum each API response exactly once.
+    // and totals sum each API response exactly once. Per-run flow is only the
+    // records belonging to the last real-user turn — a tool-looping turn has
+    // several assistant messages (one per model request), so `last` alone
+    // under-reports it.
+    const turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
     for (const record of usageByMessageId.values()) {
         acc.add(record);
+        if (turnSeq > 0 && record.turn === turnSeq) {
+            turn.input += record.input;
+            turn.output += record.output;
+            turn.cacheRead += record.cacheRead;
+            turn.cacheCreation += record.cacheCreation;
+        }
     }
     // Build usage result (same logic as old aggregateSessionUsage)
     const t = acc.totals;
     const l = acc.last;
+    // 没有真人 user prompt（旧数据/截断文件）→ 无法划分 turn，回退末条采样，
+    // 与 dsh/codex「无 turn 标记退回末条」一致；不能把整份文件当成一轮。
+    if (turnSeq === 0 && l) {
+        turn.input = l.input;
+        turn.output = l.output;
+        turn.cacheRead = l.cacheRead;
+        turn.cacheCreation = l.cacheCreation;
+    }
     // contextLength = current context-window occupancy. Prefer compact_boundary
     // postTokens (the precise post-compact size); otherwise fall back to the
     // last turn's input + cacheRead + cacheCreation (unified
@@ -362,14 +414,14 @@ function scalarScan(filePath) {
     // 对齐 codex reader 语义（§9.21：`last_token_usage`=单 turn 增量、
     // `total_token_usage`=session 累计）——否则 jsonl 兜底路径会把 session 累计
     // 当成"本 run"显示，与卡片"本 run ≤ 累计"不变量冲突（累计反而更小）。
-    const lastTotal = l ? l.input + l.output + l.cacheRead + l.cacheCreation : 0;
+    const lastTotal = turn.input + turn.output + turn.cacheRead + turn.cacheCreation;
     const usage = {
-        inputTokens: l ? l.input : 0,
-        outputTokens: l ? l.output : 0,
+        inputTokens: turn.input,
+        outputTokens: turn.output,
         contextLength,
         compactCount: acc.compactCount,
-        cacheReadTokens: l && l.cacheRead > 0 ? l.cacheRead : undefined,
-        cacheCreationTokens: l && l.cacheCreation > 0 ? l.cacheCreation : undefined,
+        cacheReadTokens: turn.cacheRead > 0 ? turn.cacheRead : undefined,
+        cacheCreationTokens: turn.cacheCreation > 0 ? turn.cacheCreation : undefined,
         totalTokens: lastTotal,
         ...cumulativeUsageFields(t),
     };

package/dist/session/dsh/sessions.d.ts

@@ -41,6 +41,8 @@ interface DshSessionReaderOptions {
     syncConnect?: (baseUrl: string, token: string) => string;
 }
 export declare class DshSessionReader implements AgentSessionReader {
+    /** DSH session/page 没有 compactCount；compact 收尾不应因此重试读取。 */
+    readonly supportsCompactCount = false;
     private readonly hostProvider;
     private readonly dshHomeProvider;
     private readonly tokenProvider;

package/dist/session/dsh/sessions.js

@@ -98,6 +98,8 @@ function isAuthFailure(err) {
     return /\b401\b|\b403\b|unauthori[sz]ed|forbidden|invalid[ -]?cookie/i.test(msg);
 }
 export class DshSessionReader {
+    /** DSH session/page 没有 compactCount；compact 收尾不应因此重试读取。 */
+    supportsCompactCount = false;
     hostProvider;
     dshHomeProvider;
     tokenProvider;
@@ -315,8 +317,8 @@ export class DshSessionReader {
                 // 在途 turn（turn/start 无 turn/end，run 进行中读历史）的采样优先于
                 // 上一轮：旧实现只认已结算的 lastTurnUsage，mid-run 读取会把当前 turn
                 // 已消耗的量显示成上一个完整 turn 的数字。
-                const flow = lastTurnUsage ??
-                    turnUsage ?? {
+                const flow = turnUsage ??
+                    lastTurnUsage ?? {
                     input,
                     output: lastUsage.outputTokens ?? 0,
                     cacheRead,
@@ -325,8 +327,9 @@ export class DshSessionReader {
                 sessionUsage = {
                     inputTokens: flow.input,
                     outputTokens: flow.output,
-                    // §9.21 口径：含末轮 output（下一 prompt 全量携带，与 postTokens 水位同语义）。
-                    contextLength: input + flow.output + cacheRead + cacheWrite,
+                    // §9.21 口径：context 是末次采样的窗口水位（input + 末次 output +
+                    // cache），不把整 turn 的 output 求和（前几步 output 已进入后续 input）。
+                    contextLength: input + (lastUsage.outputTokens ?? 0) + cacheRead + cacheWrite,
                     cacheReadTokens: flow.cacheRead,
                     cacheCreationTokens: flow.cacheWrite,
                     totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheWrite,

package/dist/session/kimi/sessions.js

@@ -347,7 +347,16 @@ 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」。
+            // 末个 turn 尚无 usage.record 时 flow = 0（当前契约是「末个 turn」，不是
+            // 「末个非空 turn」）——不能退回上一轮的记录。
+            let turnAcc = null;
+            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 +364,20 @@ 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;
+                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 还没有记录时
+            // turnAcc.count = 0 → flow = 0。整份 wire 都没有 turn.prompt（旧数据/
+            // 截断）时无从分段，沿用「整份文件 = 一个 turn」的旧口径（含子 agent wire）。
+            const flow = turnAcc ? turnAcc.totals : 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.d.ts

@@ -31,6 +31,8 @@ interface OpencodeSessionReaderOptions {
 export declare class OpencodeSessionReader implements AgentSessionReader {
     private readonly binary;
     private readonly cacheTtlMs;
+    /** opencode export 没有 compactCount；compact 收尾不应因此重试 export。 */
+    readonly supportsCompactCount = false;
     /** Optional raw-export capture override (testing / alt transport). */
     private readonly captureExportOverride?;
     /** cwd → 列表缓存（TTL 由 cacheTtlMs 决定）。 */

package/dist/session/opencode/sessions.js

@@ -81,6 +81,61 @@ 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;
+    // 末条采样之后又出现 user：这是新 turn 的起点，但还没有采样（空 turn）。
+    // 返回该 user 下标，让 flow 汇总范围为空 → 本 run = 0，而不是上一轮。
+    for (let i = lastSample + 1; i < messages.length; i++) {
+        if (messages[i]?.type === 'user')
+            return i;
+    }
+    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 两条读取路径共用）。
  *
@@ -113,6 +168,8 @@ function withCumulativeUsage(usage, cum) {
 export class OpencodeSessionReader {
     binary;
     cacheTtlMs;
+    /** opencode export 没有 compactCount；compact 收尾不应因此重试 export。 */
+    supportsCompactCount = false;
     /** Optional raw-export capture override (testing / alt transport). */
     captureExportOverride;
     /** cwd → 列表缓存（TTL 由 cacheTtlMs 决定）。 */
@@ -196,6 +253,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 +321,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 +357,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 +534,46 @@ 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 可能落在末条采样之后（新 turn 尚无采样）→ turn 全 0；latest
+        // 仍是上一轮末条采样，contextLength 保留水位。turnStart 小于最后一个采样
+        // 下标时，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,