lark-remote 0.5.15 → 0.5.16

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.16] - 2026-11-01
+
+### 修复
+
+- **Claude / Pi 的「本 run」用量在多步回合下不再低报**：卡片「本 run」与 `/resume`、自动恢复卡、完成通知卡的 Input / Output 由会话文件兜底读取，此前这两个 agent 只取**最后一条 assistant 消息**，而一条消息等于一次模型请求——带工具往返的回合里显示的是最后一次请求的量，整轮消耗被系统性低估。现在汇总末个真人回合内的所有 assistant 消息；`Context` 仍是末次请求的窗口水位、`累计` 仍是会话总量，口径不变。没有真人输入的旧数据或截断文件退回末条采样，不会把整份会话当成一轮
+- **DSH 回合进行中的读数不再显示上一轮**：进程重启后的自动恢复与 `/resume`、没有活动用量时的中途读取、完成通知卡，此前优先取**上一个已结算回合**的数字（取值顺序与它自己的注释相反），当前回合已消耗的量被显示成上一轮。现在在途回合优先
+- **DSH 的 `Context` 不再虚高**：窗口水位此前把整回合的输出一路相加，而前几步的输出早已计入后续请求的输入，属重复计数；`Context` 始终以会话文件为准，于是终态卡的上下文占用行随回合变长而虚高、百分比一起失真。现在只取末次请求的输出
+- **Kimi / opencode 新回合刚开始时显示 0，不再显示上一轮残留**：回合已发出、模型还没产生任何用量采样的时刻，两个 reader 此前退回上一轮的最后一条记录，卡片把「刚开始的空回合」画成「刚结束那一轮」的消耗。现在按「末个回合」契约显示 0（`Context` 保留上一轮水位，因为窗口占用确实延续）；整份记录里没有回合标记的旧数据沿用原有语义
+- **`/compact` 收尾不再做无用功**：opencode 与 DSH 的会话读取给不出压缩次数，此前的重试把「这个 agent 没有该字段」当成「还没落盘」，每次压缩固定多跑两次完整导出 / 读取且永远等不到。现在 reader 显式声明能否产出压缩计数，声明不能的不再重试
+
+### 维护
+
+- **用量来源与 result 事件语义拆成两个字段**：原先一个字段同时承担「Input/Output 来自 live 还是会话文件」和「result 事件是否按 live 语义处理（启动前的 result 丢弃、会话指针写回）」，而 Kimi / opencode 的 live 通知只带上下文占用、没有输入输出拆分，却被迫声明成 live 来源。现在前者单独声明为会话文件，result 事件语义走新的声明位。无行为变化
+- **跨 agent 的用量口径断言集中到一处**：本 run / `Context` / 累计三条不变量原本每个 reader 各写一套期望值，容易把错误语义固化成测试基线；现在 Claude / Pi / DSH / Kimi / opencode 的回归用例共用同一组断言。无行为变化
+- **新增 token 用量口径文档**（中英文）：三个 scope 的硬不变量、live 与会话文件两条生产路径、同一低报问题反复复发的原因、六个 reader 各自的回合边界与 `Context` 公式，以及尚未落地的共享聚合器与子 agent 用量过滤缺口
+
 ## [0.5.15] - 2026-10-31
 
 ### 修复

package/dist/bridge/index.js

@@ -1220,7 +1220,7 @@ export class Bridge {
      * @param dropFromCard 该 result 是陈旧重放，不得进卡片（调用方 continue 跳过 push）
      */
     observeResultEvent(event, opts) {
-        const { sawInit, usageAuthority, usage, writeback, runId } = opts;
+        const { sawInit, liveResultEvents, usage, writeback, runId } = opts;
         const preInitResult = !sawInit;
         const preInitTerminal = preInitResult && (event.subtype === 'error' || event.subtype === 'interrupted')
             ? {
@@ -1228,7 +1228,7 @@ export class Bridge {
                 errorMessage: event.errorMessage,
             }
             : undefined;
-        if (preInitResult && usageAuthority !== 'live') {
+        if (preInitResult && !liveResultEvents) {
             getLogger().info(`[lark-remote] pre-init result ignored (resume replay) runId=${runId}`);
             return { sawResult: false, dropFromCard: true, preInitTerminal };
         }
@@ -1236,11 +1236,11 @@ export class Bridge {
         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')
+        // 连接型 runner 的 setup 失败路径（thread/start 成功后 turn/start 失败）
+        // 不会有 turn_started 事件，store 不会写回新线程 id；runner 已在 result 里
+        // 兜底上报。仅当 runner 声明 live result 语义且会话指针未动时写回，避免
+        // 下条消息再开一个孤儿线程。其余 agent 不在此列（各自有 init/turn_started 写回）。
+        if (liveResultEvents)
             writeBackResultSession(writeback, event.session_id);
         return { sawResult: !preInitResult, dropFromCard: false, preInitTerminal };
     }
@@ -1353,9 +1353,12 @@ export class Bridge {
      * Handles idle watchdog, event processing, session sync, and state transitions.
      */
     async runAgentStreamToEnd(runner, cardSession, activeRun, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind = this.config.defaultAgent) {
-        // Runner 声明的 usage 权威来源：codex app-server = 'live'
-        // （turn/started 的 tokenUsage.last 是本 turn 增量）。其余 runner 未声明。
+        // Runner 声明的 usage 权威来源：codex app-server / pi RPC = 'live'
+        // （live 带 input/output）；opencode/kimi ACP live 只有 context，声明
+        // 'jsonl'。result 事件的 live 语义（pre-init/写回）单独声明，不能和
+        // 用量来源共用一个字段。
         const usageAuthority = runner.getUsageAuthority?.();
+        const liveResultEvents = runner.usesLiveResultEvents?.() ?? usageAuthority === 'live';
         // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
         let watchdog = null;
         let sawResult = false;
@@ -1453,7 +1456,7 @@ export class Bridge {
                 if (event.type === 'result') {
                     const outcome = this.observeResultEvent(event, {
                         sawInit,
-                        usageAuthority,
+                        liveResultEvents,
                         usage,
                         writeback,
                         runId,
@@ -1975,8 +1978,11 @@ export class Bridge {
             // 压缩结束后从会话 jsonl 读权威统计（压缩后上下文、压缩次数、本次压缩
             // token 消耗与会话累计）。thread/compacted 通知与 jsonl 落盘几乎同时
             // （实测差 ~9ms），compactCount 未读到则短重试，仍失败优雅降级（无统计）。
+            // 不支持 compactCount 的 reader（opencode/dsh）不重试——否则每次 compact
+            // 都会固定多跑两次完整 export/读取，且永远等不到该字段。
+            const compactCountSupported = this.sessionReaderRegistry.tryGet(agentKind)?.supportsCompactCount !== false;
             let finalUsage = resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, sessionId, cwd, agentKind);
-            for (let attempt = 0; !finalUsage?.compactCount && attempt < 2; attempt++) {
+            for (let attempt = 0; compactCountSupported && !finalUsage?.compactCount && attempt < 2; attempt++) {
                 await sleep(150);
                 finalUsage = resolveFinalUsage(this.sessionReaderRegistry, this.config.defaultAgent, sessionId, cwd, agentKind);
             }

package/dist/runner/common/connection-based-runner.d.ts

@@ -122,7 +122,9 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
      * One-way by design: an evicted instance never returns to the cache.
      */
     markOrphaned(): void;
-    getUsageAuthority(): 'live';
+    getUsageAuthority(): 'live' | 'jsonl';
+    /** 连接型 runner 的 result 事件都是 runner 自己产出的 live 语义。 */
+    usesLiveResultEvents(): boolean;
     killOrphan(): void;
     registerExitHandlers(): void;
     unregisterExitHandlers(): void;

package/dist/runner/common/connection-based-runner.js

@@ -221,6 +221,10 @@ export class ConnectionBasedRunner {
     getUsageAuthority() {
         return 'live';
     }
+    /** 连接型 runner 的 result 事件都是 runner 自己产出的 live 语义。 */
+    usesLiveResultEvents() {
+        return true;
+    }
     killOrphan() {
         // No-op: the connection is managed by ConnectionManager.
     }

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. */

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. */

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

@@ -353,8 +353,9 @@ export class KimiSessionReader {
             // 末条会低报，取会话总量（旧实现）又会把历史所有 run 的消耗算进这一轮。
             // 子 agent 的 wire 没有 turn 标记，只能进会话累计（无法归属到某一轮）；
             // 整份 wire 都没有 turn.prompt（旧数据）时沿用「整份文件 = 一个 turn」。
+            // 末个 turn 尚无 usage.record 时 flow = 0（当前契约是「末个 turn」，不是
+            // 「末个非空 turn」）——不能退回上一轮的记录。
             let turnAcc = null;
-            let lastMainUsage;
             const accumulateUsage = (u, scope) => {
                 hasUsageRecord = true;
                 // Malformed records (missing usage object or missing fields) must
@@ -372,7 +373,6 @@ export class KimiSessionReader {
                 acc.add(record);
                 if (scope !== 'main')
                     return;
-                lastMainUsage = record;
                 turnAcc?.add(record);
                 // unified contract (§9.21): input + output + cacheRead + cacheCreation.
                 // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
@@ -498,10 +498,10 @@ export class KimiSessionReader {
             // 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;
+            // 有 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: flow.input,

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

@@ -119,6 +119,12 @@ function lastTurnStartIndex(messages) {
     }
     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;
@@ -162,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 决定）。 */
@@ -557,8 +565,9 @@ export class OpencodeSessionReader {
                 totalTokens: sample.total,
             };
         }
-        // turnStart 严格小于最后一个采样下标，所以 latest 存在时 turn 至少含一条
-        // 采样：flow 覆盖末条值，只有 contextLength 保留末条。
+        // turnStart 可能落在末条采样之后（新 turn 尚无采样）→ turn 全 0；latest
+        // 仍是上一轮末条采样，contextLength 保留水位。turnStart 小于最后一个采样
+        // 下标时，flow 覆盖末条值，只有 contextLength 保留末条。
         if (latest) {
             latest.inputTokens = turn.input;
             latest.outputTokens = turn.output;

package/dist/session/pi/sessions.js

@@ -157,6 +157,11 @@ function findSessionFile(sessionId, cwd, sessionsDir) {
  */
 function piScalarScan(filePath) {
     const acc = new UsageAccumulator();
+    // 末个真人 turn 的 flow：user 消息开启新 turn，assistant 用量同时进两个
+    // accumulator。带工具往返的 turn 有多个 assistant 消息（一次模型请求一条），
+    // 只取末条会低报整轮消耗。
+    let turnAcc = new UsageAccumulator();
+    let sawUser = false;
     let tailOffset = -1;
     let lastUserText;
     scanJsonlOnce(filePath, (rawObj, line, offset) => {
@@ -168,18 +173,22 @@ function piScalarScan(filePath) {
             // usage aggregation (assistant only)
             if (msg.role === 'assistant' && msg.usage) {
                 const u = msg.usage;
-                acc.add({
+                const record = {
                     input: u.input ?? 0,
                     output: u.output ?? 0,
                     cacheRead: u.cacheRead ?? 0,
                     cacheCreation: u.cacheWrite ?? 0,
                     total: u.totalTokens ?? 0,
-                });
+                };
+                acc.add(record);
+                turnAcc.add(record);
             }
             // last user message offset + displayTitle. Record the byte offset
             // where the tail should start: the beginning of the NEXT line after
             // this user message (see tailOffsetAfter).
             if (msg.role === 'user') {
+                sawUser = true;
+                turnAcc = new UsageAccumulator();
                 tailOffset = tailOffsetAfter(line, offset);
                 const text = extractPiText(msg.content);
                 // Compress skill-injection bodies so the "最近输入" label shows what
@@ -195,7 +204,7 @@ function piScalarScan(filePath) {
     });
     return {
         tailOffset,
-        usage: buildPiUsage(acc),
+        usage: buildPiUsage(acc, turnAcc, sawUser),
         // Whitespace-normalized single-line display title (no length truncation —
         // the consumer truncates). Normalization collapses the skill-injection
         // newlines so the title stays on one line.
@@ -203,27 +212,38 @@ function piScalarScan(filePath) {
     };
 }
 /**
- * Build the AgentSessionUsage from an accumulator, preserving pi's
- * "last turn" semantics: inputTokens/outputTokens use the LAST turn's
- * values, contextLength = last turn's context-window occupancy
- * (input + cacheRead + cacheCreation, excludes output —unified
- * contract across all five readers), cumulative = session-wide sum.
+ * Build the AgentSessionUsage: flow (input/output/cache/total) is the sum of
+ * every assistant message in the LAST real-user turn; contextLength is the
+ * last assistant message's window occupancy; cumulative is the whole session.
+ * With no real-user turn (legacy/truncated file), flow falls back to the last
+ * assistant sample, matching dsh/codex's no-turn-marker fallback.
  * Returns undefined when no usage data was observed.
  */
-function buildPiUsage(acc) {
+function buildPiUsage(acc, turnAcc, sawUser) {
     const t = acc.totals;
-    if (t.input + t.output === 0) {
+    if (t.input + t.output + t.cacheRead + t.cacheCreation === 0) {
         return undefined;
     }
     const l = acc.last;
+    // 没有真人 user prompt（旧数据/截断文件）→ 无法划分 turn，回退末条采样，
+    // 与 dsh/codex「无 turn 标记退回末条」一致；不能把整份文件当成一轮。
+    const f = sawUser
+        ? turnAcc.totals
+        : {
+            input: l.input,
+            output: l.output,
+            cacheRead: l.cacheRead,
+            cacheCreation: l.cacheCreation,
+            total: l.total,
+        };
     return {
-        inputTokens: l.input,
-        outputTokens: l.output,
+        inputTokens: f.input,
+        outputTokens: f.output,
         contextLength: contextWindowOccupancy(l),
         compactCount: acc.compactCount > 0 ? acc.compactCount : undefined,
-        cacheReadTokens: l.cacheRead > 0 ? l.cacheRead : 0,
-        cacheCreationTokens: l.cacheCreation > 0 ? l.cacheCreation : 0,
-        totalTokens: l.total > 0 ? l.total : undefined,
+        cacheReadTokens: f.cacheRead > 0 ? f.cacheRead : 0,
+        cacheCreationTokens: f.cacheCreation > 0 ? f.cacheCreation : 0,
+        totalTokens: f.total > 0 ? f.total : undefined,
         // Cumulative (session-wide): sum of ALL runs in the jsonl file.
         ...cumulativeUsageFields(t),
     };

package/dist/session/registry.d.ts

@@ -10,4 +10,6 @@ export declare class SessionReaderRegistry {
     private readonly readers;
     register(kind: AgentKind, reader: AgentSessionReader): void;
     get(kind: AgentKind): AgentSessionReader;
+    /** 可选能力探测用：不抛错，交给调用方决定降级行为。 */
+    tryGet(kind: AgentKind): AgentSessionReader | undefined;
 }

package/dist/session/registry.js

@@ -16,5 +16,9 @@ export class SessionReaderRegistry {
         }
         return reader;
     }
+    /** 可选能力探测用：不抛错，交给调用方决定降级行为。 */
+    tryGet(kind) {
+        return this.readers.get(kind);
+    }
 }
 //# sourceMappingURL=registry.js.map

package/dist/session-contract.d.ts

@@ -175,4 +175,10 @@ export interface AgentSessionReader {
      * 未实现 = 该 agent 没有这个概念，调用方按「不在途」处理。
      */
     readCompactionState?(sessionId: string, cwd: string): CompactionState;
+    /**
+     * `readSessionContent` 是否产出 `compactCount`。opencode 的 export 没有
+     * 压缩计数；compact 收尾的重试不能把「不支持」误判成「还没落盘」。
+     * 未声明 = 支持（保持既有 reader 行为）。
+     */
+    supportsCompactCount?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "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",