lark-remote 0.5.19 → 0.5.21

package/dist/session/kimi/sessions.js

@@ -2,8 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { readJsonlLines as readJsonlLinesShared, readLastNJsonlLines } from '../common/jsonl.js';
-import { UsageAccumulator, cumulativeUsageFields } from '../common/usage-accumulator.js';
+import { cumulativeUsageFields } from '../common/usage-accumulator.js';
+import { throwSessionListError } from '../common/throw-session-list-error.js';
 import { getLogger } from '../../logger/index.js';
+import { logNonEnoentDebug } from '../session-store.js';
 import { isStale } from '../common/constants.js';
 import { safeRealpath, samePath } from '../../platform/path.js';
 import { capEvents, paginate } from '../common/pagination.js';
@@ -134,6 +136,233 @@ export function checkCwdGuard(state, realCwd) {
         return 'verified';
     return 'failed';
 }
+function emptyKimiTotals() {
+    return { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+}
+/**
+ * kimi 主 wire usage 扫描累积器（纯函数）：单遍解析，产出会话累计、末 turn
+ * flow、上下文水位与压缩统计。
+ *
+ * 产生：KimiWireUsageScan。依赖：入参 lines（已解析前的原始行）。不改任何
+ * 外部状态；畸形行跳过，畸形 usage.record 按字段 0 计但记为「有数据」。
+ */
+export function scanKimiUsage(lines) {
+    const totals = emptyKimiTotals();
+    let turn;
+    // contextLength is only from the main wire's last usage.record
+    // (subagent context is an independent window).
+    let mainContextLength = 0;
+    // §6.3: Compaction stats — count compact events, track last pre-compact context.
+    let compactCount = 0;
+    let compactPreContextLength;
+    // Distinguish "no usage.record in any wire file" (no data → usage:
+    // undefined, downstream omits the token block) from "records exist but
+    // are all zero / malformed" (real data → aggregate with ?? 0 and return
+    // the zeros as-is). A malformed record (usage.record line with missing
+    // usage object/fields) still counts as data.
+    let hasUsageRecord = false;
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (isUsageRecord(entry)) {
+            hasUsageRecord = true;
+            // Malformed records (missing usage object or missing fields) must
+            // not poison the accumulators with NaN: count missing fields as 0.
+            const inputOther = entry.usage?.inputOther ?? 0;
+            const output = entry.usage?.output ?? 0;
+            const inputCacheRead = entry.usage?.inputCacheRead ?? 0;
+            const inputCacheCreation = entry.usage?.inputCacheCreation ?? 0;
+            totals.input += inputOther;
+            totals.output += output;
+            totals.cacheRead += inputCacheRead;
+            totals.cacheCreation += inputCacheCreation;
+            if (turn) {
+                turn.input += inputOther;
+                turn.output += output;
+                turn.cacheRead += inputCacheRead;
+                turn.cacheCreation += inputCacheCreation;
+            }
+            // unified contract (§9.21): input + output + cacheRead + cacheCreation.
+            // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
+            // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
+            mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
+            continue;
+        }
+        // §6.3: Count compaction events and track pre-compact context length.
+        // 展示计数只计 context.apply_compaction：一次手动 /compact 会同时写
+        // full_compaction.complete + context.apply_compaction 两条（2026-08-16
+        // 实弹 wire.jsonl），双计会把一次压缩虚报成 2 次。full_compaction.complete
+        // 仅作 runCompact 轮询的完成信号（readCompactionRecords 仍返回两种）。
+        if (isCompactionComplete(entry) && entry.type === 'context.apply_compaction') {
+            compactCount++;
+            // Capture context length before this compaction as the pre-compact
+            // watermark (the most recent one is most relevant for display).
+            if (entry.tokensBefore !== undefined) {
+                compactPreContextLength = entry.tokensBefore;
+            }
+            continue;
+        }
+        // turn.prompt 是 turn 的起点：本 turn 的 flow 从这里重新累计。
+        if (isTurnPrompt(entry)) {
+            turn = emptyKimiTotals();
+            continue;
+        }
+    }
+    return { totals, turn, mainContextLength, compactCount, compactPreContextLength, hasUsageRecord };
+}
+/**
+ * kimi 子 agent wire usage 扫描（只读 I/O）：agents/<name>/wire.jsonl（main
+ * 以外的兄弟目录）与主会话同属同一计费实体，token 消耗必须并入会话累计；
+ * contextLength/展示事件不取子 agent。目录不可读或文件缺失静默跳过。
+ *
+ * 产生：KimiSubagentUsageScan。依赖：文件系统（agentsDir 只读）。不改外部状态。
+ */
+function scanKimiSubagentUsage(agentsDir) {
+    const totals = emptyKimiTotals();
+    let hasUsageRecord = false;
+    try {
+        for (const dirent of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+            if (!dirent.isDirectory() || dirent.name === 'main') {
+                continue;
+            }
+            const subWirePath = path.join(agentsDir, dirent.name, 'wire.jsonl');
+            if (!fs.existsSync(subWirePath)) {
+                continue;
+            }
+            for (const subLine of readJsonlLines(subWirePath)) {
+                try {
+                    const subEntry = JSON.parse(subLine);
+                    if (isUsageRecord(subEntry)) {
+                        hasUsageRecord = true;
+                        totals.input += subEntry.usage?.inputOther ?? 0;
+                        totals.output += subEntry.usage?.output ?? 0;
+                        totals.cacheRead += subEntry.usage?.inputCacheRead ?? 0;
+                        totals.cacheCreation += subEntry.usage?.inputCacheCreation ?? 0;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        // agents dir unreadable — fall back to main-only usage
+    }
+    return { totals, hasUsageRecord };
+}
+/**
+ * kimi usage 装配（tail 装配段，纯函数）：末 turn flow + 会话累计（主 wire +
+ * 子 agent）+ 主 wire 水位 + 压缩统计 → AgentSessionUsage。
+ *
+ * 有 turn.prompt 时本 run = 末个 turn 的 flow；末 turn 还没有记录时
+ * turn 为全 0。整份 wire 都没有 turn.prompt（旧数据/截断）时无从分段，
+ * 沿用「整份文件 = 一个 turn」的旧口径（含子 agent wire）。
+ */
+function assembleKimiUsage(main, sub) {
+    const totals = {
+        input: main.totals.input + sub.totals.input,
+        output: main.totals.output + sub.totals.output,
+        cacheRead: main.totals.cacheRead + sub.totals.cacheRead,
+        cacheCreation: main.totals.cacheCreation + sub.totals.cacheCreation,
+    };
+    const flow = main.turn ?? totals;
+    // Kimi semantics: preserve 0 values (not undefined) for cache fields to match original
+    return {
+        inputTokens: flow.input,
+        outputTokens: flow.output,
+        contextLength: main.mainContextLength,
+        cacheReadTokens: flow.cacheRead > 0 ? flow.cacheRead : 0,
+        cacheCreationTokens: flow.cacheCreation > 0 ? flow.cacheCreation : 0,
+        totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheCreation,
+        // Cumulative (session-wide): sums every usage.record across all turns
+        // (subagent wires included) — the "累计" line, never the per-run value.
+        ...cumulativeUsageFields(totals),
+        // §6.3: compaction stats from wire.jsonl
+        compactCount: main.compactCount,
+        ...(main.compactPreContextLength !== undefined
+            ? { compactPreContextLength: main.compactPreContextLength }
+            : {}),
+    };
+}
+/**
+ * kimi 主 wire 展示装配（纯函数）：turn.prompt 提取 displayTitle，loop event
+ * 映射为展示事件。tool.call/tool.result 是**独立的 loop event**（对照真实
+ * wire.jsonl 验证过的结构，勿合并/改形）。
+ *
+ * 产生：KimiEventScan。依赖：入参 lines。不改任何外部状态。
+ */
+function scanKimiEvents(lines) {
+    const events = [];
+    let displayTitle;
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // displayTitle + display events now scan ALL lines (not a
+        // line-slice), then `events.slice(-maxEvents)` keeps the LAST N
+        // EVENTS. Previously `lines.slice(-maxEvents)` cut raw lines, but
+        // usage.record / step.begin / turn.prompt lines produce no display
+        // event, so "last 5 lines" could yield only 1~2 visible events —
+        // and `slice(-0)` returned the full array. displayTitle takes the
+        // last turn.prompt across the whole session (the most recent user
+        // prompt), which is the correct catch-up title.
+        // Extract display title from turn.prompt
+        if (isTurnPrompt(entry)) {
+            if (entry.input && entry.input.length > 0) {
+                displayTitle = entry.input[0].text;
+            }
+            continue;
+        }
+        // Convert loop events to content events
+        if (isAppendLoopEvent(entry)) {
+            const evt = entry.event;
+            if (evt.type === 'content.part' && evt.part) {
+                if (evt.part.type === 'think') {
+                    // Skip thinking blocks for display
+                    continue;
+                }
+                else if (evt.part.type === 'text' && evt.part.text) {
+                    events.push({
+                        type: 'text',
+                        content: evt.part.text,
+                    });
+                }
+            }
+            else if (evt.type === 'tool.call' && evt.name) {
+                // 复用 content-blocks 的 200 字符截断：大 args（整段文件内容
+                // 写入、长 prompt）原文进事件会把 resume 卡顶到 28KB 预算之外
+                // （2026-08-08 extreme_fallback 故障的推手之一）。
+                const inputStr = truncateToolInput(JSON.stringify(evt.args ?? {}));
+                events.push({
+                    type: 'tool_use',
+                    content: `${evt.name}(${inputStr})`,
+                });
+            }
+            else if (evt.type === 'tool.result') {
+                // result is { output }, { output, note }, or { isError, output }
+                // 对齐 opencode reader 的预折叠：单条 tool_result 上限
+                // TOOL_RESULT_MAX_BYTES，病理级输出（如 51KB 文件读取）不会
+                // 撑爆 resume 卡，也约束 events[] 内存占用。
+                const rawOut = evt.result?.output ?? `[tool result for ${evt.toolCallId}]`;
+                events.push({
+                    type: 'tool_result',
+                    content: truncateUtf8(rawOut, TOOL_RESULT_MAX_BYTES),
+                });
+            }
+        }
+    }
+    return { events, displayTitle };
+}
 /**
  * Kimi Session Reader
  * Reads session history from ~/.kimi-code/
@@ -168,39 +397,6 @@ export class KimiSessionReader {
     findSessionIndexEntry(sessionId) {
         return this.scanSessionIndex().find((e) => e.sessionId === sessionId);
     }
-    /**
-     * Extract the last turn.prompt text from a wire.jsonl file.
-     * Used as a fallback summary source when state.json has no title/lastPrompt
-     * (v2 sessions). Scans the tail of the file for efficiency.
-     * Returns undefined if no turn.prompt is found.
-     */
-    extractLastPromptFromWire(wirePath) {
-        try {
-            if (!fs.existsSync(wirePath))
-                return undefined;
-            // Scan backwards from the tail — turn.prompt is typically near the end
-            // of a completed turn (before content.part / step.end / usage.record).
-            const lines = readLastNJsonlLines(wirePath, 50);
-            let lastPrompt;
-            for (const line of lines) {
-                try {
-                    const entry = JSON.parse(line);
-                    if (isTurnPrompt(entry)) {
-                        if (entry.input && entry.input.length > 0) {
-                            lastPrompt = entry.input[0].text;
-                        }
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            return lastPrompt?.substring(0, 200);
-        }
-        catch {
-            return undefined;
-        }
-    }
     /**
      * List all sessions for a given working directory
      */
@@ -208,87 +404,16 @@ export class KimiSessionReader {
         try {
             // 归一失败（陈旧/无权限 cwd）回退原样输入，让逐条 samePath 比较去决定
             // 空态——一次 realpathSync 抛错不得把整张列表清掉（与 opencode 同口径）。
-            const realCwd = safeRealpath(cwd, (err) => {
-                if (err.code === 'ENOENT')
-                    return;
-                getLogger().debug(`[kimi-session-reader] realpath ${cwd} failed, using the path as given: ${err?.message ?? String(err)}`);
-            });
+            const realCwd = safeRealpath(cwd, logKimiRealpathFailure.bind(null, cwd));
             const sessions = [];
             for (const entry of this.scanSessionIndex()) {
-                // state.json 一次读取共用（cwd 兜底 + summary），I/O 减半。
-                // 两次 catch 语义保留：解析失败 = 无法判 cwd → 跳过（continue）；
-                // 解析成功但字段缺失 = summary 落 wire.jsonl 提取。
-                const statePath = path.join(entry.sessionDir, 'state.json');
-                let state = null;
-                let stateParsed = false;
-                if (fs.existsSync(statePath)) {
-                    try {
-                        state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-                        stateParsed = true;
-                    }
-                    catch (err) {
-                        getLogger().debug(`[kimi-session-reader] corrupt state.json skipped session=${entry.sessionId}: ${err?.message ?? String(err)}`);
-                    }
-                }
-                // Index workDir is v1-only; v2 sessions may have empty/missing workDir.
-                // When index workDir is absent, fall back to state.json's cwd field.
-                let entryWorkDir = entry.workDir;
-                if (!entryWorkDir) {
-                    if (stateParsed && state)
-                        entryWorkDir = extractWorkDir(state);
-                    // Unreadable state — cannot determine cwd, entryWorkDir stays undefined
-                }
-                // cwd 判定与守卫（checkCwdGuard 的 samePath）同口径：严格字符串比较会
-                // 把大小写（darwin）/尾分隔符形态不同的会话从列表里滤掉，而 /resume <id>
-                // 的守卫却判等通过——「列表没有、按 id 却能读」。
-                if (entryWorkDir === undefined || !samePath(entryWorkDir, realCwd)) {
-                    continue;
-                }
-                let summary = 'New Session';
-                if (stateParsed && state) {
-                    // v1: state.title / state.lastPrompt; v2: these fields may be absent
-                    summary = state.title || state.lastPrompt || '';
-                }
-                // v2 state.json omits title/lastPrompt: extract from wire.jsonl's last
-                // turn.prompt instead. Only scan a small tail to find it — the summary
-                // only needs the most recent user prompt.
-                if (!summary) {
-                    const wirePath = path.join(entry.sessionDir, 'agents', 'main', 'wire.jsonl');
-                    summary = this.extractLastPromptFromWire(wirePath) || 'New Session';
-                }
-                // Get mtime. the session DIRECTORY mtime only changes when
-                // entries are created/deleted/renamed inside it — kimi appending to
-                // agents/main/wire.jsonl during a run does NOT touch it, so dir-mtime
-                // sorting lags real activity by minutes. Use the wire.jsonl mtime
-                // (the file kimi keeps writing while the session is active) and fall
-                // back to the dir mtime when the wire file is missing (e.g. a session
-                // that never produced output).
-                const wirePath = path.join(entry.sessionDir, 'agents', 'main', 'wire.jsonl');
-                let mtimeMs;
-                try {
-                    mtimeMs = fs.statSync(wirePath).mtimeMs;
-                }
-                catch {
-                    try {
-                        mtimeMs = fs.statSync(entry.sessionDir).mtimeMs;
-                    }
-                    catch (err) {
-                        if (err.code !== 'ENOENT') {
-                            getLogger().warn(`[kimi-session-reader] cannot stat ${entry.sessionDir}: ${err?.message ?? String(err)}`);
-                        }
-                        // 会话目录已不存在（或被清理）：跳过该条，别让它拖垮整张列表。
-                        continue;
-                    }
-                }
-                sessions.push({
-                    sessionId: entry.sessionId,
-                    summary,
-                    mtime: mtimeMs,
-                });
+                const row = collectKimiSession(entry, realCwd);
+                if (row)
+                    sessions.push(row);
             }
             // Sort by mtime descending; same-mtime ties use a deterministic
             // secondary key so ordering is stable across scans.
-            sortByRecencyDesc(sessions, (s) => s.mtime, (s) => s.sessionId);
+            sortByRecencyDesc(sessions, kimiRowMtime, kimiRowId);
             const { items, total } = paginate(sessions, opts ?? {});
             return {
                 sessions: items,
@@ -302,9 +427,7 @@ export class KimiSessionReader {
             if (error.code === 'ENOENT') {
                 return { sessions: [], total: 0 };
             }
-            getLogger().error(`[kimi-session-reader] listSessions failed: ${error}`);
-            const msg = error instanceof Error ? error.message : String(error);
-            throw new Error(`kimi session list 读取失败: ${msg}`, { cause: error });
+            throwSessionListError('kimi', error);
         }
     }
     /**
@@ -315,6 +438,11 @@ export class KimiSessionReader {
     }
     /**
      * Read session content (events + usage)
+     *
+     * 编排：cwd 守卫定位主 wire（resolveSessionWirePath，与 isSessionActive
+     * 共用 verifySessionCwd 单源）→ 主 wire 两遍只读扫描（scanKimiEvents 出
+     * 展示流 + displayTitle，scanKimiUsage 出累计/flow/水位/压缩统计）→ 子
+     * agent wire 只进 usage 累计 → assembleKimiUsage 组装。
      */
     readSessionContent(sessionId, cwd, opts) {
         const wirePath = this.resolveSessionWirePath(sessionId, cwd);
@@ -323,144 +451,8 @@ export class KimiSessionReader {
         }
         try {
             const lines = Array.from(readJsonlLines(wirePath));
-            const maxEvents = opts?.maxEvents ?? Number.MAX_SAFE_INTEGER;
-            const events = [];
-            let displayTitle;
-            const acc = new UsageAccumulator();
-            // contextLength is only from the main wire's last usage.record
-            // (subagent context is an independent window). Tracked separately
-            // from the accumulator's `last` (which could be a subagent record).
-            let mainContextLength = 0;
-            // §6.3: Compaction stats — count compact events, track last pre-compact context.
-            let compactCount = 0;
-            let compactPreContextLength;
-            // Distinguish "no usage.record in any wire file" (no data → usage:
-            // undefined, downstream omits the token block) from "records exist but
-            // are all zero / malformed" (real data → aggregate with ?? 0 and return
-            // the zeros as-is). A malformed record (usage.record line with missing
-            // usage object/fields) still counts as data.
-            let hasUsageRecord = false;
-            // ccusage-style session-wide aggregation via UsageAccumulator: sum
-            // every usage.record's per-component tokens; contextLength is the
-            // current context window occupancy (not summable) — keep only the
-            // last record's value, and only from the main wire (subagent context
-            // is an independent window). Aggregation covers the whole wire.jsonl
-            // and is independent of the maxEvents display slice
-            // (usage = the session's overall token cost).
-            //
-            // 本 run 的 flow 字段是**末个 turn**（最后一个 turn.prompt 之后）的记录之和：
-            // kimi 每次模型调用写一条 usage.record，带工具往返的 turn 会有多条。只取
-            // 末条会低报，取会话总量（旧实现）又会把历史所有 run 的消耗算进这一轮。
-            // 子 agent 的 wire 没有 turn 标记，只能进会话累计（无法归属到某一轮）；
-            // 整份 wire 都没有 turn.prompt（旧数据）时沿用「整份文件 = 一个 turn」。
-            // 末个 turn 尚无 usage.record 时 flow = 0（当前契约是「末个 turn」，不是
-            // 「末个非空 turn」）——不能退回上一轮的记录。
-            let turnAcc = null;
-            const accumulateUsage = (u, scope) => {
-                hasUsageRecord = true;
-                // Malformed records (missing usage object or missing fields) must
-                // not poison the accumulators with NaN: count missing fields as 0.
-                const inputOther = u?.inputOther ?? 0;
-                const output = u?.output ?? 0;
-                const inputCacheRead = u?.inputCacheRead ?? 0;
-                const inputCacheCreation = u?.inputCacheCreation ?? 0;
-                const record = {
-                    input: inputOther,
-                    output,
-                    cacheRead: inputCacheRead,
-                    cacheCreation: inputCacheCreation,
-                };
-                acc.add(record);
-                if (scope !== 'main')
-                    return;
-                turnAcc?.add(record);
-                // unified contract (§9.21): input + output + cacheRead + cacheCreation.
-                // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
-                // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
-                mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
-            };
-            for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-                const line = lines[lineIndex];
-                try {
-                    const entry = JSON.parse(line);
-                    // Extract usage from usage.record.
-                    if (isUsageRecord(entry)) {
-                        accumulateUsage(entry.usage, 'main');
-                        continue;
-                    }
-                    // §6.3: Count compaction events and track pre-compact context length.
-                    // 展示计数只计 context.apply_compaction：一次手动 /compact 会同时写
-                    // full_compaction.complete + context.apply_compaction 两条（2026-08-16
-                    // 实弹 wire.jsonl），双计会把一次压缩虚报成 2 次。full_compaction.complete
-                    // 仅作 runCompact 轮询的完成信号（readCompactionRecords 仍返回两种）。
-                    if (isCompactionComplete(entry) && entry.type === 'context.apply_compaction') {
-                        compactCount++;
-                        // Capture context length before this compaction as the pre-compact
-                        // watermark (the most recent one is most relevant for display).
-                        if (entry.tokensBefore !== undefined) {
-                            compactPreContextLength = entry.tokensBefore;
-                        }
-                        continue;
-                    }
-                    // displayTitle + display events now scan ALL lines (not a
-                    // line-slice), then `events.slice(-maxEvents)` keeps the LAST N
-                    // EVENTS. Previously `lines.slice(-maxEvents)` cut raw lines, but
-                    // usage.record / step.begin / turn.prompt lines produce no display
-                    // event, so "last 5 lines" could yield only 1~2 visible events —
-                    // and `slice(-0)` returned the full array. displayTitle takes the
-                    // last turn.prompt across the whole session (the most recent user
-                    // prompt), which is the correct catch-up title.
-                    // Extract display title from turn.prompt
-                    if (isTurnPrompt(entry)) {
-                        // turn.prompt 是 turn 的起点：本 turn 的 flow 从这里重新累计。
-                        turnAcc = new UsageAccumulator();
-                        if (entry.input && entry.input.length > 0) {
-                            displayTitle = entry.input[0].text;
-                        }
-                        continue;
-                    }
-                    // Convert loop events to content events
-                    if (isAppendLoopEvent(entry)) {
-                        const evt = entry.event;
-                        if (evt.type === 'content.part' && evt.part) {
-                            if (evt.part.type === 'think') {
-                                // Skip thinking blocks for display
-                                continue;
-                            }
-                            else if (evt.part.type === 'text' && evt.part.text) {
-                                events.push({
-                                    type: 'text',
-                                    content: evt.part.text,
-                                });
-                            }
-                        }
-                        else if (evt.type === 'tool.call' && evt.name) {
-                            // 复用 content-blocks 的 200 字符截断：大 args（整段文件内容
-                            // 写入、长 prompt）原文进事件会把 resume 卡顶到 28KB 预算之外
-                            // （2026-08-08 extreme_fallback 故障的推手之一）。
-                            const inputStr = truncateToolInput(JSON.stringify(evt.args ?? {}));
-                            events.push({
-                                type: 'tool_use',
-                                content: `${evt.name}(${inputStr})`,
-                            });
-                        }
-                        else if (evt.type === 'tool.result') {
-                            // result is { output }, { output, note }, or { isError, output }
-                            // 对齐 opencode reader 的预折叠：单条 tool_result 上限
-                            // TOOL_RESULT_MAX_BYTES，病理级输出（如 51KB 文件读取）不会
-                            // 撑爆 resume 卡，也约束 events[] 内存占用。
-                            const rawOut = evt.result?.output ?? `[tool result for ${evt.toolCallId}]`;
-                            events.push({
-                                type: 'tool_result',
-                                content: truncateUtf8(rawOut, TOOL_RESULT_MAX_BYTES),
-                            });
-                        }
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
+            const { events, displayTitle } = scanKimiEvents(lines);
+            const mainUsage = scanKimiUsage(lines);
             // Subagent wire files (agents/<name>/wire.jsonl, e.g. Task-derived
             // agent-0..N) belong to the same session and the same billing entity:
             // their token cost must be summed into the session-wide usage.
@@ -470,56 +462,12 @@ export class KimiSessionReader {
             // wirePath = <sessionDir>/agents/main/wire.jsonl → agents dir is two
             // levels up (siblings of main hold subagent wires).
             const agentsDir = path.dirname(path.dirname(wirePath));
-            try {
-                for (const dirent of fs.readdirSync(agentsDir, { withFileTypes: true })) {
-                    if (!dirent.isDirectory() || dirent.name === 'main') {
-                        continue;
-                    }
-                    const subWirePath = path.join(agentsDir, dirent.name, 'wire.jsonl');
-                    if (!fs.existsSync(subWirePath)) {
-                        continue;
-                    }
-                    for (const subLine of readJsonlLines(subWirePath)) {
-                        try {
-                            const subEntry = JSON.parse(subLine);
-                            if (isUsageRecord(subEntry)) {
-                                accumulateUsage(subEntry.usage, 'subagent');
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            }
-            catch {
-                // agents dir unreadable — fall back to main-only usage
-            }
-            // Build the final AgentSessionUsage from the last turn's flow + session
-            // cumulative + main contextLength.
-            const t = acc.totals;
-            // 有 turn.prompt 时本 run = 末个 turn 的 flow；末 turn 还没有记录时
-            // turnAcc.count = 0 → flow = 0。整份 wire 都没有 turn.prompt（旧数据/
-            // 截断）时无从分段，沿用「整份文件 = 一个 turn」的旧口径（含子 agent wire）。
-            const flow = turnAcc ? turnAcc.totals : t;
-            // Kimi semantics: preserve 0 values (not undefined) for cache fields to match original
-            const totalUsage = {
-                inputTokens: flow.input,
-                outputTokens: flow.output,
-                contextLength: mainContextLength,
-                cacheReadTokens: flow.cacheRead > 0 ? flow.cacheRead : 0,
-                cacheCreationTokens: flow.cacheCreation > 0 ? flow.cacheCreation : 0,
-                totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheCreation,
-                // Cumulative (session-wide): sums every usage.record across all turns
-                // (subagent wires included) — the "累计" line, never the per-run value.
-                ...cumulativeUsageFields(t),
-                // §6.3: compaction stats from wire.jsonl
-                compactCount,
-                ...(compactPreContextLength !== undefined ? { compactPreContextLength } : {}),
-            };
+            const subUsage = scanKimiSubagentUsage(agentsDir);
             return {
-                events: capEvents(events, maxEvents),
-                usage: hasUsageRecord ? totalUsage : undefined,
+                events: capEvents(events, opts?.maxEvents),
+                usage: mainUsage.hasUsageRecord || subUsage.hasUsageRecord
+                    ? assembleKimiUsage(mainUsage, subUsage)
+                    : undefined,
                 displayTitle,
             };
         }
@@ -704,9 +652,133 @@ export class KimiSessionReader {
             // Consider the session inactive when its last loop event is step.end
             return !lastLoopEventIsStepEnd(lines);
         }
-        catch {
+        catch (err) {
+            getLogger().debug('[kimi-session-reader] isSessionActive failed:', err);
             return false;
         }
     }
 }
+// --- listSessions 装配原语（模块级命名函数 + 显式传参） ---
+// 纯结构拆分：listSessions 只做 realpath / 遍历 / 排序分页 / 错误降级，
+// 单条会话的 state 读取、cwd 守卫、summary 三级回退、mtime 回退全部下沉到
+// 这些模块级函数。文案、跳过条件、排序键、分页口径逐项保持。
+/** realpath 归一化失败（非 ENOENT）留痕；ENOENT 静默沿用原 cwd。 */
+function logKimiRealpathFailure(cwd, err) {
+    logNonEnoentDebug(err, (m) => `[kimi-session-reader] realpath ${cwd} failed, using the path as given: ${m}`);
+}
+/** state.json 一次读取共用（cwd 兜底 + summary），I/O 减半。 */
+function readKimiState(sessionDir, sessionId) {
+    const statePath = path.join(sessionDir, 'state.json');
+    if (!fs.existsSync(statePath))
+        return { state: null, stateParsed: false };
+    try {
+        return {
+            state: JSON.parse(fs.readFileSync(statePath, 'utf-8')),
+            stateParsed: true,
+        };
+    }
+    catch (err) {
+        // 解析失败 = 无法判 cwd → 不 continue，留给 index workDir 兜底。
+        getLogger().debug(`[kimi-session-reader] corrupt state.json skipped session=${sessionId}: ${err?.message ?? String(err)}`);
+        return { state: null, stateParsed: false };
+    }
+}
+/** index workDir 优先，缺失时回退 state.json 的 workDir/cwd。 */
+function resolveKimiEntryWorkDir(entry, read) {
+    let entryWorkDir = entry.workDir;
+    if (!entryWorkDir && read.stateParsed && read.state) {
+        entryWorkDir = extractWorkDir(read.state);
+    }
+    return entryWorkDir;
+}
+/**
+ * 从 wire.jsonl 末段提取最后一条 turn.prompt。
+ * v2 state.json 省略 title/lastPrompt 时作为 summary 兜底；只扫尾部 50 行。
+ */
+function extractLastPromptFromWire(wirePath) {
+    try {
+        if (!fs.existsSync(wirePath))
+            return undefined;
+        // Scan backwards from the tail — turn.prompt is typically near the end
+        // of a completed turn (before content.part / step.end / usage.record).
+        const lines = readLastNJsonlLines(wirePath, 50);
+        let lastPrompt;
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (isTurnPrompt(entry)) {
+                    if (entry.input && entry.input.length > 0) {
+                        lastPrompt = entry.input[0].text;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return lastPrompt?.substring(0, 200);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** summary：state.title / lastPrompt → wire turn.prompt → 'New Session'。 */
+function kimiSessionSummary(sessionDir, read) {
+    let summary = 'New Session';
+    if (read.stateParsed && read.state) {
+        // v1: state.title / state.lastPrompt; v2: these fields may be absent
+        summary = read.state.title || read.state.lastPrompt || '';
+    }
+    if (!summary) {
+        const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
+        summary = extractLastPromptFromWire(wirePath) || 'New Session';
+    }
+    return summary;
+}
+/**
+ * 排序用 mtime：wire.jsonl 优先（run 期间持续写入），缺失回退会话目录
+ * mtime；目录也不可读（非 ENOENT 留痕）返回 null，由调用方跳过该条。
+ */
+function kimiSessionMtime(sessionDir) {
+    const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
+    try {
+        return fs.statSync(wirePath).mtimeMs;
+    }
+    catch {
+        try {
+            return fs.statSync(sessionDir).mtimeMs;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                getLogger().warn(`[kimi-session-reader] cannot stat ${sessionDir}: ${err?.message ?? String(err)}`);
+            }
+            // 会话目录已不存在（或被清理）：跳过该条，别让它拖垮整张列表。
+            return null;
+        }
+    }
+}
+/** 单条 index entry → 列表行；cwd 不匹配 / 目录不可读时返回 null（跳过）。 */
+function collectKimiSession(entry, realCwd) {
+    const read = readKimiState(entry.sessionDir, entry.sessionId);
+    const entryWorkDir = resolveKimiEntryWorkDir(entry, read);
+    if (entryWorkDir === undefined || !samePath(entryWorkDir, realCwd)) {
+        return null;
+    }
+    const summary = kimiSessionSummary(entry.sessionDir, read);
+    const mtimeMs = kimiSessionMtime(entry.sessionDir);
+    if (mtimeMs === null)
+        return null;
+    return {
+        sessionId: entry.sessionId,
+        summary,
+        mtime: mtimeMs,
+    };
+}
+/** 排序键（模块级：不把回调决策点算回 listSessions）。 */
+function kimiRowMtime(s) {
+    return s.mtime;
+}
+function kimiRowId(s) {
+    return s.sessionId;
+}
 //# sourceMappingURL=sessions.js.map