lark-remote 0.5.19 → 0.5.21

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

@@ -117,67 +117,189 @@ function readCodexRolloutSummary(filePath) {
         return null;
     }
 }
+function newScanState() {
+    return {
+        sessionMeta: null,
+        events: [],
+        realUserMessages: [],
+        lastRawUsage: undefined,
+        lastContextLimit: undefined,
+        lastTotalUsage: undefined,
+        previousTotals: undefined,
+        turnUsage: null,
+        compactCount: 0,
+        compactPreContextLength: undefined,
+        compactPostContextLength: undefined,
+        lastUserMessageSource: null,
+        userResponseItemCount: 0,
+        previousRawUsage: undefined,
+    };
+}
+function scanResult(state) {
+    return {
+        sessionMeta: state.sessionMeta,
+        events: state.events,
+        realUserMessages: state.realUserMessages,
+        lastRawUsage: state.lastRawUsage,
+        lastContextLimit: state.lastContextLimit,
+        lastTotalUsage: state.lastTotalUsage,
+        previousTotals: state.previousTotals,
+        turnUsage: state.turnUsage,
+        compactCount: state.compactCount,
+        compactPreContextLength: state.compactPreContextLength,
+        compactPostContextLength: state.compactPostContextLength,
+    };
+}
+function warnIfVocabularyDrift(state, filePath) {
+    // 兼容性漂移探针：文件里有 `role:"user"` 注入，却识别不出任何真人输入 ——
+    // 说明 codex 又换了 event_msg 词表，displayTitle 会静默变空（0.153 事故形态）。
+    // 只告警不兜底：误用注入文本当标题是已修掉的缺陷。
+    if (state.realUserMessages.length === 0 && state.userResponseItemCount > 0) {
+        getLogger().warn(`[codex-rollout-reader] no human user message recognised in ${filePath} ` +
+            `(${state.userResponseItemCount} role:"user" response_items seen) — codex rollout ` +
+            `event vocabulary may have changed; session title will be empty`);
+    }
+}
+function recordHumanMessage(state, human) {
+    const text = human.text.slice(0, 200);
+    const prev = state.realUserMessages[state.realUserMessages.length - 1];
+    // 过渡期防御：同一 turn 若被旧版 user_message 与新版 item_completed
+    // 各写一次，会得到相邻重复。仅在「通道切换且文本与上一条完全相同」
+    // 时跳过——同通道连续相同输入（真人连发两条一样的话）不受影响。
+    const duplicateAcrossChannels = state.lastUserMessageSource !== null &&
+        state.lastUserMessageSource !== human.source &&
+        prev === text;
+    if (!duplicateAcrossChannels) {
+        state.realUserMessages.push(text);
+    }
+    state.lastUserMessageSource = human.source;
+}
+function resolveRawUsage(info, previousTotals) {
+    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;
+    }
+    return { raw, total };
+}
+function accumulateTurnUsage(state, raw) {
+    if (!state.turnUsage)
+        return;
+    // token_count 每次采样一条，末 turn 的所有采样求和（见 buildUsageFromScan）。
+    const cached = Math.min(raw.cached_input_tokens, raw.input_tokens);
+    state.turnUsage.input += raw.input_tokens - cached;
+    state.turnUsage.cached += cached;
+    state.turnUsage.output += raw.output_tokens;
+    state.turnUsage.total += raw.total_tokens;
+}
+function updateCompactPostContext(state, raw) {
+    // 压缩后的水位：压缩收尾 token_count 全 0（不满足 zero-filter），
+    // 但 total_tokens 表达真实窗口；之后若出现普通 turn（input>0），
+    // 水位回归该 turn，post-compact 值失效。
+    if (state.compactCount <= 0 || !raw)
+        return;
+    if (raw.total_tokens && !raw.input_tokens && !raw.cached_input_tokens && !raw.output_tokens) {
+        state.compactPostContextLength = raw.total_tokens;
+    }
+    else if (raw.input_tokens > 0) {
+        state.compactPostContextLength = undefined;
+    }
+}
+function handleTokenCount(state, payload) {
+    const info = payload.info;
+    const { raw, total } = resolveRawUsage(info, state.previousTotals);
+    if (total) {
+        state.previousTotals = total;
+        state.lastTotalUsage = total;
+    }
+    if (raw && (raw.input_tokens || raw.cached_input_tokens || raw.output_tokens)) {
+        state.previousRawUsage = state.lastRawUsage;
+        state.lastRawUsage = raw;
+        const ctxWindow = info?.model_context_window;
+        state.lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
+        accumulateTurnUsage(state, raw);
+    }
+    updateCompactPostContext(state, raw);
+}
+function handleEventMsg(state, payload) {
+    const human = extractRealUserText(payload);
+    if (human) {
+        recordHumanMessage(state, human);
+        return;
+    }
+    if (payload.type === 'task_started') {
+        // turn 边界：一个 turn 一条 task_started，从这里开始重新累计本 turn 的用量。
+        state.turnUsage = emptyTurnUsage();
+        return;
+    }
+    if (payload.type === 'token_count')
+        handleTokenCount(state, payload);
+}
+function handleCompacted(state, payload) {
+    // 顶层 compacted 事件：压缩次数 +1，压缩前水位取「压缩调用之前」那条非零
+    // token_count 的 total_tokens。真实 rollout 落盘顺序是
+    // 末轮 → 摘要调用 → compacted → 压缩后水位：摘要调用自身的 token_count 紧贴
+    // 在 compacted 之前，直接取 lastRawUsage 会把摘要调用的消耗当成压缩前窗口。
+    // compacted 自带的摘要调用 usage 用于判定并回退一条；旧数据无该字段时保持原语义。
+    state.compactCount++;
+    const compactCallTotal = readCompactedCallTotal(payload);
+    const preCompactUsage = compactCallTotal !== undefined && state.lastRawUsage?.total_tokens === compactCallTotal
+        ? state.previousRawUsage
+        : state.lastRawUsage;
+    if (preCompactUsage?.total_tokens !== undefined) {
+        state.compactPreContextLength = preCompactUsage.total_tokens;
+    }
+}
+function handleResponseItem(state, payload, timestamp) {
+    if (payload.type !== 'message' || !Array.isArray(payload.content))
+        return;
+    if (payload.role === 'user')
+        state.userResponseItemCount++;
+    const messages = extractMessageContent(payload);
+    for (const msg of messages) {
+        state.events.push({
+            type: msg.role === 'user' ? 'user' : 'assistant',
+            content: msg.text,
+            timestamp,
+        });
+    }
+}
+function dispatchRolloutLine(state, parsed, includeEvents) {
+    if (parsed.type === 'session_meta' && parsed.payload) {
+        state.sessionMeta = parsed.payload;
+        return;
+    }
+    if (parsed.type === 'event_msg' && parsed.payload) {
+        handleEventMsg(state, parsed.payload);
+        return;
+    }
+    if (parsed.type === 'compacted') {
+        handleCompacted(state, parsed.payload);
+        return;
+    }
+    if (includeEvents && parsed.type === 'response_item' && parsed.payload) {
+        handleResponseItem(state, parsed.payload, parsed.timestamp);
+    }
+}
 /**
  * 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).
+ *
+ * 真人输入只认 `user_message` / `item_completed.UserMessage`；`role:"user"`
+ * response_item 是注入 scaffolding，只用于漂移探针，不进 displayTitle。
  */
 function scanCodexRollout(filePath, includeEvents) {
-    const lines = readJsonlLines(filePath);
-    const events = [];
-    let sessionMeta = null;
-    // Real user input comes from the authoritative "human typed this" event —
-    // `user_message` on old codex, `item_completed`/UserMessage on new codex
-    // (see `extractRealUserText`). Injected scaffolding (project rules,
-    // <environment_context>, permissions) is written as `role:"user"`
-    // response_items but gets NEITHER event, so it stays excluded from
-    // displayTitle/recap/summary. Regression 2026-07-13: the first `role:user`
-    // message is the injected project rules, mistakenly shown as "最近输入".
-    const realUserMessages = [];
-    // Which channel produced the last pushed message — used only to collapse a
-    // hypothetical double-write (same turn logged by both the legacy and the
-    // item channel), never to drop real consecutive input.
-    let lastUserMessageSource = null;
-    // Drift probe: count of `role:"user"` response_items (injected scaffolding
-    // included). If a file has those but yields zero real user messages, the
-    // event vocabulary changed again and displayTitle silently went empty —
-    // exactly the 0.153 compatibility incident shape.
-    let userResponseItemCount = 0;
-    // token_count tracking: codex emits cumulative `total_token_usage` and an
-    // incremental `last_token_usage` **per sampling call** — one turn with tool
-    // round-trips logs several `token_count` lines. We want the LAST turn's usage
-    // = the sum of that turn's samplings (matches pi/opencode /resume "last turn"
-    // display semantics). Turn boundaries come from `task_started`. When
-    // last_token_usage is absent we derive it as total - previous_total.
-    let lastRawUsage;
-    /** 上一条被接受的 raw usage；compacted 分支回退一条时用（见下方注释）。 */
-    let previousRawUsage;
-    /**
-     * 末个 turn 的累计用量；`null` = 文件里没有 `task_started`（旧数据），
-     * 此时 flow 字段退回「末条 token_count」语义（见 buildUsageFromScan）。
-     */
-    let turnUsage = null;
-    // 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。
-    // 单位口径：前后两侧统一用 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 state = newScanState();
+    for (const line of readJsonlLines(filePath)) {
         const trimmed = line.trim();
         if (!trimmed)
             continue;
@@ -185,138 +307,15 @@ function scanCodexRollout(filePath, includeEvents) {
             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) {
-                const payload = parsed.payload;
-                const human = extractRealUserText(payload);
-                if (human) {
-                    const text = human.text.slice(0, 200);
-                    const prev = realUserMessages[realUserMessages.length - 1];
-                    // 过渡期防御：同一 turn 若被旧版 user_message 与新版 item_completed
-                    // 各写一次，会得到相邻重复。仅在「通道切换且文本与上一条完全相同」
-                    // 时跳过——同通道连续相同输入（真人连发两条一样的话）不受影响。
-                    const duplicateAcrossChannels = lastUserMessageSource !== null &&
-                        lastUserMessageSource !== human.source &&
-                        prev === text;
-                    if (!duplicateAcrossChannels) {
-                        realUserMessages.push(text);
-                    }
-                    lastUserMessageSource = human.source;
-                }
-                else if (payload.type === 'task_started') {
-                    // turn 边界：一个 turn 一条 task_started（与 task_complete 成对，
-                    // turn_id 见 session_meta 之后的 `turn_context`）。从这里开始重新
-                    // 累计本 turn 的用量。
-                    turnUsage = emptyTurnUsage();
-                }
-                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)) {
-                        previousRawUsage = lastRawUsage;
-                        lastRawUsage = raw;
-                        const ctxWindow = info?.model_context_window;
-                        lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
-                        if (turnUsage) {
-                            const cached = Math.min(raw.cached_input_tokens, raw.input_tokens);
-                            turnUsage.input += raw.input_tokens - cached;
-                            turnUsage.cached += cached;
-                            turnUsage.output += raw.output_tokens;
-                            turnUsage.total += raw.total_tokens;
-                        }
-                    }
-                    // 压缩后的水位：压缩收尾 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 的 total_tokens。真实 rollout 落盘顺序是
-                // 末轮 → 摘要调用 → compacted → 压缩后水位：摘要调用自身的 token_count 紧贴
-                // 在 compacted 之前，直接取 lastRawUsage 会把摘要调用的消耗当成压缩前窗口
-                // （实测把 363K 的窗口显示成 207K）。compacted 自带的摘要调用 usage 用于判定
-                // 并回退一条；旧数据没有 latest_token_usage_record 时保持原语义。
-                compactCount++;
-                const compactCallTotal = readCompactedCallTotal(parsed.payload);
-                const preCompactUsage = compactCallTotal !== undefined && lastRawUsage?.total_tokens === compactCallTotal
-                    ? previousRawUsage
-                    : lastRawUsage;
-                if (preCompactUsage?.total_tokens !== undefined) {
-                    compactPreContextLength = preCompactUsage.total_tokens;
-                }
-            }
-            else if (includeEvents && parsed.type === 'response_item' && parsed.payload) {
-                const payload = parsed.payload;
-                if (payload.type === 'message' && Array.isArray(payload.content)) {
-                    if (payload.role === 'user')
-                        userResponseItemCount++;
-                    // 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,
-                        });
-                    }
-                }
-            }
+            dispatchRolloutLine(state, parsed, includeEvents);
         }
         catch {
             // Skip malformed lines
             continue;
         }
     }
-    // 兼容性漂移探针：文件里有 `role:"user"` 注入，却识别不出任何真人输入 ——
-    // 说明 codex 又换了 event_msg 词表，displayTitle 会静默变空（0.153 事故形态）。
-    // 只告警不兜底：误用注入文本当标题正是 2026-07-13 修掉的缺陷。
-    if (realUserMessages.length === 0 && userResponseItemCount > 0) {
-        getLogger().warn(`[codex-rollout-reader] no human user message recognised in ${filePath} ` +
-            `(${userResponseItemCount} role:"user" response_items seen) — codex rollout ` +
-            `event vocabulary may have changed; session title will be empty`);
-    }
-    return {
-        sessionMeta,
-        events,
-        realUserMessages,
-        lastRawUsage,
-        lastContextLimit,
-        lastTotalUsage,
-        previousTotals,
-        turnUsage,
-        compactCount,
-        compactPreContextLength,
-        compactPostContextLength,
-    };
+    warnIfVocabularyDrift(state, filePath);
+    return scanResult(state);
 }
 /**
  * Build ccusage-aligned usage from a scan's last-turn raw tokens.
@@ -720,7 +719,7 @@ export function clearSessionIndexCache() {
  *   event. Codex emitted it ONLY for text the human actually typed; injected
  *   scaffolding (project rules, `<environment_context>`, permissions) is
  *   written as `role:"user"` response_items but gets NO such event, so it stays
- *   out of displayTitle/recap/summary. (Regression 2026-07-13: the first
+ *   out of displayTitle/recap/summary. (Without this, the first
  *   `role:user` message is the injected project rules, once shown as 最近输入.)
  * - Current (CLI ≥0.153.4, transitional from 0.147.0): the `user_message` /
  *   `agent_message` events were removed; the same authoritative text now rides
@@ -729,7 +728,7 @@ export function clearSessionIndexCache() {
  *   input, `skill` parts are injected skill files (e.g. a `$skill-name`
  *   invocation) that must not leak into the title.
  *
- * Real-data note (2026-09): no rollout file observed carries BOTH spellings;
+ * Real-data note: no rollout file observed carries BOTH spellings;
  * 0.147–0.149 are transitional (either spelling per file), 0.153.4+/0.154.0 are
  * item_completed-only. `source` reports which spelling matched so the scanner
  * can collapse a hypothetical double-write of the same turn.

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

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

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

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