lark-remote 0.5.20 → 0.5.21

package/dist/session/kimi/sessions.js

@@ -5,6 +5,7 @@ import { readJsonlLines as readJsonlLinesShared, readLastNJsonlLines } from '../
 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';
@@ -396,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
      */
@@ -436,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,
@@ -761,4 +658,127 @@ export class KimiSessionReader {
         }
     }
 }
+// --- 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

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

@@ -139,17 +139,6 @@ export interface OpencodeV1Scan {
     /** 全会话 step-finish 求和（cumulative；零 total 的退化 step 字段照加）。 */
     cum: OpencodeUsageFlow;
 }
-/**
- * v1 扫描累积器（纯函数）：单遍扫过全部 export 消息，产出 catch-up tail 的
- * 位置（末条 user 消息）、本 run flow（tail 内非零 step-finish 求和）、末条
- * 非零采样（contextLength 水位）与全会话累计。
- *
- * 产生：OpencodeV1Scan。依赖：入参 messages。不改任何外部状态。
- *
- * 口径（勿改）：cumulative 对**所有** step-finish 逐字段求和、不设零 total
- * 门槛；turn/latest 只认 tail 内非零 total 的 step（模型在 reasoning 中被
- * 截断的退化 step 不算采样）。
- */
 export declare function scanV1Messages(messages: OpencodeExportMessage[]): OpencodeV1Scan;
 /** v2 usage 扫描累积器结果（纯数据）。 */
 export interface OpencodeV2UsageScan {

package/dist/session/opencode/sessions.js

@@ -169,26 +169,77 @@ function withCumulativeUsage(usage, cum) {
 function emptyFlow() {
     return { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
 }
-/**
- * v1 扫描累积器（纯函数）：单遍扫过全部 export 消息，产出 catch-up tail 的
- * 位置（末条 user 消息）、本 run flow（tail 内非零 step-finish 求和）、末条
- * 非零采样（contextLength 水位）与全会话累计。
- *
- * 产生：OpencodeV1Scan。依赖：入参 messages。不改任何外部状态。
- *
- * 口径（勿改）：cumulative 对**所有** step-finish 逐字段求和、不设零 total
- * 门槛；turn/latest 只认 tail 内非零 total 的 step（模型在 reasoning 中被
- * 截断的退化 step 不算采样）。
- */
-export function scanV1Messages(messages) {
-    // Find the last user message position (for catch-up tail).
-    // messages are already parsed objects — scan directly.
+/** 末条 user 消息下标（catch-up tail 起点）；无 user 消息 = -1。 */
+function lastV1UserIndex(messages) {
     let lastUserIndex = -1;
     for (let i = 0; i < messages.length; i++) {
         if (messages[i].info.role === 'user') {
             lastUserIndex = i;
         }
     }
+    return lastUserIndex;
+}
+/** cumulative：全会话逐字段求和，含零 total 的退化 step（字段 0 不改变和）。 */
+function addV1Cumulative(tokens, cum) {
+    cum.input += tokens.input ?? 0;
+    cum.output += tokens.output ?? 0;
+    cum.total += tokens.total ?? 0;
+    cum.cacheRead += tokens.cache?.read ?? 0;
+    cum.cacheCreation += tokens.cache?.write ?? 0;
+}
+/** 单次非零采样：累加本 run flow 并返回 latest 快照。 */
+function addV1TurnSample(tokens, turn) {
+    // 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 水位同语义).
+    const input = tokens.input ?? 0;
+    const output = tokens.output ?? 0;
+    const cacheRead = tokens.cache?.read ?? 0;
+    const cacheWrite = tokens.cache?.write ?? 0;
+    turn.input += input;
+    turn.output += output;
+    turn.cacheRead += cacheRead;
+    turn.cacheCreation += cacheWrite;
+    turn.total += tokens.total;
+    return {
+        inputTokens: input,
+        outputTokens: output,
+        contextLength: input + output + cacheRead + cacheWrite,
+        cacheReadTokens: tokens.cache?.read,
+        cacheCreationTokens: tokens.cache?.write,
+        totalTokens: tokens.total,
+    };
+}
+/**
+ * 单条 step-finish part：cum 对全会话逐字段求和（含零 total 退化 step），
+ * inTail 且非零 total 时把本 run flow 累加到 turn 并返回新的 latest 采样。
+ */
+function accumulateV1StepPart(part, inTail, turn, cum) {
+    if (part.type !== 'step-finish' || !part.tokens)
+        return undefined;
+    addV1Cumulative(part.tokens, cum);
+    if (!inTail)
+        return undefined;
+    // Skip zero-total steps（模型在 reasoning 中被截断）——它们没有消耗，
+    // 也不该把本次请求当成一条真实采样。
+    if ((part.tokens.total ?? 0) === 0)
+        return undefined;
+    return addV1TurnSample(part.tokens, turn);
+}
+/** 一条 user 消息里的首个 text part（tail displayTitle 首选）。 */
+function firstV1TextPart(parts) {
+    for (const part of parts) {
+        if (part.type === 'text' && part.text)
+            return part.text;
+    }
+    return undefined;
+}
+export function scanV1Messages(messages) {
+    // Find the last user message position (for catch-up tail).
+    // messages are already parsed objects — scan directly.
+    const lastUserIndex = lastV1UserIndex(messages);
     // Process messages from last user message onwards (catch-up tail)
     const startIndex = lastUserIndex >= 0 ? lastUserIndex : 0;
     const turn = emptyFlow();
@@ -202,52 +253,13 @@ export function scanV1Messages(messages) {
         // 末条 user 消息；同一 turn 可能有多个 step-finish（每次模型请求一条），
         // flow 要全加起来，只留末条会把多步 run 低报。
         for (const part of msg.parts) {
-            if (part.type === 'step-finish' && part.tokens) {
-                // cumulative：全会话求和，含零 total 的退化 step（字段为 0 时求和不
-                // 变，与拆分前行为一致）。
-                cum.input += part.tokens.input ?? 0;
-                cum.output += part.tokens.output ?? 0;
-                cum.total += part.tokens.total ?? 0;
-                cum.cacheRead += part.tokens.cache?.read ?? 0;
-                cum.cacheCreation += part.tokens.cache?.write ?? 0;
-                if (!inTail)
-                    continue;
-                // 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)
-                    continue;
-                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 += input;
-                turn.output += output;
-                turn.cacheRead += cacheRead;
-                turn.cacheCreation += cacheWrite;
-                turn.total += part.tokens.total;
-                latest = {
-                    inputTokens: input,
-                    outputTokens: output,
-                    contextLength: input + output + cacheRead + cacheWrite,
-                    cacheReadTokens: part.tokens.cache?.read,
-                    cacheCreationTokens: part.tokens.cache?.write,
-                    totalTokens: part.tokens.total,
-                };
-            }
+            const stepLatest = accumulateV1StepPart(part, inTail, turn, cum);
+            if (stepLatest)
+                latest = stepLatest;
         }
         // First user text after last user message is displayTitle
         if (inTail && !tailDisplayTitle && msg.info.role === 'user') {
-            for (const part of msg.parts) {
-                if (part.type === 'text' && part.text) {
-                    tailDisplayTitle = part.text;
-                    break;
-                }
-            }
+            tailDisplayTitle = firstV1TextPart(msg.parts);
         }
     }
     return { lastUserIndex, tailDisplayTitle, latest, turn, cum };
@@ -387,14 +399,95 @@ export function scanV2Usage(messages) {
     }
     return { latest, turn, cum };
 }
+function v2UserHandler(msg, timestamp, state) {
+    if (typeof msg.text === 'string' && msg.text.length > 0) {
+        if (!state.displayTitle)
+            state.displayTitle = msg.text;
+        state.events.push({ type: 'text', content: msg.text, timestamp });
+    }
+}
+function pushV2ToolPart(part, timestamp, state) {
+    const toolId = part.id;
+    const toolName = part.name ?? '';
+    const input = parseToolInput(part.state?.input);
+    if (toolId) {
+        state.events.push({
+            type: 'tool_use',
+            content: JSON.stringify({ id: toolId, name: toolName, input }),
+            timestamp,
+        });
+    }
+    const output = v2ToolOutput(part.state);
+    if (toolId && output !== undefined) {
+        state.events.push({
+            type: 'tool_result',
+            content: truncateUtf8(output, TOOL_RESULT_MAX_BYTES),
+            timestamp,
+        });
+    }
+}
+function v2AssistantHandler(msg, timestamp, state) {
+    for (const part of Array.isArray(msg.content) ? msg.content : []) {
+        if (part?.type === 'text' && typeof part.text === 'string') {
+            state.events.push({ type: 'text', content: part.text, timestamp });
+            continue;
+        }
+        if (part?.type === 'reasoning' && typeof part.text === 'string') {
+            state.events.push({ type: 'thinking', content: part.text, timestamp });
+            continue;
+        }
+        if (part?.type === 'tool')
+            pushV2ToolPart(part, timestamp, state);
+    }
+}
+/** User-invoked shell messages are a first-class message type in v2. */
+function v2ShellHandler(msg, timestamp, state) {
+    if (typeof msg.command !== 'string')
+        return;
+    state.events.push({
+        type: 'tool_use',
+        content: JSON.stringify({
+            id: msg.callID ?? msg.id ?? 'shell',
+            name: 'bash',
+            input: { command: msg.command },
+        }),
+        timestamp,
+    });
+    if (typeof msg.output === 'string') {
+        state.events.push({
+            type: 'tool_result',
+            content: truncateUtf8(msg.output, TOOL_RESULT_MAX_BYTES),
+            timestamp,
+        });
+    }
+}
+/** 只保留 compact summary；system/synthetic/切换类控制消息是噪声。 */
+function v2CompactionHandler(msg, timestamp, state) {
+    if (typeof msg.summary === 'string' && msg.summary) {
+        state.events.push({ type: 'text', content: msg.summary, timestamp });
+    }
+}
 /**
- * v2 catch-up tail 装配（纯函数）：末条 user 消息起的消息映射为展示事件
- * （user / assistant / shell / compaction）；displayTitle 取 tail 内首条
- * user 文本，tail 无 user 文本（如附件-only）时回退全会话首条。
+ * 消息类型 → 命名 handler。用 Map 而非对象字面量 / 长串 if：
+ * `constructor` / `toString` 这类外来 type 会命中 Object.prototype。
  */
+const V2_TAIL_HANDLERS = new Map([
+    ['user', v2UserHandler],
+    ['assistant', v2AssistantHandler],
+    ['shell', v2ShellHandler],
+    ['compaction', v2CompactionHandler],
+]);
+/** 全会话首条 user 文本（tail 无 user 文本时的 displayTitle 兜底）。 */
+function firstV2UserText(messages) {
+    for (const msg of messages) {
+        if (msg?.type === 'user' && typeof msg.text === 'string' && msg.text.length > 0) {
+            return msg.text;
+        }
+    }
+    return undefined;
+}
 function assembleV2TailEvents(messages) {
-    const events = [];
-    let displayTitle;
+    const state = { events: [] };
     let lastUserIndex = -1;
     for (let i = 0; i < messages.length; i++) {
         if (messages[i]?.type === 'user')
@@ -406,84 +499,15 @@ function assembleV2TailEvents(messages) {
         if (!msg || typeof msg.type !== 'string')
             continue;
         const timestamp = msg.time?.created ? new Date(msg.time.created).toISOString() : undefined;
-        if (msg.type === 'user') {
-            if (typeof msg.text === 'string' && msg.text.length > 0) {
-                if (!displayTitle)
-                    displayTitle = msg.text;
-                events.push({ type: 'text', content: msg.text, timestamp });
-            }
-            continue;
-        }
-        if (msg.type === 'assistant') {
-            for (const part of Array.isArray(msg.content) ? msg.content : []) {
-                if (part?.type === 'text' && typeof part.text === 'string') {
-                    events.push({ type: 'text', content: part.text, timestamp });
-                    continue;
-                }
-                if (part?.type === 'reasoning' && typeof part.text === 'string') {
-                    events.push({ type: 'thinking', content: part.text, timestamp });
-                    continue;
-                }
-                if (part?.type === 'tool') {
-                    const toolId = part.id;
-                    const toolName = part.name ?? '';
-                    const input = parseToolInput(part.state?.input);
-                    if (toolId) {
-                        events.push({
-                            type: 'tool_use',
-                            content: JSON.stringify({ id: toolId, name: toolName, input }),
-                            timestamp,
-                        });
-                    }
-                    const output = v2ToolOutput(part.state);
-                    if (toolId && output !== undefined) {
-                        events.push({
-                            type: 'tool_result',
-                            content: truncateUtf8(output, TOOL_RESULT_MAX_BYTES),
-                            timestamp,
-                        });
-                    }
-                }
-            }
-            continue;
-        }
-        // User-invoked shell messages are a first-class message type in v2.
-        if (msg.type === 'shell' && typeof msg.command === 'string') {
-            events.push({
-                type: 'tool_use',
-                content: JSON.stringify({
-                    id: msg.callID ?? msg.id ?? 'shell',
-                    name: 'bash',
-                    input: { command: msg.command },
-                }),
-                timestamp,
-            });
-            if (typeof msg.output === 'string') {
-                events.push({
-                    type: 'tool_result',
-                    content: truncateUtf8(msg.output, TOOL_RESULT_MAX_BYTES),
-                    timestamp,
-                });
-            }
-            continue;
-        }
-        // Keep the compact summary visible in the catch-up tail; other control
-        // messages (system/synthetic/agent-switched/model-switched) are noise.
-        if (msg.type === 'compaction' && typeof msg.summary === 'string' && msg.summary) {
-            events.push({ type: 'text', content: msg.summary, timestamp });
-        }
+        const handler = V2_TAIL_HANDLERS.get(msg.type);
+        if (handler)
+            handler(msg, timestamp, state);
     }
     // If the last user message had no text (e.g. attachment-only), fall back to
     // the first human text anywhere in the session for the card title.
-    if (!displayTitle) {
-        for (const msg of messages) {
-            if (msg?.type === 'user' && typeof msg.text === 'string' && msg.text.length > 0) {
-                displayTitle = msg.text;
-                break;
-            }
-        }
-    }
-    return { events, displayTitle };
+    if (!state.displayTitle)
+        state.displayTitle = firstV2UserText(messages);
+    return { events: state.events, displayTitle: state.displayTitle };
 }
 export class OpencodeSessionReader {
     binary;

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

@@ -1,4 +1,10 @@
 import type { AgentKind } from '../agent-kinds.js';
+/**
+ * session reader 共用的失败留痕（claude stat / kimi realpath）：ENOENT 是两次
+ * 查询之间的正常竞态，静默；其余 errno 必须 debug 留痕，否则「文件不可读」
+ * 会被误判成「会话不活跃」。文案由调用方按场景给出，逐字保持。
+ */
+export declare function logNonEnoentDebug(err: unknown, message: (errText: string) => string): void;
 interface SessionEntry {
     /** Session IDs per agent kind (Map for in-memory, plain object for persistence). */
     sessions: Map<AgentKind, string>;
@@ -73,6 +79,8 @@ export declare class SessionStore {
     getArrivalSessionId(userId: string, agent: AgentKind): string | undefined;
     /** Set the arrival baseline for a specific agent ('' explicitly clears the arrival baseline) */
     setArrivalSessionId(userId: string, agent: AgentKind, sessionId: string): void;
+    /** previous/arrival 两类 setter 共用的单一实现（合并完全重复块）。 */
+    private writeSessionId;
     /** Set cwd for a user, clearing all sessionIds (§9.1) */
     setCwd(userId: string, cwd: string): void;
     /** Get cwd for a user, or undefined if no session */