lark-remote 0.1.11 → 0.1.13

package/dist/runner/opencode/acp/error-monitor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
+ * errors of the active ACP session and reports them immediately.
+ *
+ * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * to the client over the ACP protocol. Its session/update notifications are
+ * limited to content deltas (agent_message_chunk / agent_thought_chunk /
+ * tool_call / tool_call_update), usage and available-commands updates — there
+ * is no error/retry/status event type, and session/list carries no status.
+ * When a retryable provider error hits (e.g. opencode-go "Weekly usage limit
+ * reached"), the session enters a retry backoff (often the full reset time,
+ * ~1h) and session/prompt stays pending with zero events, so the client would
+ * hang until its own idle watchdog.
+ *
+ * The only channel that carries the real error is opencode's own log file
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`), where every LLM stream
+ * failure is written as `message="stream error" ... session.id=<id>
+ * small=false ... error.error="<reason>"`.
+ *
+ * This monitor tails the log (delta from the turn-start offset), scoped to
+ * the active sessionId + `small=false` (main turn; the `small=true` title
+ * stream must not kill the turn). Only limit/quota-class errors trigger the
+ * callback — they are the ones opencode backs off for a long time; transient
+ * 5xx/network errors retry in seconds and must be left to opencode's own
+ * retry loop (the idle watchdog remains the fallback for silent hangs).
+ */
+export interface OpencodeLogErrorMonitorOptions {
+    /** Path to opencode's own log file (default: resolveOpencodeLogPath()). */
+    logPath: string;
+    /** Tail poll interval in milliseconds. Defaults to 2000. */
+    pollIntervalMs?: number;
+}
+/**
+ * Resolve opencode's log file path from the XDG data dir
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
+ * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
+ * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ */
+export declare function resolveOpencodeLogPath(): string;
+export declare class OpencodeLogErrorMonitor {
+    private readonly logPath;
+    private readonly pollIntervalMs;
+    private offset;
+    private pendingTail;
+    private timer;
+    private sessionId;
+    private onError;
+    constructor(opts: OpencodeLogErrorMonitorOptions);
+    /**
+     * Start monitoring the given session. Replaces any previous monitor state;
+     * the log offset is snapshotted now, so pre-existing entries never fire.
+     */
+    start(sessionId: string, onError: (message: string) => void): void;
+    /** Stop monitoring and clear all state. Safe to call multiple times. */
+    stop(): void;
+    private currentSize;
+    private poll;
+    /** Match a main-turn stream error line for the monitored session with a
+     *  limit/quota reason; returns the extracted error text or null. */
+    private matchLimitError;
+}

package/dist/runner/opencode/acp/error-monitor.js

@@ -0,0 +1,150 @@
+/**
+ * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
+ * errors of the active ACP session and reports them immediately.
+ *
+ * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * to the client over the ACP protocol. Its session/update notifications are
+ * limited to content deltas (agent_message_chunk / agent_thought_chunk /
+ * tool_call / tool_call_update), usage and available-commands updates — there
+ * is no error/retry/status event type, and session/list carries no status.
+ * When a retryable provider error hits (e.g. opencode-go "Weekly usage limit
+ * reached"), the session enters a retry backoff (often the full reset time,
+ * ~1h) and session/prompt stays pending with zero events, so the client would
+ * hang until its own idle watchdog.
+ *
+ * The only channel that carries the real error is opencode's own log file
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`), where every LLM stream
+ * failure is written as `message="stream error" ... session.id=<id>
+ * small=false ... error.error="<reason>"`.
+ *
+ * This monitor tails the log (delta from the turn-start offset), scoped to
+ * the active sessionId + `small=false` (main turn; the `small=true` title
+ * stream must not kill the turn). Only limit/quota-class errors trigger the
+ * callback — they are the ones opencode backs off for a long time; transient
+ * 5xx/network errors retry in seconds and must be left to opencode's own
+ * retry loop (the idle watchdog remains the fallback for silent hangs).
+ */
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Error text we fail fast on: quota/limit conditions opencode backs off on. */
+const LIMIT_ERROR_RE = /usage limit|quota|rate limit|rate_limit|too many requests|insufficient balance|free usage/i;
+const STREAM_ERROR_RE = /message="stream error"/;
+const MAIN_TURN_RE = /small=false/;
+const ERROR_MESSAGE_RE = /error\.error="((?:[^"\\]|\\.)*)"/;
+/**
+ * Resolve opencode's log file path from the XDG data dir
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
+ * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
+ * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ */
+export function resolveOpencodeLogPath() {
+    const dataHome = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+    return join(dataHome, 'opencode', 'log', 'opencode.log');
+}
+export class OpencodeLogErrorMonitor {
+    logPath;
+    pollIntervalMs;
+    offset = 0;
+    pendingTail = '';
+    timer = null;
+    sessionId = null;
+    onError = null;
+    constructor(opts) {
+        this.logPath = opts.logPath;
+        this.pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    }
+    /**
+     * Start monitoring the given session. Replaces any previous monitor state;
+     * the log offset is snapshotted now, so pre-existing entries never fire.
+     */
+    start(sessionId, onError) {
+        this.stop();
+        this.sessionId = sessionId;
+        this.onError = onError;
+        this.offset = this.currentSize();
+        this.pendingTail = '';
+        this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+        this.timer.unref?.();
+    }
+    /** Stop monitoring and clear all state. Safe to call multiple times. */
+    stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.sessionId = null;
+        this.onError = null;
+        this.pendingTail = '';
+    }
+    currentSize() {
+        try {
+            return statSync(this.logPath).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    poll() {
+        if (this.sessionId === null || this.onError === null)
+            return;
+        const size = this.currentSize();
+        if (size < this.offset) {
+            // Log rotated/truncated: restart from the top of the current file.
+            this.offset = 0;
+            this.pendingTail = '';
+        }
+        if (size > this.offset) {
+            let chunk;
+            try {
+                const fd = openSync(this.logPath, 'r');
+                try {
+                    const buf = Buffer.alloc(size - this.offset);
+                    readSync(fd, buf, 0, buf.length, this.offset);
+                    chunk = buf.toString('utf8');
+                }
+                finally {
+                    closeSync(fd);
+                }
+            }
+            catch {
+                return;
+            }
+            this.offset = size;
+            this.pendingTail += chunk;
+        }
+        // Scan complete lines (and any trailing line without newline).
+        for (const line of this.pendingTail.split('\n')) {
+            const message = this.matchLimitError(line);
+            if (message === null)
+                continue;
+            const onError = this.onError;
+            this.stop();
+            onError(message);
+            return;
+        }
+        // Keep only the last partial line (everything before the last '\n' was
+        // fully scanned above and did not match).
+        const lastNewline = this.pendingTail.lastIndexOf('\n');
+        if (lastNewline >= 0) {
+            this.pendingTail = this.pendingTail.slice(lastNewline + 1);
+        }
+    }
+    /** Match a main-turn stream error line for the monitored session with a
+     *  limit/quota reason; returns the extracted error text or null. */
+    matchLimitError(line) {
+        if (this.sessionId === null)
+            return null;
+        if (!line.includes(this.sessionId))
+            return null;
+        if (!STREAM_ERROR_RE.test(line))
+            return null;
+        if (!MAIN_TURN_RE.test(line))
+            return null;
+        const message = ERROR_MESSAGE_RE.exec(line)?.[1];
+        if (!message || !LIMIT_ERROR_RE.test(message))
+            return null;
+        return message;
+    }
+}
+//# sourceMappingURL=error-monitor.js.map

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

@@ -43,6 +43,10 @@ export interface OpencodeAcpRunnerOptions {
     model?: string;
     /** Configured session mode: 'build' (default) or 'plan' (opencode agent names). */
     mode?: 'build' | 'plan';
+    /** Path to opencode's own log file (default: resolveOpencodeLogPath()). */
+    errorMonitorLogPath?: string;
+    /** Tail poll interval for the opencode log error monitor. Defaults to 2000ms. */
+    errorMonitorPollIntervalMs?: number;
 }
 export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClient, OpencodeAcpTranslatorEvent> {
     private connectionManager;
@@ -55,6 +59,9 @@ export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClie
     private currentModeId?;
     /** Current model value (`provider/model`), parsed from configOptions. */
     private currentModelValue?;
+    /** Tails opencode's own log to surface LLM stream errors the ACP protocol
+     *  never forwards (quota/limit errors back off for ~1h → turn would hang). */
+    private readonly errorMonitor;
     /** Pending approval requests: requestId → kind + view + options. */
     private pendingApprovals;
     /** Tracker for the in-flight prompt request — needed for cancellation. */
@@ -71,6 +78,16 @@ export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClie
     protected shouldDeferStop(): boolean;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;
+    /**
+     * Start watching opencode's own log for LLM stream errors of the active
+     * session. opencode ACP does not surface retry/error state to the client
+     * (no error/status notification type, session/list has no status field), so
+     * the log is the only channel that carries the real provider error. Without
+     * this, a quota error (e.g. opencode-go weekly limit) leaves session/prompt
+     * pending for the full retry-after backoff (~1h) and the Feishu card hangs
+     * until the idle watchdog.
+     */
+    private startErrorMonitor;
     protected releaseConnection(cwd: string): Promise<void>;
     protected notifyIdle(cwd: string): void;
     protected disposeConnections(): Promise<void>;

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

@@ -22,49 +22,10 @@
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { OpencodeAcpTranslator } from './translator.js';
 import { RpcErrorCode, } from '../../common/acp/protocol-types.js';
-import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
+import { OPENCODE_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/protocol-helpers.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
-/**
- * Build the ACP protocol response for a permission approval decision.
- *
- * accept            → {outcome:{outcome:'selected', optionId:<allow_once kind>}}
- * accept_for_session → {outcome:{outcome:'selected', optionId:<allow_always kind>}}
- * decline           → {outcome:{outcome:'selected', optionId:<reject kind>}}
- * cancel            → {outcome:{outcome:'cancelled'}}
- *
- * optionId is opaque and echoed back as-is (opencode permission.ts:20-24
- * offers once/always/reject with kinds allow_once/allow_always/reject_once;
- * the server maps optionId 'once'/'always' → approve, anything else →
- * reject — permission.ts:219-223). If no matching option is found, fall
- * back to cancelled (safe universal default).
- */
-function buildApprovalResponse(action, pending) {
-    if (action === 'cancel') {
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    if (action === 'accept') {
-        const optionId = findOptionIdByKind(pending.options, ['allow_once', 'allow_always']);
-        if (optionId) {
-            return { outcome: { outcome: 'selected', optionId } };
-        }
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    if (action === 'accept_for_session') {
-        // §P4: 卡片「允许本次会话」→ always 类 optionId（opencode 'always'）
-        const optionId = findOptionIdByKind(pending.options, ['allow_always', 'approve_always']);
-        if (optionId) {
-            return { outcome: { outcome: 'selected', optionId } };
-        }
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    // decline
-    const optionId = findOptionIdByKind(pending.options, ['reject_once', 'reject']);
-    if (optionId) {
-        return { outcome: { outcome: 'selected', optionId } };
-    }
-    return { outcome: { outcome: 'cancelled' } };
-}
+import { OpencodeLogErrorMonitor, resolveOpencodeLogPath } from './error-monitor.js';
 // =============================================================================
 // Runner
 // =============================================================================
@@ -79,6 +40,9 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
     currentModeId;
     /** Current model value (`provider/model`), parsed from configOptions. */
     currentModelValue;
+    /** Tails opencode's own log to surface LLM stream errors the ACP protocol
+     *  never forwards (quota/limit errors back off for ~1h → turn would hang). */
+    errorMonitor;
     /** Pending approval requests: requestId → kind + view + options. */
     pendingApprovals = new Map();
     /** Tracker for the in-flight prompt request — needed for cancellation. */
@@ -91,6 +55,10 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
         super({ kind: opts.kind, sessionReader: opts.sessionReader }, opts.turnIdleTimeoutMs);
         this.model = opts.model;
         this.configuredMode = opts.mode ?? 'build';
+        this.errorMonitor = new OpencodeLogErrorMonitor({
+            logPath: opts.errorMonitorLogPath ?? resolveOpencodeLogPath(),
+            pollIntervalMs: opts.errorMonitorPollIntervalMs,
+        });
         const managerOpts = {
             binary: opts.binary ?? 'opencode',
             args: opts.acpArgs ?? ['acp'],
@@ -138,11 +106,27 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
         }
     }
     clearTurnState() {
+        this.errorMonitor.stop();
         this.currentTranslator = null;
         this.promptSettled = false;
         this.promptSent = false;
         this.activeSessionId = null;
     }
+    /**
+     * Start watching opencode's own log for LLM stream errors of the active
+     * session. opencode ACP does not surface retry/error state to the client
+     * (no error/status notification type, session/list has no status field), so
+     * the log is the only channel that carries the real provider error. Without
+     * this, a quota error (e.g. opencode-go weekly limit) leaves session/prompt
+     * pending for the full retry-after backoff (~1h) and the Feishu card hangs
+     * until the idle watchdog.
+     */
+    startErrorMonitor(sessionId) {
+        this.errorMonitor.start(sessionId, (message) => {
+            getLogger().warn(`[${this.logTag}] opencode stream error detected (log), failing turn: ${message}`);
+            this.failTurn(`opencode LLM stream error: ${message}`);
+        });
+    }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
     }
@@ -175,6 +159,7 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
                 throw new Error('compact requires a sessionId');
             }
             this.activeSessionId = sessionId;
+            this.startErrorMonitor(sessionId);
             // Cold-connection fallback: session/resume loads the session into
             // memory. On a reused connection the session is already loaded —
             // resume is idempotent and harmless.
@@ -227,7 +212,7 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
         if (!client || !pending)
             return;
         const action = response?.action ?? 'decline';
-        const acpResponse = buildApprovalResponse(action, pending);
+        const acpResponse = buildAcpPermissionOutcome(action, pending.options, OPENCODE_APPROVAL_KINDS);
         client.respond(requestId, acpResponse);
         this.pendingApprovals.delete(requestId);
         getLogger().info(`[${this.logTag}] approval responded requestId=${requestId} action=${action}`);
@@ -310,6 +295,7 @@ export class OpencodeAcpRunner extends ConnectionBasedRunner {
             sessionId = newResult.sessionId;
         }
         this.activeSessionId = sessionId;
+        this.startErrorMonitor(sessionId);
         // §P5: apply the configured mode (build/plan). If the session already
         // runs it (from session/new|resume configOptions), skip the wire call;
         // otherwise send session/set_mode and refresh the local view (opencode

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

@@ -109,7 +109,6 @@ export declare class OpencodeAcpTranslator {
      * accept/decline/cancel are universal; acceptForSession requires an
      * always-class option (opencode `allow_always`, kimi `approve_always`).
      */
-    private deriveAvailableDecisions;
     /**
      * ResultEvent.usage nominally requires input_tokens/output_tokens, but the
      * ACP wire has no such split — the live snapshot is context occupancy only.

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

@@ -29,6 +29,7 @@
  *   session/request_permission     → approval_requested (optionId echo)
  */
 import { NotificationMethod, ServerRequestMethod, SessionEventType, } from '../../common/acp/protocol-types.js';
+import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/protocol-helpers.js';
 import { getLogger } from '../../../logger/index.js';
 // =============================================================================
 // Translator
@@ -254,10 +255,10 @@ export class OpencodeAcpTranslator {
             requestId,
             kind: 'command',
             command: params.toolCall.title ?? undefined,
-            reason: rawInput ? truncate(stringify(rawInput), 200) : undefined,
+            reason: rawInput ? truncateWithEllipsis(stringify(rawInput), 200) : undefined,
             // §P4: 从服务端 options kind 派生——带 allow_always（或 approve_always）
             // 才提供「本会话总是允许」（acceptForSession）。
-            availableDecisions: this.deriveAvailableDecisions(params),
+            availableDecisions: deriveAcpAvailableDecisions(params.options ?? []),
         };
         return [
             {
@@ -277,14 +278,6 @@ export class OpencodeAcpTranslator {
      * accept/decline/cancel are universal; acceptForSession requires an
      * always-class option (opencode `allow_always`, kimi `approve_always`).
      */
-    deriveAvailableDecisions(params) {
-        const decisions = ['accept', 'decline', 'cancel'];
-        const hasAlwaysOption = (params.options ?? []).some((opt) => opt.kind === 'allow_always' || opt.kind === 'approve_always');
-        if (hasAlwaysOption) {
-            decisions.push('acceptForSession');
-        }
-        return decisions;
-    }
     // =========================================================================
     // Private helpers
     // =========================================================================
@@ -329,9 +322,6 @@ function extractToolResultContent(event) {
     }
     return '';
 }
-function truncate(text, maxLen) {
-    return text.length <= maxLen ? text : text.slice(0, maxLen) + '…';
-}
 function stringify(value) {
     if (typeof value === 'string')
         return value;

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

@@ -1,4 +1,2 @@
 export { PiRpcRunner } from './runner.js';
 export type { PiRpcRunnerOptions } from './runner.js';
-export { PiRpcClient } from './client.js';
-export { PiRpcTranslator } from './translator.js';

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

@@ -1,4 +1,2 @@
 export { PiRpcRunner } from './runner.js';
-export { PiRpcClient } from './client.js';
-export { PiRpcTranslator } from './translator.js';
 //# sourceMappingURL=index.js.map

package/dist/runner/resolve-agent-choices.js

@@ -9,9 +9,13 @@ export function resolveAgentChoices(config) {
     if (agent === 'claude') {
         return config;
     }
-    const agentChoices = choices[agent];
     const fields = choiceFieldsFor(agent);
-    if (!agentChoices || !fields) {
+    // dsh 的 choices 恒为空（host 是连接配置而非 per-run choice），无需恢复
+    if (!fields || fields.length === 0) {
+        return config;
+    }
+    const agentChoices = choices[agent];
+    if (!agentChoices) {
         return config;
     }
     // Clone to avoid mutation

package/dist/runner/sync-agent-choices.js

@@ -2,7 +2,7 @@ import { choiceFieldsFor } from './agent-choices-common.js';
 export function syncAgentChoices(config, agent) {
     // claude 的配置在顶层 config.claude，不在 agents 下，无需同步
     const fields = choiceFieldsFor(agent);
-    if (!fields)
+    if (!fields || fields.length === 0)
         return config;
     const agents = config.agents;
     const agentCfg = agents?.[agent];

package/dist/runner/types.d.ts

@@ -416,6 +416,21 @@ export interface SessionContent {
     recap?: string;
     displayTitle?: string;
 }
+/**
+ * Lightweight session summary used by `/resume` list prefetch.
+ *
+ * Carries only the display fields (title / recap / usage) — **no `events`
+ * array**. Readers that can extract these without constructing the full event
+ * list (e.g. codex, which would otherwise JSON.parse every response_item and
+ * build an `events[]` that the prefetch immediately discards) implement the
+ * optional `readSessionSummary` on `AgentSessionReader`.
+ */
+export interface SessionSummary {
+    aiTitle?: string;
+    recap?: string;
+    displayTitle?: string;
+    usage?: AgentSessionUsage;
+}
 /**
  * Reads an agent's session history. Each agent implements its own (Claude reads
  * `~/.claude/projects/`, Codex calls `thread/list`, OpenCode calls `GET /session`).
@@ -448,6 +463,14 @@ export interface AgentSessionReader {
     readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
+    /**
+     * Optional lightweight summary for list-prefetch.
+     *
+     * Returns only the display fields (aiTitle/recap/displayTitle/usage) without
+     * constructing the full `events` array. When absent, callers fall back to
+     * `readSessionContent` and take the needed fields.
+     */
+    readSessionSummary?(sessionId: string, cwd: string): SessionSummary;
     /**
      * Whether a session is still active (process may still be running).
      *

package/dist/session/claude/session-index.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { scanJsonlLines } from '../common/jsonl.js';
+import { sortByRecencyDesc } from '../common/recency.js';
 import { extractContentBlocks } from '../common/content-blocks.js';
 import { getLogger } from '../../logger/index.js';
 // ─── Claude content block mapping (shared with sessions.ts) ─
@@ -175,7 +176,8 @@ export class SessionIndex {
                 byId.set(entry.sessionId, entry);
             }
         }
-        const sorted = [...byId.values()].sort((a, b) => b.mtimeMs - a.mtimeMs || a.sessionId.localeCompare(b.sessionId));
+        const sorted = [...byId.values()];
+        sortByRecencyDesc(sorted, (s) => s.mtimeMs, (s) => s.sessionId);
         const offset = opts.offset ?? 0;
         const limit = opts.limit;
         const sliced = limit === undefined ? sorted.slice(offset) : sorted.slice(offset, offset + limit);

package/dist/session/claude/sessions.js

@@ -5,7 +5,7 @@ import { findJsonlLine, readLastJsonlLine, scanJsonlLines, readJsonlLinesFromOff
 import { STALE_MS } from '../common/constants.js';
 import { capEvents } from '../common/pagination.js';
 import { extractContentBlocks } from '../common/content-blocks.js';
-import { UsageAccumulator } from '../common/usage-accumulator.js';
+import { UsageAccumulator, contextWindowOccupancy, cumulativeUsageFields, } from '../common/usage-accumulator.js';
 import { SessionIndex, extractText, isTaskNotificationText, CLAUDE_MAPPING, } from './session-index.js';
 /**
  * Directory Claude Code uses to store session transcripts for a given cwd.
@@ -329,7 +329,7 @@ function scalarScan(filePath) {
     // 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 ? l.input + l.cacheRead + l.cacheCreation : 0;
+    const lastWindow = l ? contextWindowOccupancy(l) : 0;
     let contextLength = lastPostTokens;
     if (contextLength === 0 || lastWindow > contextLength) {
         contextLength = lastWindow;
@@ -347,11 +347,7 @@ function scalarScan(filePath) {
         cacheReadTokens: l && l.cacheRead > 0 ? l.cacheRead : undefined,
         cacheCreationTokens: l && l.cacheCreation > 0 ? l.cacheCreation : undefined,
         totalTokens: lastTotal,
-        cumulativeTotalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
-        cumulativeInputTokens: t.input,
-        cumulativeOutputTokens: t.output,
-        cumulativeCacheReadTokens: t.cacheRead,
-        cumulativeCacheCreationTokens: t.cacheCreation,
+        ...cumulativeUsageFields(t),
     };
     return {
         tailOffset,

package/dist/session/codex/rollout-reader.d.ts

@@ -13,7 +13,7 @@
  * Note: This handles the **rollout file format** (historical logging), NOT the
  * `codex exec --json` stdout format（已随 exec 模式移除）。
  */
-import type { AgentSessionContentEvent, SessionContent, AgentSessionUsage } from '../../runner/index.js';
+import type { AgentSessionContentEvent, SessionContent, SessionSummary, AgentSessionUsage } from '../../runner/index.js';
 interface CodexRolloutEntry {
     threadId: string;
     cwd: string;
@@ -21,7 +21,6 @@ interface CodexRolloutEntry {
     firstUserMessage: string;
     /** Last real (human-typed) user message, for the "最近输入" card label. */
     lastRealUserMessage: string;
-    createdAtMs: number;
     updatedAtMs: number;
     events: AgentSessionContentEvent[];
     /** Last-turn usage extracted from token_count events (ccusage-aligned). */
@@ -71,6 +70,17 @@ export declare function readCodexSessionContent(sessionId: string, opts?: {
     maxEvents?: number;
     cwd?: string;
 }): SessionContent;
+/**
+ * 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 declare function readCodexSessionSummary(sessionId: string, opts?: {
+    codexHome?: string;
+    cwd?: string;
+}): SessionSummary;
 /**
  * Check if a session is still active (recently updated).
  *