lark-remote 0.5.19 → 0.5.20

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

@@ -133,8 +133,8 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
         }
         // Apply the configured model (`provider/model`) via set_config_option.
         // Without this the session runs opencode's own default model (e.g.
-        // opencode/big-pickle), which may be unusable — 2026-08-17 live smoke:
-        // default zen model left session/prompt hanging with no response.
+        // opencode/big-pickle), which may be unusable: the default zen model can
+        // leave session/prompt hanging with no response.
         // Non-fatal on failure (unknown model → server InvalidModelError).
         if (this.model && this.currentModelValue !== this.model) {
             try {
@@ -179,7 +179,7 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
      * before failing the turn.
      *
      * 单次 attempt 自身还要等 opencode 侧超时（~10s），所以真实窗口 ≈ Σdelay +
-     * 每次的等待。2026-10-30 现场：daemon 刚重启，`/api/model` 因模型目录拉取
+     * 每次的等待。daemon 刚重启时 `/api/model` 会因模型目录拉取
      * 超时连续 503 约 7 分钟，旧退避 0.5/1.5/3s（合计 ~45s）全落在这段里，4 次
      * 重试无一成功。现在铺到 ~75s + 每次超时 ≈ 2 分钟，覆盖一次冷启动窗口，
      * 又不至于让真故障的用户干等太久。
@@ -194,7 +194,7 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
     /**
      * 用户可见文案。这里刻意**不**建议 `opencode service restart`：卡住的是
      * opencode 的模型目录/位置服务冷启动，重启只会清掉刚热好的状态、重新回到
-     * 同一个窗口（2026-10-30 现场：照提示重启两次仍然失败，等几分钟自己好了）。
+     * 同一个窗口（照提示重启两次仍然失败，等几分钟自己好了）。
      */
     enrichSessionSetupError(err) {
         if (!this.isRetryableSessionSetupError(err)) {

package/dist/runner/pi/rpc/protocol-types.d.ts

@@ -7,7 +7,7 @@
  *                     and events (session lifecycle / message / compaction) as bare
  *                     JSON objects (no envelope).
  *
- * Turn semantics (verified live against pi 0.84.1, 2026-08-18):
+ * Turn semantics (verified against pi 0.84.1):
  *   - `prompt` returns an ack (`success:true`) immediately; the turn then streams
  *     events and completes with an `agent_settled` event.
  *   - `compact` runs synchronously and returns its response at completion; it also

package/dist/runner/pi/rpc/protocol-types.js

@@ -7,7 +7,7 @@
  *                     and events (session lifecycle / message / compaction) as bare
  *                     JSON objects (no envelope).
  *
- * Turn semantics (verified live against pi 0.84.1, 2026-08-18):
+ * Turn semantics (verified against pi 0.84.1):
  *   - `prompt` returns an ack (`success:true`) immediately; the turn then streams
  *     events and completes with an `agent_settled` event.
  *   - `compact` runs synchronously and returns its response at completion; it also

package/dist/runner/pi/rpc/runner.d.ts

@@ -59,6 +59,7 @@ export declare class PiRpcRunner extends ConnectionBasedRunner<PiRpcClient, PiRp
     protected clearTurnState(): void;
     protected releaseConnection(cwd: string): Promise<void>;
     protected notifyIdle(cwd: string): void;
+    protected notifyConnectionActivity(cwd: string): void;
     protected disposeConnections(): Promise<void>;
     getStatusInfo(): AgentStatusInfo;
     /**
@@ -72,4 +73,6 @@ export declare class PiRpcRunner extends ConnectionBasedRunner<PiRpcClient, PiRp
      */
     runCompact(_message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
     private handleEvent;
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    private installTurnHooks;
 }

package/dist/runner/pi/rpc/runner.js

@@ -20,6 +20,7 @@
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 import { ConnectionManager } from '../../common/jsonrpc/connection-manager.js';
 import { getLogger } from '../../../logger/index.js';
+import { PI_DEFAULTS } from '../../../config/index.js';
 import { PiRpcClient } from './client.js';
 import { PiRpcTranslator } from './translator.js';
 export class PiRpcRunner extends ConnectionBasedRunner {
@@ -36,10 +37,12 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             sessionReader: opts.sessionReader,
             turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
         });
-        this.defaultModel = opts.model ?? 'glm-5.2';
-        this.provider = opts.provider ?? 'Volcano';
-        this.thinking = opts.thinking ?? 'medium';
-        const tools = (opts.tools ?? ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls']).join(',');
+        this.defaultModel = opts.model ?? PI_DEFAULTS.model;
+        this.provider = opts.provider ?? PI_DEFAULTS.provider;
+        this.thinking = opts.thinking ?? PI_DEFAULTS.thinking;
+        // PI_DEFAULTS.tools 是逗号串（config schema 的 tools 同形态），与原数组兜底
+        // join(',') 结果逐字相等；opts.tools 自身的数组语义（含空数组 → 空串）不变。
+        const tools = opts.tools?.join(',') ?? PI_DEFAULTS.tools;
         this.manager = new ConnectionManager({
             binary: opts.binary ?? 'pi',
             buildArgs: (req) => buildPiArgs(this.provider, this.defaultModel, this.thinking, tools, req.sessionId),
@@ -93,6 +96,9 @@ export class PiRpcRunner extends ConnectionBasedRunner {
     notifyIdle(cwd) {
         this.manager.notifyIdle(cwd);
     }
+    notifyConnectionActivity(cwd) {
+        this.manager.notifyActivity(cwd);
+    }
     async disposeConnections() {
         await this.manager.disposeAll();
     }
@@ -110,28 +116,13 @@ export class PiRpcRunner extends ConnectionBasedRunner {
      * `agent_settled` event produces the result.
      */
     async setupTurn(message, opts) {
-        const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
-        this.manager.notifyActivity(opts.cwd);
-        this.currentClient = client;
-        // 轮次代际锚点（与 BaseAcpRunner 同口径）：pi 的 shouldReuse 要求
-        // sessionId 匹配，/new、/resume 切换后的首条消息会让 acquire **同步
-        // dispose** 旧连接；terminator 等到进程退出后，旧 client 上残留的上一轮
-        // onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即丢失）。
-        // 旧轮迟到的 agent_settled 同理（新 turn 空转立即"成功"）。所有 hook
-        // 落地前必须过 isCurrentTurn。
-        const generation = this.turnGeneration;
-        client.setHooks({
-            onEvent: (evt) => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                this.handleEvent(evt);
-            },
-            onClose: () => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                this.failTurn('Pi RPC connection closed');
-            },
-        });
+        const anchor = await this.acquireForTurn(opts.cwd, () => this.manager.acquire(opts.cwd, { sessionId: opts.sessionId }));
+        // pi 的 shouldReuse 要求 sessionId 匹配：/new、/resume 切换后的首条消息会让
+        // acquire **同步 dispose** 旧连接。旧 client 残留的上一轮 onClose / 迟到的
+        // agent_settled 必须被 anchor 守卫挡掉，否则假错误会推进新 turn 的共享队列
+        // （语义见 acquireForTurn / TurnAnchor）。
+        this.installTurnHooks(anchor);
+        const { client } = anchor;
         let sessionId = opts.sessionId;
         if (!sessionId) {
             const state = await client.request({ type: 'get_state' });
@@ -169,24 +160,11 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             if (!opts.sessionId) {
                 throw new Error('compact requires a sessionId');
             }
-            const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
-            this.manager.notifyActivity(opts.cwd);
-            this.currentClient = client;
             // 同 setupTurn：hook 带轮次代际锚点，旧连接的迟到回调不得进入本轮。
-            const generation = this.turnGeneration;
-            client.setHooks({
-                onEvent: (evt) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleEvent(evt);
-                },
-                onClose: () => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.failTurn('Pi RPC connection closed');
-                },
-            });
+            const anchor = await this.acquireForTurn(opts.cwd, () => this.manager.acquire(opts.cwd, { sessionId: opts.sessionId }));
+            this.installTurnHooks(anchor);
             this.activeSessionId = opts.sessionId;
+            const { client } = anchor;
             const translator = new PiRpcTranslator();
             translator.setSessionId(opts.sessionId);
             translator.setOperationKind('compact');
@@ -210,6 +188,13 @@ export class PiRpcRunner extends ConnectionBasedRunner {
     handleEvent(evt) {
         this.pushEvents(this.currentTranslator?.handleEvent(evt) ?? []);
     }
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    installTurnHooks(anchor) {
+        anchor.client.setHooks({
+            onEvent: this.forCurrentTurn(anchor, 'event', (evt) => this.handleEvent(evt)),
+            onClose: this.forCurrentTurn(anchor, 'connection close', () => this.failTurn('Pi RPC connection closed')),
+        });
+    }
 }
 /** Build pi `--mode rpc` spawn args. `sessionId` is bound at spawn (pi has no
  *  RPC resume-by-id command); omitting it spawns a brand-new session. */

package/dist/runner/types.d.ts

@@ -302,7 +302,7 @@ export interface ResultEvent {
      * 省略）` 标记——渲染层再怎么「回答优先」也找不回被丢掉的头部。runner 在
      * 收 turn 时拿到的是**完整** assistant 文本（一条消息，不是逐 delta 拼接），
      * 把它挂在 result 上，`promoteFinalAnswer` 用它建立 finalAnswer，回答因此
-     * 不再被进度窗口截断（2026-11-01 卡片输出块被截断缺陷）。
+     * 不再被进度窗口截断。
      */
     finalAnswerText?: string;
     usage?: {
@@ -582,7 +582,7 @@ export { AGENT_DISPLAY_NAMES } from '../agent-kinds.js';
  * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
  * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
  * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
- * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮。
  *
  * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
  * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧

package/dist/runner/types.js

@@ -11,7 +11,7 @@ export { AGENT_DISPLAY_NAMES } from '../agent-kinds.js';
  * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
  * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
  * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
- * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮。
  *
  * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
  * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧

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

@@ -25,6 +25,50 @@ export declare function getNewestSession(cwd: string, opts?: {
 export declare function isClaudeSessionActive(sessionId: string, cwd: string, opts?: {
     projectsDir?: string;
 }): boolean;
+/** claude wire 一条 assistant 行携带的原始 usage 字段（可选，缺按 0 计）。 */
+interface ClaudeRawUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+}
+/** per-message-id 合并后的 usage 采样（四个分量 + 采集时的真人 turn 序号）。 */
+export interface ClaudePerMessageUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+    /** 该 message 属于第几个真人 turn（0 = 还没有真人 prompt）。 */
+    turn: number;
+}
+/**
+ * 两条采样逐字段取 max（纯函数；UsageAccumulator 的 per-field max 语义）。
+ *
+ * RED LINE（token 口径单源的一部分）：一条 streaming assistant 消息跨多行
+ * jsonl、共享同一 message id；部分后端（第三方网关，如 DeepSeek）在早期占位
+ * 行（空 thinking 块）写全零 usage，真实用量只在带 stop_reason 的末行。
+ * first-occurrence-wins 会把零记录钉死、丢掉真实用量（regression 2026-08-19：
+ * auto-resume 卡 per-run 统计全 0）。逐字段 max 与行序无关地重建完整用量；
+ * 官方 API 每行重复相同 usage，max 是 no-op。
+ *
+ * 产生：合并后的一条采样。依赖：入参。不改任何外部状态。
+ */
+export declare function maxUsageRecord(prev: ClaudePerMessageUsage | undefined, usage: ClaudeRawUsage, turnSeq: number): ClaudePerMessageUsage;
+/**
+ * usage 装配（纯函数）：每个 message id 一条最优记录、按首次出现顺序喂
+ * UsageAccumulator（Map 保序），acc.last = 末条 message 的完整用量，totals
+ * 让每条 API 响应恰好多计一次。per-run flow 只取末个真人 turn 的记录——
+ * 工具往返的 turn 有多条 assistant 消息（一次模型请求一条），只取 `last`
+ * 会低报。
+ *
+ * 产生：AgentSessionUsage。依赖：入参 records + 标量。不改任何外部状态
+ * （UsageAccumulator 在函数内新建）。
+ */
+export declare function buildClaudeUsage(records: Iterable<ClaudePerMessageUsage>, opts: {
+    turnSeq: number;
+    lastPostTokens: number;
+    compactCount: number;
+}): AgentSessionUsage;
 export declare function readSessionContent(sessionId: string, cwd: string, opts?: {
     projectsDir?: string;
     maxEvents?: number;
@@ -35,3 +79,4 @@ export declare function readSessionContent(sessionId: string, cwd: string, opts?
     recap?: string;
     displayTitle?: string;
 };
+export {};

package/dist/session/claude/sessions.js

@@ -19,7 +19,7 @@ import { SessionIndex, extractText, isTaskNotificationText, CLAUDE_MAPPING, } fr
  * Note: this encoding is LOSSY (`my_data/foo` and `my-data/foo` both encode to
  * `my-data-foo`). It is only safe to use the result to **locate** files; never
  * to **decode** a directory name back to a cwd. The cwd must always be read
- * from the JSONL content (regression 2026-06-21 /resume & /cd 路径错乱).
+ * from the JSONL content (regression: /resume & /cd 路径错乱).
  */
 function projectDirForCwd(cwd, projectsDir) {
     return path.join(projectsDir, encodeProjectDirName(cwd));
@@ -32,7 +32,7 @@ function projectDirForCwd(cwd, projectsDir) {
  * MULTIPLE cwd values (pre- and post-relocate) — accept when ANY `cwd` field
  * matches. Early-stops on the first match (findJsonlLine), keeping the
  * single-pass parse-count anchors intact on the fallback path.
- * Regression 2026-08-04 EnterWorktree relocate.
+ * Needed for EnterWorktree relocate.
  */
 function fileContainsCwd(filePath, cwd) {
     return (findJsonlLine(filePath, (l) => {
@@ -50,7 +50,7 @@ function defaultProjectsDir() {
     return path.join(os.homedir(), '.claude', 'projects');
 }
 /**
- * EnterWorktree relocate support (2026-08-04): Claude Code MOVES the
+ * EnterWorktree relocate support: Claude Code MOVES the
  * transcript file to the new cwd's project dir mid-session, so the file may
  * not exist under the requested cwd's encoded dir. Fall back to locating
  * `<sessionId>.jsonl` across all project dirs. Deterministic: entries are
@@ -148,7 +148,7 @@ export function getNewestSession(cwd, opts = {}) {
  *    JSONL output continuously. A file whose mtime is older than
  *    `STALE_MS` cannot be from a running process. This catches the
  *    common Claude CLI 2.x case where the tail is `last-prompt` / `mode`
- *    (no `type:"result"`) and the process exited long ago (regression 2026-06-21).
+ *    (no `type:"result"`) and the process exited long ago.
  *
  * 2. **last-line terminal marker**: if the last JSON line is `result`
  *    (older CLI) or any explicit terminal event, the session is done
@@ -176,7 +176,7 @@ function hasRecentFileActivity(filePath, mtimeMs, now = Date.now()) {
         // Explicit terminal markers — regardless of mtime. Claude CLI 2.x uses
         // `last-prompt` / `mode` (no `result` event) to mark turn end, so a
         // 24-minute-old session with a last-prompt tail is already done
-        // (regression 2026-06-21: previously falsely reported as active).
+        // (previously falsely reported as active).
         if (typeof obj.type === 'string' && CLAUDE_TERMINAL_TYPES.has(obj.type))
             return false;
     }
@@ -272,6 +272,87 @@ function isRealUserPrompt(obj) {
         return false;
     return true;
 }
+/**
+ * 两条采样逐字段取 max（纯函数；UsageAccumulator 的 per-field max 语义）。
+ *
+ * RED LINE（token 口径单源的一部分）：一条 streaming assistant 消息跨多行
+ * jsonl、共享同一 message id；部分后端（第三方网关，如 DeepSeek）在早期占位
+ * 行（空 thinking 块）写全零 usage，真实用量只在带 stop_reason 的末行。
+ * first-occurrence-wins 会把零记录钉死、丢掉真实用量（regression 2026-08-19：
+ * auto-resume 卡 per-run 统计全 0）。逐字段 max 与行序无关地重建完整用量；
+ * 官方 API 每行重复相同 usage，max 是 no-op。
+ *
+ * 产生：合并后的一条采样。依赖：入参。不改任何外部状态。
+ */
+export function maxUsageRecord(prev, usage, turnSeq) {
+    return {
+        input: Math.max(prev?.input ?? 0, usage.input_tokens ?? 0),
+        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,
+    };
+}
+/**
+ * usage 装配（纯函数）：每个 message id 一条最优记录、按首次出现顺序喂
+ * UsageAccumulator（Map 保序），acc.last = 末条 message 的完整用量，totals
+ * 让每条 API 响应恰好多计一次。per-run flow 只取末个真人 turn 的记录——
+ * 工具往返的 turn 有多条 assistant 消息（一次模型请求一条），只取 `last`
+ * 会低报。
+ *
+ * 产生：AgentSessionUsage。依赖：入参 records + 标量。不改任何外部状态
+ * （UsageAccumulator 在函数内新建）。
+ */
+export function buildClaudeUsage(records, opts) {
+    const acc = new UsageAccumulator();
+    const turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+    for (const record of records) {
+        acc.add(record);
+        if (opts.turnSeq > 0 && record.turn === opts.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 (opts.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
+    // contract — excludes output/reasoning, which are generated, not part of
+    // the input window). Take the max so a pre-compact turn larger than the
+    // post-compact size is not under-reported.
+    const lastWindow = l ? contextWindowOccupancy(l) : 0;
+    let contextLength = opts.lastPostTokens;
+    if (contextLength === 0 || lastWindow > contextLength) {
+        contextLength = lastWindow;
+    }
+    // 非累计字段 = 末轮（本 run）scope，累计字段 = session 总和（所有 run）。
+    // 对齐 codex reader 语义（§9.21：`last_token_usage`=单 turn 增量、
+    // `total_token_usage`=session 累计）——否则 jsonl 兜底路径会把 session 累计
+    // 当成"本 run"显示，与卡片"本 run ≤ 累计"不变量冲突（累计反而更小）。
+    const lastTotal = turn.input + turn.output + turn.cacheRead + turn.cacheCreation;
+    return {
+        inputTokens: turn.input,
+        outputTokens: turn.output,
+        contextLength,
+        compactCount: opts.compactCount,
+        cacheReadTokens: turn.cacheRead > 0 ? turn.cacheRead : undefined,
+        cacheCreationTokens: turn.cacheCreation > 0 ? turn.cacheCreation : undefined,
+        totalTokens: lastTotal,
+        ...cumulativeUsageFields(t),
+    };
+}
 /**
  * first-pass scan: stream the file once via `scanJsonlLines`
  * (no `string[]` materialized), parse each line exactly once, and collect
@@ -279,20 +360,25 @@ function isRealUserPrompt(obj) {
  * recap, lastUserMessage). Does NOT retain parsed objects — the events tail
  * is re-parsed separately by `extractEventsFromTail` so memory for both raw
  * line strings and parsed objects is O(tail), not O(whole file).
+ *
+ * 主体是分发表：每类行只收集自己的标量（assistant → usage 并表、
+ * compact_boundary → 计数 + postTokens、user → tail 定位/标题、ai-title）；
+ * usage 的逐字段 max 合并（maxUsageRecord）与装配（buildClaudeUsage）已
+ * 独立成纯函数。
  */
 function scalarScan(filePath) {
-    const acc = new UsageAccumulator();
     // Per-message-id best usage record (per-field max). A streaming assistant
     // message spans multiple jsonl lines sharing the same message id; some
     // backends (third-party gateways, e.g. DeepSeek) write all-zero usage on
     // the early placeholder lines (empty thinking block) and the real usage
     // only on the final line carrying stop_reason. First-occurrence-wins dedup
-    // would pin the zero record and discard the real one (regression
-    // 2026-08-19: auto-resume card per-run stats all 0). Per-field max
+    // would pin the zero record and discard the real one (auto-resume
+    // card per-run stats all 0). Per-field max
     // reconstructs the full usage regardless of line order — on the official
     // API every line repeats identical usage, so max is a no-op there.
     const usageByMessageId = new Map();
     let lastPostTokens = 0;
+    let compactCount = 0;
     let tailOffset = -1;
     /** 真人 prompt 序号；末个 turn = 当前值。sidechain/注入/工具结果不递增。 */
     let turnSeq = 0;
@@ -307,19 +393,12 @@ function scalarScan(filePath) {
             if (usage) {
                 const msgId = msg?.id;
                 if (msgId) {
-                    const prev = usageByMessageId.get(msgId);
-                    usageByMessageId.set(msgId, {
-                        input: Math.max(prev?.input ?? 0, usage.input_tokens ?? 0),
-                        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,
-                    });
+                    usageByMessageId.set(msgId, maxUsageRecord(usageByMessageId.get(msgId), usage, turnSeq));
                 }
             }
         }
         if (obj.type === 'system' && obj.subtype === 'compact_boundary') {
-            acc.bumpCompact();
+            compactCount++;
             const cm = obj.compactMetadata;
             if (cm?.postTokens) {
                 lastPostTokens = cm.postTokens;
@@ -372,62 +451,9 @@ function scalarScan(filePath) {
         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. 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
-    // contract — excludes output/reasoning, which are generated, not part of
-    // the input window). Take the max so a pre-compact turn larger than the
-    // post-compact size is not under-reported.
-    const lastWindow = l ? contextWindowOccupancy(l) : 0;
-    let contextLength = lastPostTokens;
-    if (contextLength === 0 || lastWindow > contextLength) {
-        contextLength = lastWindow;
-    }
-    // 非累计字段 = 末轮（本 run）scope，累计字段 = session 总和（所有 run）。
-    // 对齐 codex reader 语义（§9.21：`last_token_usage`=单 turn 增量、
-    // `total_token_usage`=session 累计）——否则 jsonl 兜底路径会把 session 累计
-    // 当成"本 run"显示，与卡片"本 run ≤ 累计"不变量冲突（累计反而更小）。
-    const lastTotal = turn.input + turn.output + turn.cacheRead + turn.cacheCreation;
-    const usage = {
-        inputTokens: turn.input,
-        outputTokens: turn.output,
-        contextLength,
-        compactCount: acc.compactCount,
-        cacheReadTokens: turn.cacheRead > 0 ? turn.cacheRead : undefined,
-        cacheCreationTokens: turn.cacheCreation > 0 ? turn.cacheCreation : undefined,
-        totalTokens: lastTotal,
-        ...cumulativeUsageFields(t),
-    };
     return {
         tailOffset,
-        usage,
+        usage: buildClaudeUsage(usageByMessageId.values(), { turnSeq, lastPostTokens, compactCount }),
         aiTitle: lastAiTitle,
         recap: lastRecap,
         lastUserMessage,

package/dist/session/codex/rollout-reader.js

@@ -132,7 +132,7 @@ function scanCodexRollout(filePath, includeEvents) {
     // (see `extractRealUserText`). Injected scaffolding (project rules,
     // <environment_context>, permissions) is written as `role:"user"`
     // response_items but gets NEITHER event, so it stays excluded from
-    // displayTitle/recap/summary. Regression 2026-07-13: the first `role:user`
+    // displayTitle/recap/summary. Without this, the first `role:user`
     // message is the injected project rules, mistakenly shown as "最近输入".
     const realUserMessages = [];
     // Which channel produced the last pushed message — used only to collapse a
@@ -298,7 +298,7 @@ function scanCodexRollout(filePath, includeEvents) {
     }
     // 兼容性漂移探针：文件里有 `role:"user"` 注入，却识别不出任何真人输入 ——
     // 说明 codex 又换了 event_msg 词表，displayTitle 会静默变空（0.153 事故形态）。
-    // 只告警不兜底：误用注入文本当标题正是 2026-07-13 修掉的缺陷。
+    // 只告警不兜底：误用注入文本当标题是已修掉的缺陷。
     if (realUserMessages.length === 0 && userResponseItemCount > 0) {
         getLogger().warn(`[codex-rollout-reader] no human user message recognised in ${filePath} ` +
             `(${userResponseItemCount} role:"user" response_items seen) — codex rollout ` +
@@ -720,7 +720,7 @@ export function clearSessionIndexCache() {
  *   event. Codex emitted it ONLY for text the human actually typed; injected
  *   scaffolding (project rules, `<environment_context>`, permissions) is
  *   written as `role:"user"` response_items but gets NO such event, so it stays
- *   out of displayTitle/recap/summary. (Regression 2026-07-13: the first
+ *   out of displayTitle/recap/summary. (Without this, the first
  *   `role:user` message is the injected project rules, once shown as 最近输入.)
  * - Current (CLI ≥0.153.4, transitional from 0.147.0): the `user_message` /
  *   `agent_message` events were removed; the same authoritative text now rides
@@ -729,7 +729,7 @@ export function clearSessionIndexCache() {
  *   input, `skill` parts are injected skill files (e.g. a `$skill-name`
  *   invocation) that must not leak into the title.
  *
- * Real-data note (2026-09): no rollout file observed carries BOTH spellings;
+ * Real-data note: no rollout file observed carries BOTH spellings;
  * 0.147–0.149 are transitional (either spelling per file), 0.153.4+/0.154.0 are
  * item_completed-only. `source` reports which spelling matched so the scanner
  * can collapse a hypothetical double-write of the same turn.

package/dist/session/common/throw-session-list-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * session list 故障路径的统一出口：error 日志 + 抛契约文案 + cause 保留。
+ *
+ * 契约红线：错误文案固定为 `<agent> session list 读取失败: <msg>`（逐字节），
+ * router 靠它展示「列表失败」——静默 [] 会让用户误以为没有 session，
+ * 与真空不可区分。
+ *
+ * 各家 ENOENT → 优雅空态的分支是正常路径，留在调用点，不经过这里。
+ */
+export declare function throwSessionListError(agent: string, err: unknown): never;

package/dist/session/common/throw-session-list-error.js

@@ -0,0 +1,16 @@
+import { getLogger } from '../../logger/index.js';
+/**
+ * session list 故障路径的统一出口：error 日志 + 抛契约文案 + cause 保留。
+ *
+ * 契约红线：错误文案固定为 `<agent> session list 读取失败: <msg>`（逐字节），
+ * router 靠它展示「列表失败」——静默 [] 会让用户误以为没有 session，
+ * 与真空不可区分。
+ *
+ * 各家 ENOENT → 优雅空态的分支是正常路径，留在调用点，不经过这里。
+ */
+export function throwSessionListError(agent, err) {
+    getLogger().error(`[${agent}-session-reader] session list failed: ${err}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`${agent} session list 读取失败: ${msg}`, { cause: err });
+}
+//# sourceMappingURL=throw-session-list-error.js.map

package/dist/session/dsh/sessions.js

@@ -211,8 +211,12 @@ export class DshSessionReader {
             return { sessions: page, total };
         }
         catch (error) {
-            getLogger().error(`[dsh-session-reader] listSessions error: ${error.message}`);
-            return { sessions: [], total: 0 };
+            // 远端 RPC 没有真空态：daemon 未启动 / cookie 失效 / 超时全是故障态。
+            // error 日志 + 上抛，router 显示「列表失败」——静默 [] 会让用户误以为
+            // 没有 session，与真空不可区分（与 kimi/opencode 同口径）。
+            getLogger().error(`[dsh-session-reader] listSessions failed: ${error}`);
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`dsh session list 读取失败: ${msg}`, { cause: error });
         }
     }
     getNewestSession(cwd) {
@@ -358,7 +362,9 @@ export class DshSessionReader {
             };
         }
         catch (error) {
-            getLogger().error(`[dsh-session-reader] readSessionContent error: ${error.message}`);
+            // 降级为空卡（与 claude/pi 同口径），但完整错误对象入日志保留 stack，
+            // 否则 wire 截断 / 权限问题只剩一句 message 无法定位。
+            getLogger().error(`[dsh-session-reader] readSessionContent failed: ${error}`);
             return { events: [] };
         }
     }
@@ -367,7 +373,7 @@ export class DshSessionReader {
             return this.resolveSession(sessionId, cwd)?.running === true;
         }
         catch (error) {
-            getLogger().error(`[dsh-session-reader] isSessionActive error: ${error.message}`);
+            getLogger().error(`[dsh-session-reader] isSessionActive failed: ${error}`);
             return false;
         }
     }
@@ -535,7 +541,7 @@ function mapEvent(ev) {
             const timestamp = safeEventTimestamp(ev.time);
             // DSH 的块类型是 text / reasoning / tool-call（不是 Anthropic 的
             // thinking）。只认 text 会让 resume 卡"只有工具调用、没有思考与输出"
-            // （2026-10-19 反馈：一个 31 turn 的会话里 reasoning 块 371 个、text 12 个，
+            // （一个 31 turn 的会话里 reasoning 块 371 个、text 12 个，
             // 全被丢掉）。tool-call 块不在这里取——独立的 `tool/call` 事件带完整参数。
             for (const block of content) {
                 const text = typeof block.text === 'string' ? block.text.trim() : '';