lark-remote 0.5.13 → 0.5.15

package/dist/session/kimi/sessions.js

@@ -5,9 +5,9 @@ import { readJsonlLines as readJsonlLinesShared, readLastNJsonlLines } from '../
 import { UsageAccumulator, cumulativeUsageFields } from '../common/usage-accumulator.js';
 import { getLogger } from '../../logger/index.js';
 import { isStale } from '../common/constants.js';
-import { samePath } from '../../platform/path.js';
+import { safeRealpath, samePath } from '../../platform/path.js';
 import { capEvents, paginate } from '../common/pagination.js';
-import { sortByRecencyDesc } from '../common/recency.js';
+import { newestOf, sortByRecencyDesc } from '../common/recency.js';
 import { TtlCache } from '../../common/ttl-cache.js';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 import { truncateToolInput } from '../common/content-blocks.js';
@@ -88,7 +88,12 @@ function readJsonlLines(filePath) {
         jsonlCache.set(filePath, { mtime, lines });
         return lines;
     }
-    catch {
+    catch (err) {
+        // ENOENT = 会话文件在扫描间隙被清理（正常）；其余 errno 留痕，否则该会话
+        // 静默从 /resume 消失。
+        if (err.code !== 'ENOENT') {
+            getLogger().warn(`[kimi-session-reader] cannot read ${filePath}: ${err?.message ?? String(err)}`);
+        }
         return [];
     }
 }
@@ -201,7 +206,13 @@ export class KimiSessionReader {
      */
     listSessions(cwd, opts) {
         try {
-            const realCwd = fs.realpathSync(cwd);
+            // 归一失败（陈旧/无权限 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 sessions = [];
             for (const entry of this.scanSessionIndex()) {
                 // state.json 一次读取共用（cwd 兜底 + summary），I/O 减半。
@@ -258,7 +269,16 @@ export class KimiSessionReader {
                     mtimeMs = fs.statSync(wirePath).mtimeMs;
                 }
                 catch {
-                    mtimeMs = fs.statSync(entry.sessionDir).mtimeMs;
+                    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,
@@ -276,15 +296,22 @@ export class KimiSessionReader {
             };
         }
         catch (error) {
-            getLogger().error(`[kimi-session-reader] listSessions error: ${error}`);
-            return { sessions: [], total: 0 };
+            // ENOENT（cwd 已删除）：陈旧 cwd 保持优雅空态。
+            // 其余失败：error 日志 + 上抛，router 显示「列表失败」——静默 [] 会让
+            // 用户误以为没有 session，与真空不可区分（与 opencode 同口径）。
+            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 });
         }
     }
     /**
      * Get the newest session for a given working directory
      */
     getNewestSession(cwd) {
-        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+        return newestOf(this, cwd);
     }
     /**
      * Read session content (events + usage)
@@ -320,7 +347,15 @@ export class KimiSessionReader {
             // 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).
-            const accumulateUsage = (u, updateContextLength) => {
+            //
+            // 本 run 的 flow 字段是**末个 turn**（最后一个 turn.prompt 之后）的记录之和：
+            // kimi 每次模型调用写一条 usage.record，带工具往返的 turn 会有多条。只取
+            // 末条会低报，取会话总量（旧实现）又会把历史所有 run 的消耗算进这一轮。
+            // 子 agent 的 wire 没有 turn 标记，只能进会话累计（无法归属到某一轮）；
+            // 整份 wire 都没有 turn.prompt（旧数据）时沿用「整份文件 = 一个 turn」。
+            let turnAcc = null;
+            let lastMainUsage;
+            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.
@@ -328,18 +363,21 @@ export class KimiSessionReader {
                 const output = u?.output ?? 0;
                 const inputCacheRead = u?.inputCacheRead ?? 0;
                 const inputCacheCreation = u?.inputCacheCreation ?? 0;
-                acc.add({
+                const record = {
                     input: inputOther,
                     output,
                     cacheRead: inputCacheRead,
                     cacheCreation: inputCacheCreation,
-                });
-                if (updateContextLength) {
-                    // unified contract (§9.21): input + output + cacheRead + cacheCreation.
-                    // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
-                    // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
-                    mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
-                }
+                };
+                acc.add(record);
+                if (scope !== 'main')
+                    return;
+                lastMainUsage = record;
+                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];
@@ -347,7 +385,7 @@ export class KimiSessionReader {
                     const entry = JSON.parse(line);
                     // Extract usage from usage.record.
                     if (isUsageRecord(entry)) {
-                        accumulateUsage(entry.usage, true);
+                        accumulateUsage(entry.usage, 'main');
                         continue;
                     }
                     // §6.3: Count compaction events and track pre-compact context length.
@@ -374,6 +412,8 @@ export class KimiSessionReader {
                     // 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;
                         }
@@ -443,7 +483,7 @@ export class KimiSessionReader {
                         try {
                             const subEntry = JSON.parse(subLine);
                             if (isUsageRecord(subEntry)) {
-                                accumulateUsage(subEntry.usage, false);
+                                accumulateUsage(subEntry.usage, 'subagent');
                             }
                         }
                         catch {
@@ -455,18 +495,23 @@ export class KimiSessionReader {
             catch {
                 // agents dir unreadable — fall back to main-only usage
             }
-            // Build the final AgentSessionUsage from accumulator totals + main contextLength.
+            // Build the final AgentSessionUsage from the last turn's flow + session
+            // cumulative + main contextLength.
             const t = acc.totals;
+            // 有 turn.prompt 时本 run = 末个 turn 的 flow（末 turn 还没有记录时退回
+            // 末条主 wire 记录）；整份 wire 都没有 turn.prompt（旧数据/截断）时无从
+            // 分段，沿用「整份文件 = 一个 turn」的旧口径（含子 agent wire）。
+            const flow = turnAcc ? (turnAcc.count > 0 ? turnAcc.totals : (lastMainUsage ?? t)) : t;
             // Kimi semantics: preserve 0 values (not undefined) for cache fields to match original
             const totalUsage = {
-                inputTokens: t.input,
-                outputTokens: t.output,
+                inputTokens: flow.input,
+                outputTokens: flow.output,
                 contextLength: mainContextLength,
-                cacheReadTokens: t.cacheRead > 0 ? t.cacheRead : 0,
-                cacheCreationTokens: t.cacheCreation > 0 ? t.cacheCreation : 0,
-                totalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
-                // Cumulative (session-wide): kimi sums all usage.records; mirrors
-                // inputTokens/outputTokens which are already session totals.
+                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,

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

@@ -15,7 +15,7 @@
  * - isSessionActive: use `updated` timestamp with 1 hour stale window.
  * - Simple memory cache with TTL.
  */
-import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+import type { AgentSession, AgentSessionReader, SessionContent } from '../../session-contract.js';
 interface OpencodeSessionReaderOptions {
     /** Path to the opencode binary. Defaults to `opencode`. */
     binary?: string;

package/dist/session/opencode/sessions.js

@@ -22,9 +22,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 import { isStale } from '../common/constants.js';
-import { samePath } from '../../platform/path.js';
+import { safeRealpath, samePath } from '../../platform/path.js';
 import { paginate, capEvents } from '../common/pagination.js';
-import { sortByRecencyDesc } from '../common/recency.js';
+import { newestOf, sortByRecencyDesc } from '../common/recency.js';
 import { TtlCache } from '../../common/ttl-cache.js';
 import { getLogger } from '../../logger/index.js';
 /** v2 CLI defaults `session list` to 100 entries; keep the reader's historical
@@ -81,6 +81,84 @@ function v2ToolOutput(state) {
         return state.result;
     return undefined;
 }
+/**
+ * v2 assistant 消息 → 用量采样。total 为 0 的退化消息（模型在 reasoning 中被
+ * 截断）不算采样：信任它会抹掉整轮真实用量。
+ */
+function usageSample(msg) {
+    if (msg?.type !== 'assistant' || !msg.tokens)
+        return undefined;
+    const input = msg.tokens.input ?? 0;
+    const output = msg.tokens.output ?? 0;
+    const cacheRead = msg.tokens.cache?.read ?? 0;
+    const cacheCreation = msg.tokens.cache?.write ?? 0;
+    const total = input + output + (msg.tokens.reasoning ?? 0) + cacheRead + cacheCreation;
+    if (total === 0)
+        return undefined;
+    return { input, output, cacheRead, cacheCreation, total };
+}
+/**
+ * 末个 turn 的起点（其后才是"本 run"的采样）。
+ *
+ * `idle` 是 opencode 自带的 turn 结束标记（真实 export 里每个 idle 前一条是
+ * assistant、后一条是 user/synthetic/system）。取「最后一个其后仍有采样的 idle」：
+ * - 文件以 idle 收尾（/resume 常态）时，末个 idle 之后没有采样，边界自动落到
+ *   再上一个 idle，即最后那个完整 turn；
+ * - 文件停在 turn 中间（run 收尾读盘）时，末个 idle 就是当前 turn 的起点。
+ *
+ * 老数据没有 idle：退回最后一个 turn 起跑标记（user/synthetic/system），与
+ * codex/dsh「无 turn 标记则退回末条采样」的既有兜底一致。
+ */
+function lastTurnStartIndex(messages) {
+    let lastSample = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (usageSample(messages[i]) !== undefined) {
+            lastSample = i;
+            break;
+        }
+    }
+    if (lastSample < 0)
+        return -1;
+    for (let i = lastSample - 1; i >= 0; i--) {
+        if (messages[i]?.type === 'idle')
+            return i;
+    }
+    for (let i = lastSample - 1; i >= 0; i--) {
+        const type = messages[i]?.type;
+        if (type === 'user' || type === 'synthetic' || type === 'system')
+            return i;
+    }
+    return -1;
+}
+/**
+ * 把会话级累计 token 落到 usage 上（v1 export 与 v2 export 两条读取路径共用）。
+ *
+ * 已有 usage 就地补累计字段；没有 usage 但累计非零（例如只有 cache 计数）时，
+ * 构造一条只带累计的，避免"会话有消耗却显示无 usage"。
+ */
+function withCumulativeUsage(usage, cum) {
+    if (usage) {
+        usage.cumulativeTotalTokens = cum.total;
+        usage.cumulativeInputTokens = cum.input;
+        usage.cumulativeOutputTokens = cum.output;
+        usage.cumulativeCacheReadTokens = cum.cacheRead;
+        usage.cumulativeCacheCreationTokens = cum.cacheWrite;
+        return usage;
+    }
+    if (!(cum.input || cum.output || cum.total || cum.cacheRead || cum.cacheWrite)) {
+        return undefined;
+    }
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        contextLength: 0,
+        cumulativeTotalTokens: cum.total,
+        cumulativeInputTokens: cum.input,
+        cumulativeOutputTokens: cum.output,
+        cumulativeCacheReadTokens: cum.cacheRead,
+        cumulativeCacheCreationTokens: cum.cacheWrite,
+    };
+}
 export class OpencodeSessionReader {
     binary;
     cacheTtlMs;
@@ -124,7 +202,7 @@ export class OpencodeSessionReader {
      * Get the newest session in a given cwd.
      */
     getNewestSession(cwd) {
-        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+        return newestOf(this, cwd);
     }
     /**
      * Read session content: extract catch-up tail (last user message + everything after).
@@ -167,6 +245,8 @@ export class OpencodeSessionReader {
             }
             const events = [];
             let usage;
+            /** 本 turn 的 flow 累计：末条 user 消息之后的全部 step-finish。 */
+            let turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
             let aiTitle;
             let displayTitle;
             // Find the last user message position (for catch-up tail).
@@ -233,28 +313,34 @@ export class OpencodeSessionReader {
                         }
                     }
                 }
-                // Track usage from step-finish parts
+                // Track usage from step-finish parts. v1 没有 idle 标记，turn 边界就是
+                // 上面那段"最后一条 user 消息"；同一 turn 可能有多个 step-finish
+                // （每次模型请求一条），flow 要全加起来，只留末条会把多步 run 低报。
                 for (const part of msg.parts) {
                     if (part.type === 'step-finish' && part.tokens) {
-                        // Use the last NON-EMPTY step-finish tokens. A long autonomous run
-                        // can end on a degenerate step (model cut off mid-reasoning) whose
-                        // step-finish reports all-zero tokens; trusting it would wipe out
-                        // the run's real per-turn usage (contextLength/input/output/total
-                        // all render 0). Skip zero-total steps so per-turn usage reflects
-                        // the last step that actually consumed tokens.
+                        // Skip zero-total steps（模型在 reasoning 中被截断）——它们没有消耗，
+                        // 也不该把本次请求当成一条真实采样。
                         // ccusage-aligned: cache.write -> cacheCreationTokens.
                         // contextLength = input + output + cacheRead + cacheCreation —
                         // the unified context-window occupancy contract across all readers
                         // (§9.21：末轮 output 已进入历史、下一 prompt 全量携带，与 compact
                         // postTokens 水位同语义).
                         if ((part.tokens.total ?? 0) !== 0) {
+                            const input = part.tokens.input ?? 0;
+                            const output = part.tokens.output ?? 0;
+                            const cacheRead = part.tokens.cache?.read ?? 0;
+                            const cacheWrite = part.tokens.cache?.write ?? 0;
+                            turn = {
+                                input: turn.input + input,
+                                output: turn.output + output,
+                                cacheRead: turn.cacheRead + cacheRead,
+                                cacheCreation: turn.cacheCreation + cacheWrite,
+                                total: turn.total + part.tokens.total,
+                            };
                             usage = {
-                                inputTokens: part.tokens.input,
-                                outputTokens: part.tokens.output,
-                                contextLength: (part.tokens.input ?? 0) +
-                                    (part.tokens.output ?? 0) +
-                                    (part.tokens.cache?.read ?? 0) +
-                                    (part.tokens.cache?.write ?? 0),
+                                inputTokens: input,
+                                outputTokens: output,
+                                contextLength: input + output + cacheRead + cacheWrite,
                                 cacheReadTokens: part.tokens.cache?.read,
                                 cacheCreationTokens: part.tokens.cache?.write,
                                 totalTokens: part.tokens.total,
@@ -263,6 +349,14 @@ export class OpencodeSessionReader {
                     }
                 }
             }
+            // flow 覆盖末条采样值，contextLength 保留末条（水位不求和）。
+            if (usage) {
+                usage.inputTokens = turn.input;
+                usage.outputTokens = turn.output;
+                usage.cacheReadTokens = turn.cacheRead;
+                usage.cacheCreationTokens = turn.cacheCreation;
+                usage.totalTokens = turn.total;
+            }
             // Cumulative (session-wide): sum input/output/total across ALL step-finish
             // parts in the whole session. The catch-up loop above only scans from
             // the last user message (= last run) for per-turn usage; cumulative
@@ -283,25 +377,13 @@ export class OpencodeSessionReader {
                     }
                 }
             }
-            if (usage) {
-                usage.cumulativeTotalTokens = cumTotal;
-                usage.cumulativeInputTokens = cumInput;
-                usage.cumulativeOutputTokens = cumOutput;
-                usage.cumulativeCacheReadTokens = cumCacheRead;
-                usage.cumulativeCacheCreationTokens = cumCacheWrite;
-            }
-            else if (cumInput || cumOutput || cumTotal || cumCacheRead || cumCacheWrite) {
-                usage = {
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    contextLength: 0,
-                    cumulativeTotalTokens: cumTotal,
-                    cumulativeInputTokens: cumInput,
-                    cumulativeOutputTokens: cumOutput,
-                    cumulativeCacheReadTokens: cumCacheRead,
-                    cumulativeCacheCreationTokens: cumCacheWrite,
-                };
-            }
+            usage = withCumulativeUsage(usage, {
+                total: cumTotal,
+                input: cumInput,
+                output: cumOutput,
+                cacheRead: cumCacheRead,
+                cacheWrite: cumCacheWrite,
+            });
             // Use info.title as aiTitle
             if (data.info.title) {
                 aiTitle = data.info.title;
@@ -444,51 +526,53 @@ export class OpencodeSessionReader {
         let cumTotal = 0;
         let cumCacheRead = 0;
         let cumCacheWrite = 0;
-        for (const msg of messages) {
-            if (msg?.type !== 'assistant' || !msg.tokens)
+        // 本 turn（= 本 run）的 flow：末个 turn 内每次模型请求之和。contextLength
+        // 仍取末次请求的窗口水位（水位不可求和）。只取末条会把多步 run 低报
+        // （实测一条 25 请求的 run：input 20,040 显示成 543、output 10,358 显示成 1,250）。
+        const turnStart = lastTurnStartIndex(messages);
+        const turn = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
+        for (let i = 0; i < messages.length; i++) {
+            const sample = usageSample(messages[i]);
+            if (!sample)
                 continue;
-            const tokens = msg.tokens;
-            const cacheRead = tokens.cache?.read ?? 0;
-            const cacheWrite = tokens.cache?.write ?? 0;
-            const total = tokens.input + tokens.output + tokens.reasoning + cacheRead + cacheWrite;
-            cumInput += tokens.input;
-            cumOutput += tokens.output;
-            cumTotal += total;
-            cumCacheRead += cacheRead;
-            cumCacheWrite += cacheWrite;
-            // A long autonomous run can end on a degenerate assistant message with
-            // zero tokens; skip it so the card reflects the last real step.
-            if (total !== 0) {
-                latest = {
-                    inputTokens: tokens.input,
-                    outputTokens: tokens.output,
-                    // §9.21 口径：含末轮 output（与 postTokens 水位同语义）。
-                    contextLength: tokens.input + tokens.output + cacheRead + cacheWrite,
-                    cacheReadTokens: cacheRead,
-                    cacheCreationTokens: cacheWrite,
-                    totalTokens: total,
-                };
+            cumInput += sample.input;
+            cumOutput += sample.output;
+            cumTotal += sample.total;
+            cumCacheRead += sample.cacheRead;
+            cumCacheWrite += sample.cacheCreation;
+            if (i > turnStart) {
+                turn.input += sample.input;
+                turn.output += sample.output;
+                turn.cacheRead += sample.cacheRead;
+                turn.cacheCreation += sample.cacheCreation;
+                turn.total += sample.total;
             }
-        }
-        if (latest) {
-            latest.cumulativeTotalTokens = cumTotal;
-            latest.cumulativeInputTokens = cumInput;
-            latest.cumulativeOutputTokens = cumOutput;
-            latest.cumulativeCacheReadTokens = cumCacheRead;
-            latest.cumulativeCacheCreationTokens = cumCacheWrite;
-        }
-        else if (cumInput || cumOutput || cumTotal || cumCacheRead || cumCacheWrite) {
             latest = {
-                inputTokens: 0,
-                outputTokens: 0,
-                contextLength: 0,
-                cumulativeTotalTokens: cumTotal,
-                cumulativeInputTokens: cumInput,
-                cumulativeOutputTokens: cumOutput,
-                cumulativeCacheReadTokens: cumCacheRead,
-                cumulativeCacheCreationTokens: cumCacheWrite,
+                inputTokens: sample.input,
+                outputTokens: sample.output,
+                // §9.21 口径：含末轮 output（与 postTokens 水位同语义）。
+                contextLength: sample.input + sample.output + sample.cacheRead + sample.cacheCreation,
+                cacheReadTokens: sample.cacheRead,
+                cacheCreationTokens: sample.cacheCreation,
+                totalTokens: sample.total,
             };
         }
+        // turnStart 严格小于最后一个采样下标，所以 latest 存在时 turn 至少含一条
+        // 采样：flow 覆盖末条值，只有 contextLength 保留末条。
+        if (latest) {
+            latest.inputTokens = turn.input;
+            latest.outputTokens = turn.output;
+            latest.cacheReadTokens = turn.cacheRead;
+            latest.cacheCreationTokens = turn.cacheCreation;
+            latest.totalTokens = turn.total;
+        }
+        latest = withCumulativeUsage(latest, {
+            total: cumTotal,
+            input: cumInput,
+            output: cumOutput,
+            cacheRead: cumCacheRead,
+            cacheWrite: cumCacheWrite,
+        });
         return {
             events: capEvents(events, opts?.maxEvents),
             usage: latest,
@@ -518,12 +602,11 @@ export class OpencodeSessionReader {
     // --- Private helpers ---
     /** realpath 归一化（public：测试直接调用，替代 as unknown as）。 */
     realpath(cwd) {
-        try {
-            return fs.realpathSync(cwd);
-        }
-        catch {
-            return cwd;
-        }
+        return safeRealpath(cwd, (err) => {
+            if (err.code === 'ENOENT')
+                return;
+            getLogger().debug(`[opencode-session-reader] realpath ${cwd} failed, using the path as given: ${err?.message ?? String(err)}`);
+        });
     }
     fetchSessionList(cwd) {
         const realCwd = this.realpath(cwd);

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

@@ -1,5 +1,5 @@
 import { type ContentBlockMapping } from '../common/content-blocks.js';
-import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+import type { AgentSession, AgentSessionReader, SessionContent } from '../../session-contract.js';
 /** Pi-specific field-name mapping for content block extraction. */
 export declare const PI_MAPPING: ContentBlockMapping;
 /**

package/dist/session/pi/sessions.js

@@ -8,7 +8,7 @@ import { UsageAccumulator, contextWindowOccupancy, cumulativeUsageFields, } from
 import { isStale } from '../common/constants.js';
 import { encodeProjectDirName, samePath } from '../../platform/path.js';
 import { paginate } from '../common/pagination.js';
-import { sortByRecencyDesc } from '../common/recency.js';
+import { newestOf, sortByRecencyDesc } from '../common/recency.js';
 import { TtlCache } from '../../common/ttl-cache.js';
 import { getLogger } from '../../logger/index.js';
 function defaultPiDir() {
@@ -135,8 +135,11 @@ function findSessionFile(sessionId, cwd, sessionsDir) {
             }
         }
     }
-    catch {
-        // dir doesn't exist
+    catch (err) {
+        // dir 不存在（陈旧 cwd / 该 cwd 从没有会话）是正常空态；其余留痕。
+        if (err.code !== 'ENOENT') {
+            getLogger().debug(`[pi-session-reader] cannot read ${dir}: ${err?.message ?? String(err)}`);
+        }
     }
     return null;
 }
@@ -282,7 +285,7 @@ export class PiSessionReader {
         };
     }
     getNewestSession(cwd) {
-        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+        return newestOf(this, cwd);
     }
     readSessionContent(sessionId, cwd, opts) {
         let filePath = null;
@@ -319,7 +322,10 @@ export class PiSessionReader {
             const st = fs.statSync(filePath);
             return !isStale(st.mtimeMs);
         }
-        catch {
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                getLogger().debug(`[pi-session-reader] stat ${filePath} failed: ${err?.message ?? String(err)}`);
+            }
             return false;
         }
     }
@@ -335,8 +341,15 @@ export class PiSessionReader {
         try {
             files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
         }
-        catch {
-            return [];
+        catch (err) {
+            // ENOENT：该 cwd 还没有会话目录（正常空态）。其余失败上抛，由 router
+            // 显示「列表失败」——静默 [] 与真空不可区分（与 opencode 同口径）。
+            if (err.code === 'ENOENT') {
+                return [];
+            }
+            getLogger().error(`[pi-session-reader] listSessions failed: ${err}`);
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`pi session list 读取失败: ${msg}`, { cause: err });
         }
         const sessions = [];
         for (const f of files) {

package/dist/session/registry.d.ts

@@ -1,4 +1,5 @@
-import type { AgentKind, AgentSessionReader } from '../runner/index.js';
+import type { AgentKind } from '../agent-kinds.js';
+import type { AgentSessionReader } from '../session-contract.js';
 /**
  * Registry of `AgentSessionReader` instances, keyed by `AgentKind`. Mirrors
  * `AgentRegistry` but for session-history reads. `index.ts` registers one

package/dist/session/session-store.d.ts

@@ -1,4 +1,4 @@
-import type { AgentKind } from '../runner/index.js';
+import type { AgentKind } from '../agent-kinds.js';
 interface SessionEntry {
     /** Session IDs per agent kind (Map for in-memory, plain object for persistence). */
     sessions: Map<AgentKind, string>;
@@ -58,7 +58,6 @@ export declare class SessionStore {
      */
     private mutateEntry;
     get(userId: string): SessionEntry | undefined;
-    set(userId: string, entry: SessionEntry): void;
     delete(userId: string): void;
     /** Clear sessionId for a specific agent, keeping cwd and other agent sessions */
     clearSessionId(userId: string, agent?: AgentKind, opts?: {

package/dist/session/session-store.js

@@ -85,10 +85,6 @@ export class SessionStore {
     get(userId) {
         return this.sessions.get(userId);
     }
-    set(userId, entry) {
-        this.sessions.set(userId, entry);
-        this.autoPersist();
-    }
     delete(userId) {
         this.sessions.delete(userId);
         this.autoPersist();
@@ -170,7 +166,7 @@ export class SessionStore {
     /** Get sessionId for a specific agent, or undefined if no session or sessionId is empty */
     getSessionId(userId, agent = 'claude') {
         const entry = this.sessions.get(userId);
-        if (!entry || !entry.sessions)
+        if (!entry)
             return undefined;
         const sessionId = entry.sessions.get(agent);
         if (!sessionId)
@@ -284,8 +280,19 @@ export class SessionStore {
                 }
             }
         }
-        catch {
-            getLogger().warn('[session] persisted session store corrupted, ignoring');
+        catch (err) {
+            getLogger().warn(`[session] persisted session store corrupted (${this.persistPath ?? '(memory)'}), ignoring:`, err);
+            // 改名保留现场：原文件继续原地躺着会让下次启动重复告警，也丢掉排障证据。
+            if (this.persistPath) {
+                const brokenPath = `${this.persistPath}.corrupt-${Date.now()}`;
+                try {
+                    fs.renameSync(this.persistPath, brokenPath);
+                    getLogger().warn(`[session] moved corrupt store to ${brokenPath}`);
+                }
+                catch (renameErr) {
+                    getLogger().warn('[session] failed to preserve corrupt store:', renameErr);
+                }
+            }
         }
     }
     autoPersist() {