lark-remote 0.1.11 → 0.1.13

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

@@ -18,6 +18,7 @@ import path from 'node:path';
 import { readJsonlLines, findJsonlLine } from '../common/jsonl.js';
 import { STALE_MS } from '../common/constants.js';
 import { paginate, capEvents } from '../common/pagination.js';
+import { sortByRecencyDesc } from '../common/recency.js';
 import { getLogger } from '../../logger/index.js';
 import { isRecord, stringValue } from '../../common/guards.js';
 import { resolveCodexHome } from '../../config/codex-config.js';
@@ -35,130 +36,8 @@ export function readCodexRollout(filePath) {
         return null;
     }
     try {
-        const lines = readJsonlLines(filePath);
-        const events = [];
-        let sessionMeta = null;
-        // Real user input is identified by a paired `event_msg` whose
-        // payload.type === "user_message" - codex emits this ONLY for text the
-        // human actually typed. Injected scaffolding (project rules,
-        // <environment_context>, permissions) is also written as `role:"user"`
-        // response_items but has NO user_message event, so it must be excluded
-        // from displayTitle/recap/summary. Regression 2026-07-13: the first
-        // `role:user` message is the injected project rules, mistakenly shown as
-        // "最近输入".
-        const realUserMessages = [];
-        // token_count tracking: codex emits cumulative `total_token_usage` and an
-        // incremental `last_token_usage`. We want the LAST turn's usage (matches
-        // pi/opencode /resume "last turn" display semantics). When
-        // last_token_usage is absent we derive it as total - previous_total.
-        let lastRawUsage;
-        // Context window limit from the same token_count event as lastRawUsage
-        // (codex reports info.model_context_window per turn; absent on old data).
-        let lastContextLimit;
-        // Final total_token_usage (cumulative across the whole session) for the
-        // Run card's "累计" display. Codex emits this alongside last_token_usage.
-        let lastTotalUsage;
-        let previousTotals;
-        // Compaction 统计：codex 的 compact turn 在会话文件里写顶层 `compacted`
-        // 事件（含摘要），压缩前后的上下文水位由相邻 token_count 表达。压缩收尾的
-        // token_count 增量是 input/cached/output 全 0、只有 total_tokens 有值
-        // （窗口被摘要+replacement history 占据），现有 zero-filter 会跳过它，
-        // 因此这里必须单独捕获，不能复用 lastRawUsage。
-        // 单位口径（review P3-9）：前后两侧统一用 total_tokens —— 压缩前取最近一次
-        // 非零 token_count 的 total_tokens（input+output，即该 turn 在窗口内的全部
-        // token），压缩后取收尾事件的 total_tokens（压缩后窗口）。不得一边 input
-        // 一边 total，否则「压缩前 X → 压缩后 Y」两边单位不一致。
-        let compactCount = 0;
-        let compactPreContextLength;
-        let compactPostContextLength;
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                if (!parsed || typeof parsed.type !== 'string')
-                    continue;
-                if (parsed.type === 'session_meta' && parsed.payload) {
-                    sessionMeta = parsed.payload;
-                }
-                else if (parsed.type === 'event_msg' && parsed.payload) {
-                    // user_message events carry the authoritative human-typed text.
-                    const payload = parsed.payload;
-                    if (payload.type === 'user_message') {
-                        const text = stringValue(payload.message);
-                        if (text) {
-                            realUserMessages.push(text.slice(0, 200));
-                        }
-                    }
-                    else if (payload.type === 'token_count') {
-                        const info = payload.info;
-                        const last = info?.last_token_usage;
-                        const total = info?.total_token_usage;
-                        let raw;
-                        if (last) {
-                            raw = last;
-                        }
-                        else if (total && previousTotals) {
-                            raw = subtractRawUsage(total, previousTotals);
-                        }
-                        else {
-                            raw = total;
-                        }
-                        if (total) {
-                            previousTotals = total;
-                            lastTotalUsage = total;
-                        }
-                        if (raw && (raw.input_tokens || raw.cached_input_tokens || raw.output_tokens)) {
-                            lastRawUsage = raw;
-                            const ctxWindow = info?.model_context_window;
-                            lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
-                        }
-                        // 压缩后的水位：压缩收尾 token_count 全 0（raw 不满足上面 zero-filter），
-                        // 但 total_tokens 表达真实窗口；之后若出现普通 turn（input>0），
-                        // 水位回归该 turn，post-compact 值失效。
-                        if (compactCount > 0 && raw) {
-                            if (raw.total_tokens &&
-                                !raw.input_tokens &&
-                                !raw.cached_input_tokens &&
-                                !raw.output_tokens) {
-                                compactPostContextLength = raw.total_tokens;
-                            }
-                            else if (raw.input_tokens > 0) {
-                                compactPostContextLength = undefined;
-                            }
-                        }
-                    }
-                }
-                else if (parsed.type === 'compacted') {
-                    // 顶层 compacted 事件：压缩次数 +1，压缩前水位取最近一次非零 token_count。
-                    compactCount++;
-                    if (lastRawUsage?.total_tokens !== undefined) {
-                        compactPreContextLength = lastRawUsage.total_tokens;
-                    }
-                }
-                else if (parsed.type === 'response_item' && parsed.payload) {
-                    const payload = parsed.payload;
-                    if (payload.type === 'message' && Array.isArray(payload.content)) {
-                        // Extract text content for display
-                        const messages = extractMessageContent(payload);
-                        for (const msg of messages) {
-                            events.push({
-                                type: msg.role === 'user' ? 'user' : 'assistant',
-                                content: msg.text,
-                                timestamp: parsed.timestamp,
-                            });
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip malformed lines
-                continue;
-            }
-        }
-        const firstUserMessage = realUserMessages[0] ?? '';
-        const lastRealUserMessage = realUserMessages[realUserMessages.length - 1] ?? '';
+        const scan = scanCodexRollout(filePath, true);
+        const { sessionMeta } = scan;
         if (!sessionMeta) {
             return null;
         }
@@ -167,62 +46,18 @@ export function readCodexRollout(filePath) {
         if (!sessionId) {
             return null;
         }
-        // Use file mtime as updatedAtMs, or parse timestamp from session_meta
         const stats = fs.statSync(filePath);
-        const createdAtMs = sessionMeta.timestamp
-            ? new Date(String(sessionMeta.timestamp)).getTime()
-            : stats.birthtimeMs;
         const updatedAtMs = stats.mtimeMs;
-        // Build ccusage-aligned usage from the last turn's raw tokens.
-        // input = raw - cached (codex reports cached input separately), cache
-        // creation is never reported by codex, reasoning is a subset of output
-        // (display-only, never added to total).
-        // contextLength = input_tokens (= (input_tokens-cached) + cached + 0),
-        // i.e. input + cacheRead + cacheCreation — the unified context-window
-        // occupancy contract across all five readers (review P2-8, excludes
-        // output/reasoning).
-        let usage;
-        if (lastRawUsage) {
-            const r = lastRawUsage;
-            const cached = Math.min(r.cached_input_tokens, r.input_tokens);
-            usage = {
-                inputTokens: r.input_tokens - cached,
-                outputTokens: r.output_tokens,
-                contextLength: r.input_tokens,
-                contextLimit: lastContextLimit,
-                cacheReadTokens: cached,
-                cacheCreationTokens: 0,
-                totalTokens: r.total_tokens,
-            };
-            // Cumulative from the final total_token_usage (non-cached input +
-            // output), summed across all turns in the session.
-            if (lastTotalUsage) {
-                const cumCached = Math.min(lastTotalUsage.cached_input_tokens, lastTotalUsage.input_tokens);
-                usage.cumulativeInputTokens = lastTotalUsage.input_tokens - cumCached;
-                usage.cumulativeOutputTokens = lastTotalUsage.output_tokens;
-                usage.cumulativeTotalTokens = lastTotalUsage.total_tokens;
-                usage.cumulativeCacheReadTokens = cumCached;
-                usage.cumulativeCacheCreationTokens = 0; // Codex 不报告 cache creation
-            }
-            // 压缩统计：会话内出现过 compacted 事件就计数（供 /resume 与 Compact 卡
-            // 展示）；仅当会话以压缩收尾时（post-compact 水位存在），contextLength
-            // 覆盖为压缩后水位并暴露压缩前水位——后续还有普通 turn 时水位回归该 turn。
-            if (compactCount > 0) {
-                usage.compactCount = compactCount;
-                if (compactPostContextLength !== undefined) {
-                    usage.contextLength = compactPostContextLength;
-                    usage.compactPreContextLength = compactPreContextLength;
-                }
-            }
-        }
+        const firstUserMessage = scan.realUserMessages[0] ?? '';
+        const lastRealUserMessage = scan.realUserMessages[scan.realUserMessages.length - 1] ?? '';
+        const usage = buildUsageFromScan(scan);
         return {
             threadId: sessionId,
             cwd,
             firstUserMessage: firstUserMessage || '(no user message)',
             lastRealUserMessage,
-            createdAtMs,
             updatedAtMs,
-            events,
+            events: scan.events,
             usage,
         };
     }
@@ -231,6 +66,222 @@ export function readCodexRollout(filePath) {
         return null;
     }
 }
+/**
+ * Lightweight single-file scan that extracts only the display-relevant fields
+ * (last real user message + usage) — **without** constructing the `events`
+ * array. Backs `readCodexSessionSummary` so the `/resume` list prefetch does
+ * not pay the cost of JSON.parse-ing every response_item and building events
+ * that are immediately discarded.
+ *
+ * Returns null if the file doesn't exist, is corrupted, or has no session_meta.
+ */
+function readCodexRolloutSummary(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const scan = scanCodexRollout(filePath, false);
+        if (!scan.sessionMeta)
+            return null;
+        return {
+            lastRealUserMessage: scan.realUserMessages[scan.realUserMessages.length - 1] ?? '',
+            usage: buildUsageFromScan(scan),
+        };
+    }
+    catch (err) {
+        getLogger().warn(`[codex-rollout-reader] failed to read summary ${filePath}: ${err}`);
+        return null;
+    }
+}
+/**
+ * Scan a rollout file once, tracking user messages, usage and compaction state.
+ * When `includeEvents` is true, response_item content is also extracted into
+ * `events`; when false, response_item lines are skipped entirely (the summary
+ * fast path).
+ */
+function scanCodexRollout(filePath, includeEvents) {
+    const lines = readJsonlLines(filePath);
+    const events = [];
+    let sessionMeta = null;
+    // Real user input is identified by a paired `event_msg` whose
+    // payload.type === "user_message" - codex emits this ONLY for text the
+    // human actually typed. Injected scaffolding (project rules,
+    // <environment_context>, permissions) is also written as `role:"user"`
+    // response_items but has NO user_message event, so it must be excluded
+    // from displayTitle/recap/summary. Regression 2026-07-13: the first
+    // `role:user` message is the injected project rules, mistakenly shown as
+    // "最近输入".
+    const realUserMessages = [];
+    // token_count tracking: codex emits cumulative `total_token_usage` and an
+    // incremental `last_token_usage`. We want the LAST turn's usage (matches
+    // pi/opencode /resume "last turn" display semantics). When
+    // last_token_usage is absent we derive it as total - previous_total.
+    let lastRawUsage;
+    // Context window limit from the same token_count event as lastRawUsage
+    // (codex reports info.model_context_window per turn; absent on old data).
+    let lastContextLimit;
+    // Final total_token_usage (cumulative across the whole session) for the
+    // Run card's "累计" display. Codex emits this alongside last_token_usage.
+    let lastTotalUsage;
+    let previousTotals;
+    // Compaction 统计：codex 的 compact turn 在会话文件里写顶层 `compacted`
+    // 事件（含摘要），压缩前后的上下文水位由相邻 token_count 表达。压缩收尾的
+    // token_count 增量是 input/cached/output 全 0、只有 total_tokens 有值
+    // （窗口被摘要+replacement history 占据），现有 zero-filter 会跳过它，
+    // 因此这里必须单独捕获，不能复用 lastRawUsage。
+    // 单位口径（review P3-9）：前后两侧统一用 total_tokens —— 压缩前取最近一次
+    // 非零 token_count 的 total_tokens（input+output，即该 turn 在窗口内的全部
+    // token），压缩后取收尾事件的 total_tokens（压缩后窗口）。不得一边 input
+    // 一边 total，否则「压缩前 X → 压缩后 Y」两边单位不一致。
+    let compactCount = 0;
+    let compactPreContextLength;
+    let compactPostContextLength;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!parsed || typeof parsed.type !== 'string')
+                continue;
+            if (parsed.type === 'session_meta' && parsed.payload) {
+                sessionMeta = parsed.payload;
+            }
+            else if (parsed.type === 'event_msg' && parsed.payload) {
+                // user_message events carry the authoritative human-typed text.
+                const payload = parsed.payload;
+                if (payload.type === 'user_message') {
+                    const text = stringValue(payload.message);
+                    if (text) {
+                        realUserMessages.push(text.slice(0, 200));
+                    }
+                }
+                else if (payload.type === 'token_count') {
+                    const info = payload.info;
+                    const last = info?.last_token_usage;
+                    const total = info?.total_token_usage;
+                    let raw;
+                    if (last) {
+                        raw = last;
+                    }
+                    else if (total && previousTotals) {
+                        raw = subtractRawUsage(total, previousTotals);
+                    }
+                    else {
+                        raw = total;
+                    }
+                    if (total) {
+                        previousTotals = total;
+                        lastTotalUsage = total;
+                    }
+                    if (raw && (raw.input_tokens || raw.cached_input_tokens || raw.output_tokens)) {
+                        lastRawUsage = raw;
+                        const ctxWindow = info?.model_context_window;
+                        lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
+                    }
+                    // 压缩后的水位：压缩收尾 token_count 全 0（raw 不满足上面 zero-filter），
+                    // 但 total_tokens 表达真实窗口；之后若出现普通 turn（input>0），
+                    // 水位回归该 turn，post-compact 值失效。
+                    if (compactCount > 0 && raw) {
+                        if (raw.total_tokens &&
+                            !raw.input_tokens &&
+                            !raw.cached_input_tokens &&
+                            !raw.output_tokens) {
+                            compactPostContextLength = raw.total_tokens;
+                        }
+                        else if (raw.input_tokens > 0) {
+                            compactPostContextLength = undefined;
+                        }
+                    }
+                }
+            }
+            else if (parsed.type === 'compacted') {
+                // 顶层 compacted 事件：压缩次数 +1，压缩前水位取最近一次非零 token_count。
+                compactCount++;
+                if (lastRawUsage?.total_tokens !== undefined) {
+                    compactPreContextLength = lastRawUsage.total_tokens;
+                }
+            }
+            else if (includeEvents && parsed.type === 'response_item' && parsed.payload) {
+                const payload = parsed.payload;
+                if (payload.type === 'message' && Array.isArray(payload.content)) {
+                    // Extract text content for display
+                    const messages = extractMessageContent(payload);
+                    for (const msg of messages) {
+                        events.push({
+                            type: msg.role === 'user' ? 'user' : 'assistant',
+                            content: msg.text,
+                            timestamp: parsed.timestamp,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+            continue;
+        }
+    }
+    return {
+        sessionMeta,
+        events,
+        realUserMessages,
+        lastRawUsage,
+        lastContextLimit,
+        lastTotalUsage,
+        previousTotals,
+        compactCount,
+        compactPreContextLength,
+        compactPostContextLength,
+    };
+}
+/**
+ * Build ccusage-aligned usage from a scan's last-turn raw tokens.
+ * input = raw - cached (codex reports cached input separately), cache
+ * creation is never reported by codex, reasoning is a subset of output
+ * (display-only, never added to total).
+ * contextLength = input_tokens (= (input_tokens-cached) + cached + 0),
+ * i.e. input + cacheRead + cacheCreation — the unified context-window
+ * occupancy contract across all five readers (review P2-8, excludes
+ * output/reasoning).
+ */
+function buildUsageFromScan(scan) {
+    const { lastRawUsage, lastContextLimit, lastTotalUsage, compactCount, compactPreContextLength, compactPostContextLength, } = scan;
+    if (!lastRawUsage)
+        return undefined;
+    const r = lastRawUsage;
+    const cached = Math.min(r.cached_input_tokens, r.input_tokens);
+    const usage = {
+        inputTokens: r.input_tokens - cached,
+        outputTokens: r.output_tokens,
+        contextLength: r.input_tokens,
+        contextLimit: lastContextLimit,
+        cacheReadTokens: cached,
+        cacheCreationTokens: 0,
+        totalTokens: r.total_tokens,
+    };
+    // Cumulative from the final total_token_usage (non-cached input +
+    // output), summed across all turns in the session.
+    if (lastTotalUsage) {
+        const cumCached = Math.min(lastTotalUsage.cached_input_tokens, lastTotalUsage.input_tokens);
+        usage.cumulativeInputTokens = lastTotalUsage.input_tokens - cumCached;
+        usage.cumulativeOutputTokens = lastTotalUsage.output_tokens;
+        usage.cumulativeTotalTokens = lastTotalUsage.total_tokens;
+        usage.cumulativeCacheReadTokens = cumCached;
+        usage.cumulativeCacheCreationTokens = 0; // Codex 不报告 cache creation
+    }
+    // 压缩统计：会话内出现过 compacted 事件就计数（供 /resume 与 Compact 卡
+    // 展示）；仅当会话以压缩收尾时（post-compact 水位存在），contextLength
+    // 覆盖为压缩后水位并暴露压缩前水位——后续还有普通 turn 时水位回归该 turn。
+    if (compactCount > 0) {
+        usage.compactCount = compactCount;
+        if (compactPostContextLength !== undefined) {
+            usage.contextLength = compactPostContextLength;
+            usage.compactPreContextLength = compactPreContextLength;
+        }
+    }
+    return usage;
+}
 /**
  * List Codex sessions from rollout files.
  *
@@ -261,7 +312,7 @@ export function listCodexRollouts(opts = {}) {
     // Establish the global order by mtime desc, then slice the page.
     // Same-mtime ties use filePath as a deterministic secondary key so index
     // rebuilds / walk order changes never reorder the page.
-    matched.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
+    sortByRecencyDesc(matched, (e) => e.mtimeMs, (e) => e.filePath);
     const { items: page, total } = paginate(matched, { limit: opts.limit, offset: opts.offset });
     // Full-parse only the page being returned (summary/usage).
     const entries = [];
@@ -327,6 +378,41 @@ export function readCodexSessionContent(sessionId, opts = {}) {
         usage: rollout.usage,
     };
 }
+/**
+ * Read the summary (title + usage, no events) of a specific session by id.
+ *
+ * Mirrors `readCodexSessionContent`'s index lookup + cwd guard, but uses the
+ * lightweight `readCodexRolloutSummary` instead of the full parse — so the
+ * `/resume` list prefetch never constructs the events array it would discard.
+ */
+export function readCodexSessionSummary(sessionId, opts = {}) {
+    const codexHome = resolveCodexHome(opts.codexHome);
+    let index = getSessionIndex(codexHome);
+    let entry = index.get(sessionId);
+    if (!entry) {
+        index = getSessionIndex(codexHome, true);
+        entry = index.get(sessionId);
+    }
+    if (!entry) {
+        return {};
+    }
+    // Cwd guard: same semantics as readCodexSessionContent — when a cwd is
+    // provided, the session's working directory must match.
+    if (opts.cwd && entry.cwd !== opts.cwd) {
+        return {};
+    }
+    const summary = readCodexRolloutSummary(entry.filePath);
+    if (!summary) {
+        return {};
+    }
+    return {
+        // displayTitle = LAST real user message (matches the "最近输入" label).
+        displayTitle: summary.lastRealUserMessage || undefined,
+        // codex has no compact-summary concept, so recap is never faked.
+        recap: undefined,
+        usage: summary.usage,
+    };
+}
 /**
  * Check if a session is still active (recently updated).
  *

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

@@ -1,4 +1,4 @@
-import type { AgentSession, SessionContent, AgentSessionReader } from '../../runner/index.js';
+import type { AgentSession, SessionContent, SessionSummary, AgentSessionReader } from '../../runner/index.js';
 interface CodexSessionReaderOptions {
     codexHome?: string;
 }
@@ -16,6 +16,7 @@ export declare class CodexSessionReader implements AgentSessionReader {
     readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
+    readSessionSummary(sessionId: string, cwd: string): SessionSummary;
     isSessionActive(sessionId: string, cwd: string): boolean;
 }
 export {};

package/dist/session/codex/sessions.js

@@ -1,5 +1,5 @@
 import { resolveCodexHome } from '../../config/codex-config.js';
-import { listCodexRollouts, readCodexSessionContent, isCodexSessionActive, } from './rollout-reader.js';
+import { listCodexRollouts, readCodexSessionContent, readCodexSessionSummary, isCodexSessionActive, } from './rollout-reader.js';
 export class CodexSessionReader {
     codexHome;
     constructor(opts = {}) {
@@ -34,6 +34,9 @@ export class CodexSessionReader {
             cwd,
         });
     }
+    readSessionSummary(sessionId, cwd) {
+        return readCodexSessionSummary(sessionId, { codexHome: this.codexHome, cwd });
+    }
     isSessionActive(sessionId, cwd) {
         return isCodexSessionActive(sessionId, { codexHome: this.codexHome, cwd });
     }

package/dist/session/common/pagination.d.ts

@@ -7,8 +7,6 @@
  * drifted on the default limit). Centralized here so the contract is defined
  * once: default page limit is 20, matching the majority of readers.
  */
-/** Default page size for listSessions. */
-export declare const DEFAULT_LIST_LIMIT = 20;
 /**
  * Paginate a (already-ordered) full item list by offset + limit.
  * Clamps negative offset to 0; caps limit to the remaining items.

package/dist/session/common/pagination.js

@@ -8,7 +8,7 @@
  * once: default page limit is 20, matching the majority of readers.
  */
 /** Default page size for listSessions. */
-export const DEFAULT_LIST_LIMIT = 20;
+const DEFAULT_LIST_LIMIT = 20;
 /**
  * Paginate a (already-ordered) full item list by offset + limit.
  * Clamps negative offset to 0; caps limit to the remaining items.

package/dist/session/common/recency.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Session-list ordering invariant shared by every reader: newest first,
+ * with a deterministic id tie-break so index rebuilds / walk-order changes
+ * never reorder a page (codex red line: never break out of a partial order).
+ */
+/** 「时间降序 + id 字典序 tie-break」原地排序（原先 6 处内联拷贝）。 */
+export declare function sortByRecencyDesc<T>(items: T[], time: (item: T) => number, id: (item: T) => string): void;

package/dist/session/common/recency.js

@@ -0,0 +1,10 @@
+/**
+ * Session-list ordering invariant shared by every reader: newest first,
+ * with a deterministic id tie-break so index rebuilds / walk-order changes
+ * never reorder a page (codex red line: never break out of a partial order).
+ */
+/** 「时间降序 + id 字典序 tie-break」原地排序（原先 6 处内联拷贝）。 */
+export function sortByRecencyDesc(items, time, id) {
+    items.sort((a, b) => time(b) - time(a) || id(a).localeCompare(id(b)));
+}
+//# sourceMappingURL=recency.js.map

package/dist/session/common/usage-accumulator.d.ts

@@ -55,4 +55,18 @@ export declare class UsageAccumulator {
      */
     bumpCompact(): void;
 }
+/** P2-8 统一契约：上下文窗口占用 = 末轮 input + cacheRead + cacheCreation（不含 output/reasoning）。 */
+export declare function contextWindowOccupancy(l: {
+    input: number;
+    cacheRead: number;
+    cacheCreation: number;
+}): number;
+/** P2-8 统一契约：session 全量累计字段组装（4 个 reader 共用：claude/dsh/kimi/pi；
+ * codex 走 last_token_usage 口径、opencode 保留自己的条件赋值，原为逐字段复制的 4 连拷贝）。 */
+export declare function cumulativeUsageFields(t: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+}): Pick<import('../../runner/types.js').AgentSessionUsage, 'cumulativeTotalTokens' | 'cumulativeInputTokens' | 'cumulativeOutputTokens' | 'cumulativeCacheReadTokens' | 'cumulativeCacheCreationTokens'>;
 export {};

package/dist/session/common/usage-accumulator.js

@@ -69,4 +69,19 @@ export class UsageAccumulator {
         this._compactCount++;
     }
 }
+/** P2-8 统一契约：上下文窗口占用 = 末轮 input + cacheRead + cacheCreation（不含 output/reasoning）。 */
+export function contextWindowOccupancy(l) {
+    return l.input + l.cacheRead + l.cacheCreation;
+}
+/** P2-8 统一契约：session 全量累计字段组装（4 个 reader 共用：claude/dsh/kimi/pi；
+ * codex 走 last_token_usage 口径、opencode 保留自己的条件赋值，原为逐字段复制的 4 连拷贝）。 */
+export function cumulativeUsageFields(t) {
+    return {
+        cumulativeTotalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
+        cumulativeInputTokens: t.input,
+        cumulativeOutputTokens: t.output,
+        cumulativeCacheReadTokens: t.cacheRead,
+        cumulativeCacheCreationTokens: t.cacheCreation,
+    };
+}
 //# sourceMappingURL=usage-accumulator.js.map

package/dist/session/dsh/sessions.js

@@ -13,6 +13,8 @@
  *   session-wide usage accumulation (assistant/message.usage).
  */
 import { spawnSync } from 'node:child_process';
+import { cumulativeUsageFields } from '../common/usage-accumulator.js';
+import { sortByRecencyDesc } from '../common/recency.js';
 import { getLogger } from '../../logger/index.js';
 import { DEFAULT_DSH_HOST } from '../../config/index.js';
 import { capEvents, paginate } from '../common/pagination.js';
@@ -81,13 +83,13 @@ export class DshSessionReader {
             const items = value.items ?? [];
             const filtered = items
                 .filter((i) => i.cwd === cwd)
-                .sort((a, b) => b.updatedAt - a.updatedAt || String(a.sessionId).localeCompare(String(b.sessionId)))
                 .map((i) => ({
                 sessionId: String(i.sessionId),
                 summary: '',
                 mtime: i.updatedAt,
                 ...(i.agentPreset ? { agentPreset: i.agentPreset } : {}),
             }));
+            sortByRecencyDesc(filtered, (i) => i.mtime, (i) => i.sessionId);
             const { items: page, total } = paginate(filtered, opts ?? {});
             return { sessions: page, total };
         }
@@ -147,11 +149,12 @@ export class DshSessionReader {
                     cacheReadTokens: cacheRead,
                     cacheCreationTokens: cacheWrite,
                     totalTokens: input + output + cacheRead + cacheWrite,
-                    cumulativeTotalTokens: cumInput + cumOutput + cumCacheRead + cumCacheWrite,
-                    cumulativeInputTokens: cumInput,
-                    cumulativeOutputTokens: cumOutput,
-                    cumulativeCacheReadTokens: cumCacheRead,
-                    cumulativeCacheCreationTokens: cumCacheWrite,
+                    ...cumulativeUsageFields({
+                        input: cumInput,
+                        output: cumOutput,
+                        cacheRead: cumCacheRead,
+                        cacheCreation: cumCacheWrite,
+                    }),
                 };
             }
             return {