lark-remote 0.1.11 → 0.1.12

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.1.12] - 2026-08-29
+
+### 修复
+
+- opencode ACP stream error 实时上报：tail opencode 日志即时捕获错误行，配额类错误秒级报错，不再挂起卡片等待超时
+
+### 变更
+
+- codex 会话历史读取轻量化：长会话生成轻量摘要，模型目录异步加载，减少启动阻塞
+- CI 覆盖率门禁纳入 `src/index.ts`，覆盖率统计更完整
+
 ## [0.1.11] - 2026-08-24
 
 ### 新增

package/dist/config/codex-config.d.ts

@@ -75,14 +75,36 @@ export declare function parseCodexModelsOutput(stdout: string): BundledModelInfo
  * 缓存：键含 binary/home/mode/models.json mtime:size + config.toml mtime:size
  * （P3-4/P3-15/P3-5）；成功结果 TTL 1h，失败/空结果短 TTL 负缓存；stat 异常时
  * 指纹为空（P1-1/P3-10）。
+ *
+ * 同步路径（卡片构建用）：缓存命中直接返回；若有一个后台异步加载
+ * （`loadCodexCatalogModelsAsync` / 启动 warm）在途，则不阻塞事件循环、不重复
+ * spawn，直接返回 [] 走既有 fallback（FALLBACK_MODELS / currentModel）——该
+ * [] 状态与命令失败/超时的已有语义一致，由调用方既有 fallback 兜底。
  */
 export declare function getCodexCatalogModels(codexHome?: string): BundledModelInfo[];
+/**
+ * 异步加载模型目录（execFile，不阻塞事件循环），写入与同步路径共享的
+ * `catalogCache`。按缓存 key 复用 in-flight Promise：并发调用（多个 warm /
+ * 显式调用）只 spawn 一次 `codex debug models`。
+ *
+ * 与同步路径的职责划分：启动时用 `warmCodexCatalogCache` 后台预热，使首次打开
+ * Codex 配置卡（同步读）时缓存已温、无需 8s execFileSync 阻塞；若用户在 warm
+ * 完成前打开卡片，同步路径会检测到 in-flight 并直接返回 [] fallback。
+ */
+export declare function loadCodexCatalogModelsAsync(codexHome?: string): Promise<BundledModelInfo[]>;
+/**
+ * 启动/后台预热：fire-and-forget 调用异步加载，消除首次打开 Codex 配置卡时的
+ * 8s 同步阻塞。非致命——失败/未安装 codex 时静默落负缓存。
+ */
+export declare function warmCodexCatalogCache(codexHome?: string): void;
 /**
  * Test utility: clear the catalog cache. Tests that exercise the bundled
  * command path (`--bundled`) directly use `invalidateCodexBundledTestCache`
  * from `tests/lib/codex-bundled-test-helpers.ts`.
  */
 export declare function invalidateCodexBundledCache(): void;
+/** Test utility: clear in-flight async catalog loads (see async loader tests). */
+export declare function _clearCodexCatalogInFlightForTest(): void;
 /**
  * Get supported reasoning effort options for a model.
  * @param codexHome 可选 codex 配置目录覆盖（与 loadCodexConfig 的 codexHome 对齐，

package/dist/config/codex-config.js

@@ -8,7 +8,7 @@
  * - catalog 模式（config.toml 声明 model_catalog_json）：模型列表/档位来自活动目录
  * - 非 catalog 模式：openai 用 bundled 全量；anthropic 仅在用户显式配置时存在
  */
-import { execFileSync } from 'node:child_process';
+import { execFileSync, execFile } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -46,6 +46,8 @@ const BUNDLED_CACHE_TTL_MS = 60 * 60 * 1000;
 /** 失败/空结果负缓存 TTL：避免每次卡片构建同步阻塞最长 8s（P3-5） */
 const NEGATIVE_CACHE_TTL_MS = 30 * 1000;
 let catalogCache = null;
+/** In-flight async catalog loads, keyed by cache key — dedup concurrent warm ups. */
+const catalogInFlight = new Map();
 /**
  * Read config.toml `model_catalog_json` path (tilde-expanded).
  * 返回语义：
@@ -153,8 +155,89 @@ export function parseCodexModelsOutput(stdout) {
  * 缓存：键含 binary/home/mode/models.json mtime:size + config.toml mtime:size
  * （P3-4/P3-15/P3-5）；成功结果 TTL 1h，失败/空结果短 TTL 负缓存；stat 异常时
  * 指纹为空（P1-1/P3-10）。
+ *
+ * 同步路径（卡片构建用）：缓存命中直接返回；若有一个后台异步加载
+ * （`loadCodexCatalogModelsAsync` / 启动 warm）在途，则不阻塞事件循环、不重复
+ * spawn，直接返回 [] 走既有 fallback（FALLBACK_MODELS / currentModel）——该
+ * [] 状态与命令失败/超时的已有语义一致，由调用方既有 fallback 兜底。
  */
 export function getCodexCatalogModels(codexHome) {
+    const { key, bundled } = computeCodexCatalogKey(codexHome);
+    const cached = readCachedCatalog(key);
+    if (cached !== undefined)
+        return cached;
+    // in-flight 异步加载进行中：不 execFileSync（会阻塞 8s），返回 [] 交给
+    // 调用方既有 fallback；in-flight 完成后下次读取命中缓存。
+    if (catalogInFlight.has(key)) {
+        return [];
+    }
+    const now = Date.now();
+    try {
+        const stdout = execFileSync('codex', catalogArgs(bundled), {
+            encoding: 'utf-8',
+            timeout: 8_000,
+            maxBuffer: 4 * 1024 * 1024,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const models = parseCodexModelsOutput(stdout);
+        catalogCache = { key, models, ts: now, failed: models.length === 0 };
+        return models;
+    }
+    catch (err) {
+        getLogger().warn(`[codex-config] models unavailable for binary "codex": ${err.message}`);
+        catalogCache = { key, models: [], ts: now, failed: true };
+        return [];
+    }
+}
+/**
+ * 异步加载模型目录（execFile，不阻塞事件循环），写入与同步路径共享的
+ * `catalogCache`。按缓存 key 复用 in-flight Promise：并发调用（多个 warm /
+ * 显式调用）只 spawn 一次 `codex debug models`。
+ *
+ * 与同步路径的职责划分：启动时用 `warmCodexCatalogCache` 后台预热，使首次打开
+ * Codex 配置卡（同步读）时缓存已温、无需 8s execFileSync 阻塞；若用户在 warm
+ * 完成前打开卡片，同步路径会检测到 in-flight 并直接返回 [] fallback。
+ */
+export async function loadCodexCatalogModelsAsync(codexHome) {
+    const { key, bundled } = computeCodexCatalogKey(codexHome);
+    const cached = readCachedCatalog(key);
+    if (cached !== undefined)
+        return cached;
+    const inFlight = catalogInFlight.get(key);
+    if (inFlight)
+        return inFlight;
+    const p = (async () => {
+        const now = Date.now();
+        try {
+            const stdout = await execFileAsync('codex', catalogArgs(bundled));
+            const models = parseCodexModelsOutput(stdout);
+            catalogCache = { key, models, ts: now, failed: models.length === 0 };
+            return models;
+        }
+        catch (err) {
+            getLogger().warn(`[codex-config] models unavailable for binary "codex": ${err.message}`);
+            catalogCache = { key, models: [], ts: now, failed: true };
+            return [];
+        }
+    })();
+    catalogInFlight.set(key, p);
+    try {
+        return await p;
+    }
+    finally {
+        catalogInFlight.delete(key);
+    }
+}
+/**
+ * 启动/后台预热：fire-and-forget 调用异步加载，消除首次打开 Codex 配置卡时的
+ * 8s 同步阻塞。非致命——失败/未安装 codex 时静默落负缓存。
+ */
+export function warmCodexCatalogCache(codexHome) {
+    void loadCodexCatalogModelsAsync(codexHome);
+}
+/** 计算目录缓存键（binary/home/mode + 指纹），同步与异步路径共享。 */
+function computeCodexCatalogKey(codexHome) {
     const binary = 'codex';
     const home = resolveCodexHome(codexHome);
     const catalogPath = readModelCatalogJsonPath(home);
@@ -179,6 +262,10 @@ export function getCodexCatalogModels(codexHome) {
         }
     }
     const key = `${binary}\u0000${home}\u0000${bundled ? 'bundled' : 'active'}\u0000${catalogFingerprint}\u0000${configFingerprint}`;
+    return { key, bundled };
+}
+/** 读取有效缓存（含负缓存 TTL）；命中返回模型，否则 undefined。 */
+function readCachedCatalog(key) {
     const now = Date.now();
     if (catalogCache && catalogCache.key === key) {
         const ttl = catalogCache.failed ? NEGATIVE_CACHE_TTL_MS : BUNDLED_CACHE_TTL_MS;
@@ -186,24 +273,27 @@ export function getCodexCatalogModels(codexHome) {
             return catalogCache.models;
         }
     }
-    try {
-        const args = bundled ? ['debug', 'models', '--bundled'] : ['debug', 'models'];
-        const stdout = execFileSync(binary, args, {
+    return undefined;
+}
+/** `codex debug models` 参数（--bundled 与否）。 */
+function catalogArgs(bundled) {
+    return bundled ? ['debug', 'models', '--bundled'] : ['debug', 'models'];
+}
+/** Promisify execFile with the same 8s timeout / 4MB cap as the sync path. */
+function execFileAsync(file, args) {
+    return new Promise((resolve, reject) => {
+        execFile(file, args, {
             encoding: 'utf-8',
             timeout: 8_000,
             maxBuffer: 4 * 1024 * 1024,
             env: process.env,
-            stdio: ['ignore', 'pipe', 'ignore'],
+        }, (err, stdout) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stdout);
         });
-        const models = parseCodexModelsOutput(stdout);
-        catalogCache = { key, models, ts: now, failed: models.length === 0 };
-        return models;
-    }
-    catch (err) {
-        getLogger().warn(`[codex-config] models unavailable for binary "${binary}": ${err.message}`);
-        catalogCache = { key, models: [], ts: now, failed: true };
-        return [];
-    }
+    });
 }
 /**
  * Test utility: clear the catalog cache. Tests that exercise the bundled
@@ -213,6 +303,10 @@ export function getCodexCatalogModels(codexHome) {
 export function invalidateCodexBundledCache() {
     catalogCache = null;
 }
+/** Test utility: clear in-flight async catalog loads (see async loader tests). */
+export function _clearCodexCatalogInFlightForTest() {
+    catalogInFlight.clear();
+}
 /**
  * Get supported reasoning effort options for a model.
  * @param codexHome 可选 codex 配置目录覆盖（与 loadCodexConfig 的 codexHome 对齐，

package/dist/index.js

@@ -6,6 +6,7 @@ import { FeishuConnector } from './connector/index.js';
 import { ClaudeRunner, CodexAppServerRunner, OpencodeAcpRunner, PiRpcRunner, KimiAcpRunner, DshRunner, } from './runner/index.js';
 import { AgentRegistry } from './runner/registry.js';
 import { probeAllAgents } from './runner/probe.js';
+import { warmCodexCatalogCache } from './config/codex-config.js';
 import { SessionReaderRegistry, SessionStore } from './session/index.js';
 import { ClaudeSessionReader, CodexSessionReader, OpencodeSessionReader, PiSessionReader, KimiSessionReader, DshSessionReader, } from './session/index.js';
 import { CommandRouter, isImmediateAction } from './router/index.js';
@@ -289,6 +290,11 @@ function initializeRunner(config, configDir, cliArgs) {
         .catch(() => {
         // Probe failure is non-fatal; /config card will retry on open.
     });
+    // Warm the codex model catalog in the background so the first Codex /config
+    // card open reads a warm cache instead of blocking the event loop for up to
+    // 8s (execFileSync cold path). Fire-and-forget; failure lands in negative
+    // cache and the sync card path falls back gracefully.
+    warmCodexCatalogCache();
     return { agentRegistry, sessionReaderRegistry };
 }
 /** Setup message and card action handlers. */

package/dist/router/index.js

@@ -3108,12 +3108,19 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         const sessionMeta = new Map();
         const prefetchCount = Math.min(RESUME_CONTENT_PREFETCH, allSessions.length);
         for (const s of allSessions.slice(0, prefetchCount)) {
-            // Use the same reader as the listSessions call above
-            const content = reader.readSessionContent(s.sessionId, cwd);
+            // 优先走轻量摘要（只取标题/用量，不构造 events）——codex 实现了
+            // readSessionSummary，避免对前 N 条各做一次全量 JSONL 解析来构造
+            // 立即被丢弃的 events 数组。其他 agent 无此方法时回退全量读取再取字段。
+            const meta = reader.readSessionSummary
+                ? reader.readSessionSummary(s.sessionId, cwd)
+                : (() => {
+                    const c = reader.readSessionContent(s.sessionId, cwd);
+                    return { aiTitle: c.aiTitle, recap: c.recap, displayTitle: c.displayTitle };
+                })();
             sessionMeta.set(s.sessionId, {
-                aiTitle: content.aiTitle,
-                recap: content.recap,
-                displayTitle: content.displayTitle,
+                aiTitle: meta.aiTitle,
+                recap: meta.recap,
+                displayTitle: meta.displayTitle,
             });
         }
         const now = Date.now();

package/dist/runner/index.d.ts

@@ -15,6 +15,6 @@ export { KimiAcpRunner } from './kimi/index.js';
 export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

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

@@ -25,6 +25,7 @@ import { RpcErrorCode, } from '../../common/acp/protocol-types.js';
 import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import { OpencodeLogErrorMonitor, resolveOpencodeLogPath } from './error-monitor.js';
 /**
  * Build the ACP protocol response for a permission approval decision.
  *
@@ -79,6 +80,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 +95,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 +146,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 +199,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.
@@ -310,6 +335,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/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/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;
@@ -38,6 +38,19 @@ interface ListCodexRolloutsOptions {
     offset?: number;
 }
 export declare function readCodexRollout(filePath: string): CodexRolloutEntry | 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.
+ */
+export declare function readCodexRolloutSummary(filePath: string): {
+    lastRealUserMessage: string;
+    usage?: AgentSessionUsage;
+} | null;
 /**
  * List Codex sessions from rollout files.
  *
@@ -71,6 +84,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).
  *

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

@@ -35,130 +35,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;
         }
@@ -173,48 +51,9 @@ export function readCodexRollout(filePath) {
             ? 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,
@@ -222,7 +61,7 @@ export function readCodexRollout(filePath) {
             lastRealUserMessage,
             createdAtMs,
             updatedAtMs,
-            events,
+            events: scan.events,
             usage,
         };
     }
@@ -231,6 +70,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.
+ */
+export 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.
  *
@@ -327,6 +382,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/package.json

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