lark-remote 0.1.6 → 0.1.7

package/dist/session/kimi/sessions.js

@@ -5,11 +5,26 @@ import { readJsonlLines as readJsonlLinesShared, readLastNJsonlLines } from '../
 import { UsageAccumulator } from '../common/usage-accumulator.js';
 import { getLogger } from '../../logger/index.js';
 import { STALE_MS } from '../common/constants.js';
-import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../card/text-truncate.js';
+import { capEvents, paginate } from '../common/pagination.js';
+import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
+import { truncateToolInput } from '../common/content-blocks.js';
 /** Default Kimi config directory */
 function defaultKimiDir() {
     return path.join(os.homedir(), '.kimi-code');
 }
+/** union 含 catch-all 成员，普通 `===` 判窄不生效，用显式守卫收窄（替代 as unknown as）。 */
+function isAppendLoopEvent(entry) {
+    return entry.type === 'context.append_loop_event';
+}
+function isUsageRecord(entry) {
+    return entry.type === 'usage.record';
+}
+function isTurnPrompt(entry) {
+    return entry.type === 'turn.prompt';
+}
+function isCompactionComplete(entry) {
+    return entry.type === 'full_compaction.complete' || entry.type === 'context.apply_compaction';
+}
 /**
  * Max lines scanned backwards when looking for the last loop event.
  * Bounds the tail scan so huge wire files are not fully parsed.
@@ -28,11 +43,9 @@ function lastLoopEventIsStepEnd(lines) {
     for (let i = lines.length - 1, scanned = 0; i >= 0 && scanned < LOOP_EVENT_SCAN_LIMIT; i--, scanned++) {
         try {
             const entry = JSON.parse(lines[i]);
-            if (entry.type !== 'context.append_loop_event') {
+            if (!isAppendLoopEvent(entry))
                 continue;
-            }
-            const loopEvent = entry;
-            return loopEvent.event.type === 'step.end';
+            return entry.event.type === 'step.end';
         }
         catch {
             // Skip malformed lines and keep scanning backwards
@@ -174,10 +187,9 @@ export class KimiSessionReader {
             for (const line of lines) {
                 try {
                     const entry = JSON.parse(line);
-                    if (entry.type === 'turn.prompt') {
-                        const prompt = entry;
-                        if (prompt.input && prompt.input.length > 0) {
-                            lastPrompt = prompt.input[0].text;
+                    if (isTurnPrompt(entry)) {
+                        if (entry.input && entry.input.length > 0) {
+                            lastPrompt = entry.input[0].text;
                         }
                     }
                 }
@@ -253,20 +265,16 @@ export class KimiSessionReader {
                 }
                 sessions.push({
                     sessionId: entry.sessionId,
-                    summary: summary.substring(0, 200), // Truncate long titles
+                    summary,
                     mtime: mtimeMs,
                 });
             }
             // Sort by mtime descending; same-mtime ties use a deterministic
             // secondary key so ordering is stable across scans.
             sessions.sort((a, b) => b.mtime - a.mtime || a.sessionId.localeCompare(b.sessionId));
-            const total = sessions.length;
-            const offset = Math.max(0, opts?.offset ?? 0);
-            // Default limit 20, aligned with the other agent session readers
-            // (claude/codex/opencode/pi); no opts -> return up to 20 sessions.
-            const limit = opts?.limit ?? 20;
+            const { items, total } = paginate(sessions, opts ?? {});
             return {
-                sessions: sessions.slice(offset, offset + limit),
+                sessions: items,
                 total,
             };
         }
@@ -285,64 +293,8 @@ export class KimiSessionReader {
      * Read session content (events + usage)
      */
     readSessionContent(sessionId, cwd, opts) {
-        // Find session directory from index (also retrieve index entry for
-        // fallback cwd guard when state.json is missing or unparseable)
-        const indexEntry = this.findSessionIndexEntry(sessionId);
-        const sessionDir = indexEntry?.sessionDir ?? null;
-        if (!sessionDir) {
-            return { events: [] };
-        }
-        const statePath = path.join(sessionDir, 'state.json');
-        let realCwd;
-        try {
-            realCwd = fs.realpathSync(cwd);
-        }
-        catch {
-            getLogger().warn(`[kimi-session-reader] fs.realpathSync failed for cwd=${cwd} (session ${sessionId}), returning empty`);
-            return { events: [] };
-        }
-        let cwdGuardPassed = false;
-        try {
-            if (fs.existsSync(statePath)) {
-                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-                const guardResult = checkCwdGuard(state, realCwd);
-                if (guardResult === 'failed') {
-                    return { events: [] };
-                }
-                if (guardResult === 'unverifiable') {
-                    getLogger().warn(`[kimi-session-reader] state.json has no workDir/cwd field for session ${sessionId}, falling back to index workDir`);
-                    // Fall through to index-based guard below
-                }
-                else {
-                    // verified — state.json cwd matches
-                    cwdGuardPassed = true;
-                }
-            }
-        }
-        catch {
-            // state.json unparseable — fall through to index-based guard
-            getLogger().warn(`[kimi-session-reader] state.json parse failed for session ${sessionId}, falling back to index workDir`);
-        }
-        // Fallback: when state.json is missing, unparseable, or has no workDir/cwd,
-        // use the workDir from the session index entry as a secondary guard.
-        // This prevents /resume <id> from accessing a session belonging to a
-        // different workspace when state.json is unavailable.
-        if (!cwdGuardPassed) {
-            const indexWorkDir = indexEntry?.workDir;
-            if (indexWorkDir && indexWorkDir !== realCwd) {
-                return { events: [] };
-            }
-            // v2 sessions have empty index workDir (v1-only field) and may lack
-            // state.json cwd. When no cwd source can verify the session belongs to
-            // the requested workspace, fail-closed to prevent cross-workspace access
-            // (aligned with claude's fail-closed cwd guard).
-            if (!indexWorkDir) {
-                getLogger().warn(`[kimi-session-reader] no cwd source (state.json + index) for session ${sessionId}, rejecting (fail-closed)`);
-                return { events: [] };
-            }
-        }
-        const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
-        if (!fs.existsSync(wirePath)) {
+        const wirePath = this.resolveSessionWirePath(sessionId, cwd);
+        if (wirePath === null) {
             return { events: [] };
         }
         try {
@@ -355,6 +307,9 @@ export class KimiSessionReader {
             // (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
@@ -393,9 +348,22 @@ export class KimiSessionReader {
                 try {
                     const entry = JSON.parse(line);
                     // Extract usage from usage.record.
-                    if (entry.type === 'usage.record') {
-                        const usageEntry = entry;
-                        accumulateUsage(usageEntry.usage, true);
+                    if (isUsageRecord(entry)) {
+                        accumulateUsage(entry.usage, true);
+                        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
+                    // 仅作 R2 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;
                     }
                     // P2-7: displayTitle + display events now scan ALL lines (not a
@@ -407,17 +375,15 @@ export class KimiSessionReader {
                     // 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 (entry.type === 'turn.prompt') {
-                        const prompt = entry;
-                        if (prompt.input && prompt.input.length > 0) {
-                            displayTitle = prompt.input[0].text.substring(0, 100);
+                    if (isTurnPrompt(entry)) {
+                        if (entry.input && entry.input.length > 0) {
+                            displayTitle = entry.input[0].text;
                         }
                         continue;
                     }
                     // Convert loop events to content events
-                    if (entry.type === 'context.append_loop_event') {
-                        const loopEvent = entry;
-                        const evt = loopEvent.event;
+                    if (isAppendLoopEvent(entry)) {
+                        const evt = entry.event;
                         if (evt.type === 'content.part' && evt.part) {
                             if (evt.part.type === 'think') {
                                 // Skip thinking blocks for display
@@ -431,13 +397,10 @@ export class KimiSessionReader {
                             }
                         }
                         else if (evt.type === 'tool.call' && evt.name) {
-                            // 对齐 claude content-blocks 的 200 字符截断：大 args（整段
-                            // 文件内容写入、长 prompt）原文进事件会把 resume 卡顶到
-                            // 28KB 预算之外（2026-08-08 extreme_fallback 故障的推手之一）。
-                            let inputStr = JSON.stringify(evt.args ?? {});
-                            if (inputStr.length > 200) {
-                                inputStr = inputStr.replace(/\n/g, ' ').slice(0, 197) + '...';
-                            }
+                            // 复用 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})`,
@@ -466,7 +429,9 @@ export class KimiSessionReader {
             // contextLength stays main-only (subagent context is an independent
             // window). Display events/title also stay main-only. Any unreadable
             // directory or missing/corrupt wire file is skipped silently.
-            const agentsDir = path.join(sessionDir, 'agents');
+            // 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') {
@@ -479,9 +444,8 @@ export class KimiSessionReader {
                     for (const subLine of readJsonlLines(subWirePath)) {
                         try {
                             const subEntry = JSON.parse(subLine);
-                            if (subEntry.type === 'usage.record') {
-                                const usageEntry = subEntry;
-                                accumulateUsage(usageEntry.usage, false);
+                            if (isUsageRecord(subEntry)) {
+                                accumulateUsage(subEntry.usage, false);
                             }
                         }
                         catch {
@@ -510,9 +474,12 @@ export class KimiSessionReader {
                 cumulativeOutputTokens: t.output,
                 cumulativeCacheReadTokens: t.cacheRead > 0 ? t.cacheRead : 0,
                 cumulativeCacheCreationTokens: t.cacheCreation > 0 ? t.cacheCreation : 0,
+                // §6.3: compaction stats from wire.jsonl
+                compactCount,
+                ...(compactPreContextLength !== undefined ? { compactPreContextLength } : {}),
             };
             return {
-                events: maxEvents <= 0 ? [] : events.slice(-maxEvents),
+                events: capEvents(events, maxEvents),
                 usage: hasUsageRecord ? totalUsage : undefined,
                 displayTitle,
             };
@@ -522,14 +489,157 @@ export class KimiSessionReader {
             return { events: [] };
         }
     }
+    /**
+     * Read the compaction records (context.apply_compaction /
+     * full_compaction.complete) from a session's wire.jsonl.
+     *
+     * Same cwd guard as readSessionContent. Used by KimiAcpRunner.runCompact
+     * (R2) to wait for the background compaction to land before ending the run.
+     */
+    readCompactionRecords(sessionId, cwd) {
+        const wirePath = this.resolveSessionWirePath(sessionId, cwd);
+        if (wirePath === null) {
+            return [];
+        }
+        const records = [];
+        try {
+            for (const line of readJsonlLines(wirePath)) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (isCompactionComplete(entry)) {
+                        records.push({
+                            type: entry.type,
+                            ...(entry.compactedCount !== undefined
+                                ? { compactedCount: entry.compactedCount }
+                                : {}),
+                            ...(entry.tokensBefore !== undefined ? { tokensBefore: entry.tokensBefore } : {}),
+                            ...(entry.tokensAfter !== undefined ? { tokensAfter: entry.tokensAfter } : {}),
+                            time: entry.time,
+                        });
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            getLogger().error(`[kimi-session-reader] readCompactionRecords error: ${error}`);
+            return [];
+        }
+        return records;
+    }
+    /**
+     * Resolve the main wire.jsonl path for a session after passing the cwd
+     * guard (state.json + session index fallback). Returns null when the
+     * session is unknown, fails the guard, or has no wire file.
+     */
+    resolveSessionWirePath(sessionId, cwd) {
+        // Find session directory from index (also retrieve index entry for
+        // fallback cwd guard when state.json is missing or unparseable)
+        const indexEntry = this.findSessionIndexEntry(sessionId);
+        const sessionDir = indexEntry?.sessionDir ?? null;
+        if (!sessionDir) {
+            return null;
+        }
+        const statePath = path.join(sessionDir, 'state.json');
+        let realCwd;
+        try {
+            realCwd = fs.realpathSync(cwd);
+        }
+        catch {
+            getLogger().warn(`[kimi-session-reader] fs.realpathSync failed for cwd=${cwd} (session ${sessionId}), returning empty`);
+            return null;
+        }
+        let cwdGuardPassed = false;
+        try {
+            if (fs.existsSync(statePath)) {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                const guardResult = checkCwdGuard(state, realCwd);
+                if (guardResult === 'failed') {
+                    return null;
+                }
+                if (guardResult === 'unverifiable') {
+                    getLogger().warn(`[kimi-session-reader] state.json has no workDir/cwd field for session ${sessionId}, falling back to index workDir`);
+                    // Fall through to index-based guard below
+                }
+                else {
+                    // verified — state.json cwd matches
+                    cwdGuardPassed = true;
+                }
+            }
+        }
+        catch {
+            // state.json unparseable — fall through to index-based guard
+            getLogger().warn(`[kimi-session-reader] state.json parse failed for session ${sessionId}, falling back to index workDir`);
+        }
+        // Fallback: when state.json is missing, unparseable, or has no workDir/cwd,
+        // use the workDir from the session index entry as a secondary guard.
+        // This prevents /resume <id> from accessing a session belonging to a
+        // different workspace when state.json is unavailable.
+        if (!cwdGuardPassed) {
+            const indexWorkDir = indexEntry?.workDir;
+            if (indexWorkDir && indexWorkDir !== realCwd) {
+                return null;
+            }
+            // v2 sessions have empty index workDir (v1-only field) and may lack
+            // state.json cwd. When no cwd source can verify the session belongs to
+            // the requested workspace, fail-closed to prevent cross-workspace access
+            // (aligned with claude's fail-closed cwd guard).
+            if (!indexWorkDir) {
+                getLogger().warn(`[kimi-session-reader] no cwd source (state.json + index) for session ${sessionId}, rejecting (fail-closed)`);
+                return null;
+            }
+        }
+        const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
+        if (!fs.existsSync(wirePath)) {
+            return null;
+        }
+        return wirePath;
+    }
     /**
      * Check if a session is currently active
      */
-    isSessionActive(sessionId, _cwd) {
-        const sessionDir = this.findSessionDirFromIndex(sessionId);
+    isSessionActive(sessionId, cwd) {
+        const indexEntry = this.findSessionIndexEntry(sessionId);
+        const sessionDir = indexEntry?.sessionDir;
         if (!sessionDir) {
             return false;
         }
+        // Cwd guard: the session's working directory must match the requested
+        // cwd (align with claude/pi/opencode). Mirrors readSessionContent's
+        // fail-closed cwd check (state.json workDir/cwd, then index workDir).
+        let realCwd;
+        try {
+            realCwd = fs.realpathSync(cwd);
+        }
+        catch {
+            return false;
+        }
+        let cwdGuardPassed = false;
+        const statePath = path.join(sessionDir, 'state.json');
+        try {
+            if (fs.existsSync(statePath)) {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                const guardResult = checkCwdGuard(state, realCwd);
+                if (guardResult === 'failed')
+                    return false;
+                if (guardResult === 'verified')
+                    cwdGuardPassed = true;
+            }
+        }
+        catch {
+            // state.json unparseable — fall through to index-based guard
+        }
+        if (!cwdGuardPassed) {
+            const indexWorkDir = indexEntry?.workDir;
+            if (indexWorkDir && indexWorkDir !== realCwd)
+                return false;
+            // v2 sessions have empty index workDir (v1-only field) and may lack
+            // state.json cwd — fail-closed to prevent cross-workspace access.
+            if (!indexWorkDir)
+                return false;
+        }
         const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
         if (!fs.existsSync(wirePath)) {
             return false;

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

@@ -24,13 +24,25 @@ interface OpencodeSessionReaderOptions {
      */
     captureExport?: (sessionId: string) => string;
 }
+interface OpencodeSessionListEntry {
+    id: string;
+    title: string;
+    updated: number;
+    created: number;
+    projectId: string;
+    directory: string;
+}
 export declare class OpencodeSessionReader implements AgentSessionReader {
     private readonly binary;
     private readonly cacheTtlMs;
     /** Optional raw-export capture override (testing / alt transport). */
     private readonly captureExportOverride?;
     /** Cache keyed by cwd - each cwd has its own cache entry */
-    private listCache;
+    /** cwd → 列表缓存（public：测试直接断言缓存形状，替代 as unknown as）。 */
+    listCache: Map<string, {
+        ts: number;
+        data: OpencodeSessionListEntry[];
+    }>;
     constructor(opts?: OpencodeSessionReaderOptions);
     /**
      * List sessions in a given cwd, using directory field for matching.
@@ -59,14 +71,16 @@ export declare class OpencodeSessionReader implements AgentSessionReader {
      * Passes cwd to fetchSessionList so it returns sessions for the correct directory.
      */
     isSessionActive(sessionId: string, cwd: string): boolean;
-    private realpath;
+    /** realpath 归一化（public：测试直接调用，替代 as unknown as）。 */
+    realpath(cwd: string): string;
     private fetchSessionList;
     /**
      * Capture raw `opencode export <sessionId>` output (JSON string). Injectable
      * via the constructor; the default routes stdout to a temp file fd to bypass
      * opencode's ~128KB pipe truncation on large sessions (L1).
      */
-    private captureExport;
+    /** 导出会话内容（public：测试直接调用，替代 as unknown as）。 */
+    captureExport(sessionId: string): string;
     /**
      * L1 default transport: run `opencode export` with stdout pointed at a
      * regular-file fd (NOT a pipe). opencode truncates piped stdout at ~128KB for

package/dist/session/opencode/sessions.js

@@ -15,17 +15,20 @@
  */
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
+import { silentlyUnlink } from '../../common/fs.js';
 import os from 'node:os';
 import path from 'node:path';
-import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../card/text-truncate.js';
+import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 import { getLogger } from '../../logger/index.js';
 import { STALE_MS } from '../common/constants.js';
+import { paginate, capEvents } from '../common/pagination.js';
 export class OpencodeSessionReader {
     binary;
     cacheTtlMs;
     /** Optional raw-export capture override (testing / alt transport). */
     captureExportOverride;
     /** Cache keyed by cwd - each cwd has its own cache entry */
+    /** cwd → 列表缓存（public：测试直接断言缓存形状，替代 as unknown as）。 */
     listCache = new Map();
     constructor(opts = {}) {
         this.binary = 'opencode';
@@ -46,12 +49,9 @@ export class OpencodeSessionReader {
         // secondary key so CLI/list-cache rebuilds never reorder the page.
         filtered.sort((a, b) => b.updated - a.updated || a.id.localeCompare(b.id));
         // Compute total over the full sorted set, then paginate.
-        const total = filtered.length;
-        const offset = Math.max(0, opts?.offset ?? 0);
-        const limit = opts?.limit;
-        const page = limit === undefined ? filtered.slice(offset) : filtered.slice(offset, offset + limit);
+        const { items, total } = paginate(filtered, opts ?? {});
         return {
-            sessions: page.map((e) => ({
+            sessions: items.map((e) => ({
                 sessionId: e.id,
                 // CLI title 字段形状不保证恒为 string（null/缺字段时 router 的
                 // s.summary.trim() 会 TypeError）——非 string 给空串（Review R3 P3-3）。
@@ -105,8 +105,7 @@ export class OpencodeSessionReader {
             let aiTitle;
             let displayTitle;
             // Find the last user message position (for catch-up tail).
-            // messages are already parsed objects — scan directly instead of
-            // stringify→findLastUserIndex→parse round-trip (review P2-36).
+            // messages are already parsed objects — scan directly.
             let lastUserIndex = -1;
             for (let i = 0; i < data.messages.length; i++) {
                 if (data.messages[i].info.role === 'user') {
@@ -172,21 +171,28 @@ export class OpencodeSessionReader {
                 // Track usage from step-finish parts
                 for (const part of msg.parts) {
                     if (part.type === 'step-finish' && part.tokens) {
-                        // Use the last step-finish tokens (usually the final one).
+                        // 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.
                         // ccusage-aligned: cache.write -> cacheCreationTokens.
                         // contextLength = input + cacheRead + cacheCreation (excludes
                         // output/reasoning) — the unified context-window occupancy
                         // contract across all five readers (review P2-8).
-                        usage = {
-                            inputTokens: part.tokens.input,
-                            outputTokens: part.tokens.output,
-                            contextLength: part.tokens.input +
-                                (part.tokens.cache?.read ?? 0) +
-                                (part.tokens.cache?.write ?? 0),
-                            cacheReadTokens: part.tokens.cache?.read,
-                            cacheCreationTokens: part.tokens.cache?.write,
-                            totalTokens: part.tokens.total,
-                        };
+                        if ((part.tokens.total ?? 0) !== 0) {
+                            usage = {
+                                inputTokens: part.tokens.input,
+                                outputTokens: part.tokens.output,
+                                contextLength: part.tokens.input +
+                                    (part.tokens.cache?.read ?? 0) +
+                                    (part.tokens.cache?.write ?? 0),
+                                cacheReadTokens: part.tokens.cache?.read,
+                                cacheCreationTokens: part.tokens.cache?.write,
+                                totalTokens: part.tokens.total,
+                            };
+                        }
                     }
                 }
             }
@@ -251,12 +257,7 @@ export class OpencodeSessionReader {
             // Apply maxEvents cap: keep the LAST N events (most recent), matching
             // CodexSessionReader's slice(-maxEvents). maxEvents limits the catch-up
             // tail so auto-resume cards don't load the entire session.
-            // P2-7: maxEvents <= 0 returns [] (guards `slice(-0)` full-array trap).
-            const cappedEvents = opts?.maxEvents !== undefined
-                ? opts.maxEvents <= 0
-                    ? []
-                    : events.slice(-opts.maxEvents)
-                : events;
+            const cappedEvents = capEvents(events, opts?.maxEvents);
             return {
                 events: cappedEvents,
                 usage,
@@ -289,6 +290,7 @@ export class OpencodeSessionReader {
         }
     }
     // --- Private helpers ---
+    /** realpath 归一化（public：测试直接调用，替代 as unknown as）。 */
     realpath(cwd) {
         try {
             return fs.realpathSync(cwd);
@@ -343,6 +345,7 @@ export class OpencodeSessionReader {
      * via the constructor; the default routes stdout to a temp file fd to bypass
      * opencode's ~128KB pipe truncation on large sessions (L1).
      */
+    /** 导出会话内容（public：测试直接调用，替代 as unknown as）。 */
     captureExport(sessionId) {
         if (this.captureExportOverride)
             return this.captureExportOverride(sessionId);
@@ -378,10 +381,7 @@ export class OpencodeSessionReader {
                 }
                 catch { }
             }
-            try {
-                fs.unlinkSync(tmp);
-            }
-            catch { }
+            silentlyUnlink(tmp);
         }
     }
 }

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

@@ -1,4 +1,7 @@
+import { type ContentBlockMapping } from '../common/content-blocks.js';
 import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+/** Pi-specific field-name mapping for content block extraction. */
+export declare const PI_MAPPING: ContentBlockMapping;
 /**
  * PiSessionReader: reads pi agent sessions from `~/.pi/agent/`.
  *
@@ -7,7 +10,8 @@ import type { AgentSession, AgentSessionReader, SessionContent } from '../../run
  */
 export declare class PiSessionReader implements AgentSessionReader {
     private readonly piDir;
-    private readonly sessionsDir;
+    /** 会话目录（public：测试可重定向到 fixture 目录，替代 as any）。 */
+    sessionsDir: string;
     constructor(opts?: {
         piDir?: string;
     });