evolclaw 2.1.2 → 2.3.0

package/dist/core/permission.js

@@ -0,0 +1,259 @@
+import path from 'path';
+// 危险命令黑名单（正则表达式）
+const DANGEROUS_PATTERNS = [
+    // Unix
+    /\brm\s+-\w*r\w*f/, // rm -rf
+    /\bsudo\b/, // sudo
+    /\bmkfs\b/, // mkfs (格式化文件系统)
+    /\bdd\s+if=/, // dd (磁盘操作)
+    /\bchmod\s+777/, // chmod 777 (危险权限)
+    />\s*\/dev\/(?!null\b)/, // 重定向到设备文件（排除 /dev/null）
+    /\bshutdown\b/, // 关机
+    /\breboot\b/, // 重启
+    // Windows
+    /\bformat\s+[a-zA-Z]:/i, // format C: (格式化磁盘)
+    /\brd\s+\/s/i, // rd /s (递归删除目录)
+    /\bdel\s+\/[sfq]/i, // del /f, /s, /q (强制删除)
+    /\breg\s+delete/i, // reg delete (删除注册表)
+    /\bnet\s+stop/i, // net stop (停止服务)
+];
+// 只读模式写入命令黑名单
+const READONLY_WRITE_PATTERNS = [
+    /\bmkdir\b/, /\btouch\b/, /\btee\b/, /\bcp\b/, /\bmv\b/,
+    /\brm\b/, /\brmdir\b/, /\bchmod\b/, /\bchown\b/, /\bln\b/,
+    />>?\s/,
+    /\bgit\s+(commit|push|merge|rebase|reset|stash|checkout|cherry-pick|revert|tag|branch\s+-[dDmM])/,
+    /\bgit\s+am\b/,
+    /\bnpm\s+(install|ci|uninstall|update|link|publish|run|exec|init)\b/,
+    /\bnpx\b/, /\byarn\b/, /\bpnpm\b/, /\bpip\s+install\b/,
+    /\bsed\s+-i\b/, /\bawk\s+-i\b/, /\bpatch\b/,
+];
+/**
+ * 只读模式检查（用于 PreToolUse hook 和 canUseTool callback）
+ * Write/Edit/NotebookEdit 仅允许写入 {projectPath}/.evolclaw/tmp/
+ * Bash 拦截所有写入意图命令
+ */
+export function checkReadonly(toolName, input, projectPath) {
+    if (toolName === 'Write' || toolName === 'Edit' || toolName === 'NotebookEdit') {
+        const filePath = (input.file_path || input.notebook_path);
+        if (!filePath)
+            return { behavior: 'allow' };
+        const tmpDir = path.join(projectPath, '.evolclaw', 'tmp') + path.sep;
+        const resolved = path.resolve(projectPath, filePath) + (filePath.endsWith(path.sep) ? path.sep : '');
+        if (!resolved.startsWith(tmpDir) && resolved !== tmpDir.slice(0, -1)) {
+            return { behavior: 'deny', message: '🔒 只读模式：禁止修改项目文件。如需生成文件请写入 .evolclaw/tmp/ 目录' };
+        }
+    }
+    if (toolName === 'Bash') {
+        const cmd = input.command || '';
+        for (const pattern of READONLY_WRITE_PATTERNS) {
+            if (pattern.test(cmd)) {
+                return { behavior: 'deny', message: '🔒 只读模式：禁止执行写入操作' };
+            }
+        }
+    }
+    return { behavior: 'allow' };
+}
+/**
+ * 黑名单检查（用于 PreToolUse hook）
+ * 检查危险命令模式，非黑名单一律放行
+ */
+export async function checkBlacklist(toolName, input) {
+    // 只检查 Bash 工具，其余工具全部放行
+    if (toolName === 'Bash') {
+        const cmd = input.command || '';
+        // 空命令直接放行
+        if (!cmd || cmd.trim() === '') {
+            return { behavior: 'allow', updatedInput: input };
+        }
+        // 检查黑名单
+        for (const pattern of DANGEROUS_PATTERNS) {
+            if (pattern.test(cmd)) {
+                return {
+                    behavior: 'deny',
+                    message: `⛔ 危险命令被拦截: ${cmd.substring(0, 80)}`
+                };
+            }
+        }
+    }
+    // 默认允许
+    return { behavior: 'allow', updatedInput: input };
+}
+/**
+ * 工具输入摘要（提取工具调用的可读描述，供权限审批和消息展示使用）
+ */
+export function summarizeToolInput(toolName, input) {
+    if (!input)
+        return '';
+    const extractors = {
+        'Read': (i) => i.file_path,
+        'Edit': (i) => i.file_path,
+        'Write': (i) => i.file_path,
+        'Bash': (i) => i.command?.substring(0, 80),
+        'Grep': (i) => `pattern: ${i.pattern}`,
+        'Glob': (i) => `pattern: ${i.pattern}`,
+        'Agent': (i) => i.description || i.prompt?.substring(0, 80),
+        'Skill': (i) => i.skill ? `${i.skill}${i.args ? ' ' + i.args : ''}` : undefined,
+        'TodoWrite': (i) => {
+            if (Array.isArray(i.todos)) {
+                return i.todos.map((t) => t.content || t.task || t.text).filter(Boolean).join(', ').substring(0, 80);
+            }
+            return undefined;
+        },
+        'TaskCreate': (i) => i.subject || i.description?.substring(0, 80),
+        'TaskUpdate': (i) => i.status ? `${i.taskId} → ${i.status}` : i.taskId,
+        'NotebookEdit': (i) => i.notebook_path,
+        'WebFetch': (i) => i.url,
+        'WebSearch': (i) => i.query?.substring(0, 80),
+    };
+    const extractor = extractors[toolName];
+    if (extractor) {
+        const result = extractor(input);
+        if (result)
+            return result;
+    }
+    return input.description
+        || input.subject
+        || input.file_path
+        || input.pattern
+        || input.command?.substring(0, 80)
+        || input.prompt?.substring(0, 80)
+        || input.query?.substring(0, 80)
+        || input.skill
+        || input.url
+        || '';
+}
+export class PermissionGateway {
+    pending = new Map();
+    timeout = 5 * 60 * 1000;
+    eventBus;
+    /** 始终允许的工具缓存：toolName → Set<pattern> */
+    alwaysAllow = new Map();
+    setEventBus(eventBus) {
+        this.eventBus = eventBus;
+    }
+    /**
+     * 检查工具是否已被标记为"始终允许"
+     */
+    isAlwaysAllowed(toolName) {
+        return this.alwaysAllow.has(toolName);
+    }
+    /**
+     * 将工具标记为"始终允许"
+     */
+    addAlwaysAllow(toolName) {
+        if (!this.alwaysAllow.has(toolName)) {
+            this.alwaysAllow.set(toolName, new Set());
+        }
+    }
+    /**
+     * 清除所有"始终允许"缓存（用于切换权限模式时重置）
+     */
+    clearAlwaysAllow() {
+        this.alwaysAllow.clear();
+    }
+    /**
+     * 获取所有"始终允许"的工具列表
+     */
+    getAlwaysAllowList() {
+        return [...this.alwaysAllow.keys()];
+    }
+    /**
+     * 请求人工审批。返回三态决策。
+     */
+    async requestPermission(sessionId, toolName, toolInput, sendPrompt, context, summary, reason) {
+        // 如果已标记为始终允许，直接放行
+        if (this.isAlwaysAllowed(toolName)) {
+            return 'always';
+        }
+        const requestId = `perm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const displaySummary = summary || summarizeToolInput(toolName, toolInput);
+        const reasonLine = reason ? `\n原因：${reason}` : '';
+        this.eventBus?.publish({ type: 'permission:requested', sessionId, requestId, toolName, input: displaySummary });
+        // 构造 ActionInteraction
+        const interaction = {
+            type: 'interaction',
+            id: requestId,
+            kind: {
+                kind: 'action',
+                title: '🔐 权限请求',
+                body: `工具：${toolName}\n操作：${displaySummary}${reasonLine}`,
+                buttons: [
+                    { key: 'allow', label: '✅ 允许', style: 'primary' },
+                    { key: 'always', label: '🔓 始终允许', style: 'default' },
+                    { key: 'deny', label: '❌ 拒绝', style: 'danger' },
+                ],
+            },
+            channelId: context?.channelId || '',
+            sessionId,
+            expiresAt: Date.now() + this.timeout,
+        };
+        // 尝试富交互
+        let interactionSent = false;
+        if (context?.adapter?.sendInteraction && context.channelId) {
+            try {
+                const result = await context.adapter.sendInteraction(context.channelId, interaction, context.replyContext);
+                interactionSent = !!result;
+            }
+            catch (err) {
+                // sendInteraction 失败，fallback 到文本
+            }
+        }
+        // fallback 到文本
+        if (!interactionSent) {
+            await sendPrompt(`🔐 权限请求\n工具：${toolName}\n操作：${displaySummary}${reasonLine}\n\n回复 /perm allow 本次允许 | always 始终允许 | deny 拒绝`);
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                // 清理 router 注册（仅删除本次请求，不影响其他交互）
+                if (interactionSent && context?.interactionRouter) {
+                    context.interactionRouter.cancel(requestId);
+                }
+                this.eventBus?.publish({ type: 'permission:timeout', sessionId, requestId });
+                resolve('deny');
+            }, this.timeout);
+            this.pending.set(requestId, { sessionId, toolName, resolve, timer });
+            // 如果发了交互卡片，同时注册到 InteractionRouter
+            if (interactionSent && context?.interactionRouter) {
+                context.interactionRouter.register(requestId, sessionId, (action) => {
+                    this.resolvePermission(sessionId, requestId, action);
+                });
+            }
+        });
+    }
+    resolvePermission(sessionId, requestId, decision) {
+        const pending = this.pending.get(requestId);
+        if (!pending || pending.sessionId !== sessionId)
+            return false;
+        clearTimeout(pending.timer);
+        // 如果是 always，缓存该工具
+        if (decision === 'always') {
+            this.addAlwaysAllow(pending.toolName);
+        }
+        pending.resolve(decision);
+        this.pending.delete(requestId);
+        this.eventBus?.publish({ type: 'permission:resolved', sessionId, requestId, approved: decision !== 'deny' });
+        return true;
+    }
+    /** 中断时取消指定会话的所有 pending 权限请求 */
+    cancelAll(sessionId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.sessionId === sessionId) {
+                clearTimeout(pending.timer);
+                pending.resolve('deny');
+                this.pending.delete(requestId);
+            }
+        }
+    }
+    /** 获取指定会话的所有 pending requestId */
+    getPendingRequests(sessionId) {
+        const ids = [];
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.sessionId === sessionId) {
+                ids.push(requestId);
+            }
+        }
+        return ids;
+    }
+}

package/dist/core/session/adapters/claude-session-file-adapter.js

@@ -0,0 +1,144 @@
+/**
+ * Claude SessionFileAdapter
+ *
+ * Reads Claude Agent SDK session files from ~/.claude/projects/{encodedPath}/{sessionId}.jsonl
+ * and wraps sdkListSessions for name synchronization.
+ */
+import { listSessions as sdkListSessions } from '@anthropic-ai/claude-agent-sdk';
+import { encodePath } from '../../../utils/cross-platform.js';
+import { logger } from '../../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class ClaudeSessionFileAdapter {
+    agentId = 'claude';
+    getSessionFilePath(projectPath, agentSessionId) {
+        const homeDir = os.homedir();
+        const encodedPath = encodePath(projectPath);
+        return path.join(homeDir, '.claude', 'projects', encodedPath, `${agentSessionId}.jsonl`);
+    }
+    checkExists(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        return fs.existsSync(sessionFile);
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return { turns: 0 };
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let turns = 0;
+            let title;
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    const msgContent = event.message.content;
+                    const isToolResult = Array.isArray(msgContent) && msgContent.every((c) => c.type === 'tool_result');
+                    if (!isToolResult) {
+                        turns++;
+                    }
+                }
+                if (event.title && !title) {
+                    title = event.title;
+                }
+                if (event.sessionTitle && !title) {
+                    title = event.sessionTitle;
+                }
+            }
+            return { turns, title };
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read session file info: ${sessionFile}`, error);
+            return { turns: 0 };
+        }
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return null;
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    const text = this.extractUserMessageText(event.message.content);
+                    if (text)
+                        return text;
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read session file: ${sessionFile}`, error);
+        }
+        return null;
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        const sessionFile = this.getSessionFilePath(projectPath, agentSessionId);
+        if (!fs.existsSync(sessionFile))
+            return null;
+        try {
+            const content = fs.readFileSync(sessionFile, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let lastMessage = null;
+            for (const line of lines) {
+                const event = JSON.parse(line);
+                if (event.type === 'user' && event.message?.role === 'user') {
+                    lastMessage = this.extractUserMessageText(event.message.content) ?? lastMessage;
+                }
+            }
+            return lastMessage;
+        }
+        catch (error) {
+            logger.warn(`[ClaudeAdapter] Failed to read last message from session file: ${sessionFile}`, error);
+        }
+        return null;
+    }
+    scanCliSessions(projectPath) {
+        const homeDir = os.homedir();
+        const encodedPath = encodePath(projectPath);
+        const sessionDir = path.join(homeDir, '.claude', 'projects', encodedPath);
+        if (!fs.existsSync(sessionDir))
+            return [];
+        const files = fs.readdirSync(sessionDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .filter(f => !f.startsWith('agent-'))
+            .map(f => {
+            const filePath = path.join(sessionDir, f);
+            const stat = fs.statSync(filePath);
+            return { uuid: f.replace('.jsonl', ''), mtime: stat.mtimeMs, size: stat.size };
+        })
+            .filter(f => f.size > 0)
+            .sort((a, b) => b.mtime - a.mtime)
+            .slice(0, 10);
+        return files.map(f => ({ uuid: f.uuid, mtime: f.mtime }));
+    }
+    async listSdkSessions(projectPath) {
+        try {
+            const sessions = await sdkListSessions({ dir: projectPath });
+            return sessions.map(s => ({
+                sessionId: s.sessionId,
+                title: s.customTitle || undefined,
+            }));
+        }
+        catch (error) {
+            logger.debug('[ClaudeAdapter] SDK listSessions failed (non-critical):', error);
+            return [];
+        }
+    }
+    extractUserMessageText(messageContent) {
+        if (typeof messageContent === 'string') {
+            const text = messageContent.trim().replace(/\s+/g, ' ');
+            return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+        }
+        else if (Array.isArray(messageContent)) {
+            const textContent = messageContent.find((c) => c.type === 'text');
+            if (textContent?.text) {
+                const text = textContent.text.trim().replace(/\s+/g, ' ');
+                return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+            }
+        }
+        return null;
+    }
+}

package/dist/core/session/adapters/codex-session-file-adapter.js

@@ -0,0 +1,261 @@
+/**
+ * Codex SessionFileAdapter
+ *
+ * Reads Codex thread data from ~/.codex/state_*.sqlite (read-only)
+ * and Codex rollout JSONL files for detailed session info.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { logger } from '../../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class CodexSessionFileAdapter {
+    agentId = 'codex';
+    db = null;
+    dbInitialized = false;
+    /**
+     * 动态发现最新的 state_*.sqlite 文件
+     * Codex 使用 sqlx 迁移，DB 文件名含版本号（state_5, state_6, ...）
+     */
+    resolveStateDbPath() {
+        const codexHome = path.join(os.homedir(), '.codex');
+        if (!fs.existsSync(codexHome))
+            return null;
+        try {
+            const files = fs.readdirSync(codexHome)
+                .filter(f => /^state_\d+\.sqlite$/.test(f))
+                .sort((a, b) => {
+                const va = parseInt(a.match(/state_(\d+)/)?.[1] || '0');
+                const vb = parseInt(b.match(/state_(\d+)/)?.[1] || '0');
+                return vb - va;
+            });
+            return files.length > 0 ? path.join(codexHome, files[0]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getDb() {
+        if (this.dbInitialized)
+            return this.db;
+        this.dbInitialized = true;
+        const dbPath = this.resolveStateDbPath();
+        if (!dbPath)
+            return null;
+        try {
+            this.db = new DatabaseSync(dbPath, { readOnly: true });
+            logger.debug(`[CodexAdapter] Opened state DB: ${dbPath}`);
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] Failed to open state DB: ${dbPath}`, error);
+            this.db = null;
+        }
+        return this.db;
+    }
+    checkExists(projectPath, agentSessionId) {
+        // 1. 优先查 state_*.sqlite（覆盖 CLI 创建的线程）
+        const db = this.getDb();
+        if (db) {
+            try {
+                const row = db.prepare('SELECT 1 FROM threads WHERE id = ? AND archived = 0').get(agentSessionId);
+                if (row)
+                    return true;
+            }
+            catch (error) {
+                logger.warn(`[CodexAdapter] checkExists DB query failed:`, error);
+            }
+        }
+        // 2. Fallback: 扫 ~/.codex/sessions/ 下的 rollout JSONL
+        //    SDK 创建的 thread 不写 state_*.sqlite，但会持久化到 sessions 目录
+        return !!this.findRolloutFile(agentSessionId);
+    }
+    /**
+     * 在 ~/.codex/sessions/ 下递归查找含 agentSessionId 的 rollout JSONL 文件
+     */
+    findRolloutFile(agentSessionId) {
+        const sessionsDir = path.join(os.homedir(), '.codex', 'sessions');
+        if (!fs.existsSync(sessionsDir))
+            return null;
+        try {
+            const search = (dir) => {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.isDirectory()) {
+                        const found = search(path.join(dir, entry.name));
+                        if (found)
+                            return found;
+                    }
+                    else if (entry.name.endsWith('.jsonl') && entry.name.includes(agentSessionId)) {
+                        return path.join(dir, entry.name);
+                    }
+                }
+                return null;
+            };
+            return search(sessionsDir);
+        }
+        catch {
+            return null;
+        }
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        // 1. 优先查 state DB
+        const db = this.getDb();
+        if (db) {
+            try {
+                const row = db.prepare('SELECT title, rollout_path FROM threads WHERE id = ?').get(agentSessionId);
+                if (row) {
+                    return {
+                        turns: this.countTurnsFromRollout(row.rollout_path),
+                        title: row.title || undefined,
+                    };
+                }
+            }
+            catch (error) {
+                logger.warn(`[CodexAdapter] getFileInfo DB query failed:`, error);
+            }
+        }
+        // 2. Fallback: 从 sessions 目录查找 rollout 文件
+        const rolloutPath = this.findRolloutFile(agentSessionId);
+        if (rolloutPath) {
+            return { turns: this.countTurnsFromRollout(rolloutPath) };
+        }
+        return { turns: 0 };
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        // 1. 优先查 state DB
+        const db = this.getDb();
+        if (db) {
+            try {
+                const row = db.prepare('SELECT first_user_message FROM threads WHERE id = ?').get(agentSessionId);
+                if (row?.first_user_message) {
+                    const text = row.first_user_message.trim().replace(/\s+/g, ' ');
+                    return text.substring(0, 50) + (text.length > 50 ? '...' : '');
+                }
+            }
+            catch (error) {
+                logger.warn(`[CodexAdapter] readFirstMessage DB query failed:`, error);
+            }
+        }
+        // 2. Fallback: 从 rollout JSONL 读取第一条 user_message
+        const rolloutPath = this.findRolloutFile(agentSessionId);
+        if (!rolloutPath)
+            return null;
+        return this.readUserMessageFromRollout(rolloutPath, 'first');
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        // 1. 优先查 state DB 获取 rollout_path
+        const db = this.getDb();
+        let rolloutPath = null;
+        if (db) {
+            try {
+                const row = db.prepare('SELECT rollout_path FROM threads WHERE id = ?').get(agentSessionId);
+                if (row?.rollout_path && fs.existsSync(row.rollout_path)) {
+                    rolloutPath = row.rollout_path;
+                }
+            }
+            catch (error) {
+                logger.warn(`[CodexAdapter] readLastUserMessage DB query failed:`, error);
+            }
+        }
+        // 2. Fallback: 从 sessions 目录查找 rollout 文件
+        if (!rolloutPath) {
+            rolloutPath = this.findRolloutFile(agentSessionId);
+        }
+        if (!rolloutPath)
+            return null;
+        return this.readUserMessageFromRollout(rolloutPath, 'last');
+    }
+    scanCliSessions(projectPath) {
+        const db = this.getDb();
+        if (!db)
+            return [];
+        try {
+            const rows = db.prepare('SELECT id, updated_at FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC LIMIT 10').all(projectPath);
+            return rows.map(r => ({
+                uuid: r.id,
+                mtime: r.updated_at, // Codex uses Unix timestamp (seconds)
+            }));
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] scanCliSessions failed:`, error);
+            return [];
+        }
+    }
+    async listSdkSessions(projectPath) {
+        const db = this.getDb();
+        if (!db)
+            return [];
+        try {
+            const rows = db.prepare('SELECT id, title FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC').all(projectPath);
+            return rows.map(r => ({
+                sessionId: r.id,
+                title: r.title || undefined,
+            }));
+        }
+        catch (error) {
+            logger.warn(`[CodexAdapter] listSdkSessions failed:`, error);
+            return [];
+        }
+    }
+    close() {
+        if (this.db) {
+            try {
+                this.db.close();
+            }
+            catch { /* ignore close errors */ }
+            this.db = null;
+        }
+        this.dbInitialized = false;
+    }
+    /**
+     * 从 rollout JSONL 读取第一条或最后一条 user_message
+     */
+    readUserMessageFromRollout(rolloutPath, which) {
+        try {
+            const content = fs.readFileSync(rolloutPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let result = null;
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'event_msg' && event.payload?.type === 'user_message' && event.payload.message) {
+                        const text = event.payload.message.trim().replace(/\s+/g, ' ');
+                        const truncated = text.substring(0, 50) + (text.length > 50 ? '...' : '');
+                        if (which === 'first')
+                            return truncated;
+                        result = truncated;
+                    }
+                }
+                catch { /* skip malformed line */ }
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 从 rollout JSONL 文件计算轮数（数 turn_context 行）
+     */
+    countTurnsFromRollout(rolloutPath) {
+        if (!rolloutPath || !fs.existsSync(rolloutPath))
+            return 0;
+        try {
+            const content = fs.readFileSync(rolloutPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            let turns = 0;
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'turn_context') {
+                        turns++;
+                    }
+                }
+                catch { /* skip malformed line */ }
+            }
+            return turns;
+        }
+        catch {
+            return 0;
+        }
+    }
+}