ec-web 0.0.26 → 0.0.28

package/dist/sources/session-ecagent.js

@@ -0,0 +1,665 @@
+/**
+ * EC Agent 会话数据源 — EvolCore 内置基座（ecagent）的转录展示。
+ *
+ * 数据源：
+ * - $EVOLCORE_HOME/agents/<aid>/sessions/--<encoded-project>--/<ts>_<sessionId>.jsonl
+ *
+ * 文件格式（ecagent JsonlSessionRepo）：
+ *   第一行 { type: 'session', version, id, timestamp, cwd }
+ *   其余行 { type: 'message', id, parentId, timestamp, message }
+ *     message.role ∈ user | assistant | toolResult
+ *
+ * 与 Claude / Codex session source 接口对齐，返回相同的数据结构。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { getAgentSelfNames } from './msg.js';
+import { parseTranscriptResultKey, previewLargeToolResults, windowTranscriptTurns } from './transcript-window.js';
+import { buildSessionBindMap, readRunnerTaskTurns, classifyTranscriptSource, isEvolcoreRoutedMessage, resolveSessionBindSelfName, } from './session-origin.js';
+let _dlog = null;
+export function setDebugLog(log) { _dlog = log; }
+function dlog(line) { if (_dlog)
+    try {
+        _dlog(line);
+    }
+    catch { } }
+// ── 目录/文件解析 ──
+/** 与 EcagentRunner.sessionsRoot()/projectDirectory 保持一致的目录命名。 */
+function projectDirName(projectPath) {
+    const encoded = path.resolve(projectPath).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-');
+    return `--${encoded}--`;
+}
+function isProjectDirName(name) {
+    return name.startsWith('--') && name.endsWith('--') && name.length > 4;
+}
+function agentsRoot() {
+    return resolvePaths().sessionsDir;
+}
+function listAgentSessionsDirs() {
+    const root = agentsRoot();
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        out.push({ agentAid: entry.name, sessionsDir: path.join(root, entry.name, 'sessions') });
+    }
+    return out;
+}
+function readHeader(file) {
+    try {
+        const fd = fs.openSync(file, 'r');
+        const buf = Buffer.alloc(16384);
+        const n = fs.readSync(fd, buf, 0, 16384, 0);
+        fs.closeSync(fd);
+        const firstLine = buf.toString('utf-8', 0, n).split('\n', 1)[0];
+        if (!firstLine.trim())
+            return null;
+        const parsed = JSON.parse(firstLine);
+        if (parsed?.type !== 'session' || typeof parsed.id !== 'string')
+            return null;
+        return {
+            id: parsed.id,
+            cwd: typeof parsed.cwd === 'string' ? parsed.cwd : '',
+            timestamp: typeof parsed.timestamp === 'string' ? parsed.timestamp : '',
+            version: parsed.version == null ? '' : String(parsed.version),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** 文件名形如 <ISO 时间戳（冒号替换为 -）>_<sessionId>.jsonl。 */
+function sessionIdFromFileName(name) {
+    if (!name.endsWith('.jsonl'))
+        return null;
+    const base = name.slice(0, -'.jsonl'.length);
+    const sep = base.indexOf('_');
+    if (sep < 0)
+        return null;
+    const id = base.slice(sep + 1);
+    return id || null;
+}
+function listSessionFiles(agentAid, dir) {
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter(name => name.endsWith('.jsonl'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        const id = sessionIdFromFileName(name);
+        if (!id)
+            continue;
+        out.push({ agentAid, dir, file: path.join(dir, name), id });
+    }
+    return out;
+}
+// ── 项目列表 ──
+function listProjects() {
+    const byCwd = new Map();
+    for (const { agentAid, sessionsDir } of listAgentSessionsDirs()) {
+        let dirs;
+        try {
+            dirs = fs.readdirSync(sessionsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirEntry of dirs) {
+            if (!dirEntry.isDirectory() || !isProjectDirName(dirEntry.name))
+                continue;
+            const dir = path.join(sessionsDir, dirEntry.name);
+            const files = listSessionFiles(agentAid, dir);
+            if (!files.length)
+                continue;
+            let lastActivity = 0;
+            let newest = null;
+            for (const ref of files) {
+                try {
+                    const mtime = fs.statSync(ref.file).mtimeMs;
+                    if (mtime > lastActivity) {
+                        lastActivity = mtime;
+                        newest = ref;
+                    }
+                }
+                catch { }
+            }
+            const cwd = (newest ? readHeader(newest.file)?.cwd : '') || '';
+            if (!cwd)
+                continue;
+            const existing = byCwd.get(cwd);
+            if (existing) {
+                existing.count += files.length;
+                if (lastActivity > existing.lastActivity) {
+                    existing.lastActivity = lastActivity;
+                    existing.encoded = dirEntry.name;
+                }
+                continue;
+            }
+            byCwd.set(cwd, {
+                encoded: dirEntry.name,
+                cwd,
+                label: cwd.replace(/[/\\]+$/, '').split(/[/\\]/).pop() || dirEntry.name,
+                count: files.length,
+                lastActivity,
+            });
+        }
+    }
+    return [...byCwd.values()].sort((a, b) => b.lastActivity - a.lastActivity);
+}
+function resolveProject(params, projects) {
+    if (params.project) {
+        const found = projects.find(p => p.encoded === params.project);
+        if (found)
+            return found;
+    }
+    const cwdProject = projects.find(p => projectDirName(p.cwd) === projectDirName(process.cwd()));
+    if (cwdProject)
+        return cwdProject;
+    return projects[0] || null;
+}
+// ── 条目解析 ──
+function parseEntries(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch { }
+    }
+    return out;
+}
+function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('\n');
+}
+function userText(message) {
+    const content = message?.content;
+    if (!Array.isArray(content))
+        return typeof content === 'string' ? content : '';
+    return content
+        .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('\n');
+}
+function preview(text, limit = 120) {
+    return text.replace(/\s+/g, ' ').trim().slice(0, limit);
+}
+function sessionName(entries) {
+    let name = '';
+    for (const entry of entries) {
+        if (entry?.type === 'session_info' && typeof entry.name === 'string' && entry.name.trim())
+            name = entry.name.trim();
+    }
+    return name;
+}
+// ── 会话列表 ──
+const CACHE_VERSION = 1;
+const _metaCache = new Map();
+const _detailCache = new Map();
+const MAX_DETAIL_CACHE_ENTRIES = 6;
+function cacheDir(encoded) {
+    return path.join(resolvePaths().dataDir, 'ecweb-cache', 'ecagent', encoded);
+}
+function readDiskCache(encoded, id, mtime, size) {
+    try {
+        const rec = JSON.parse(fs.readFileSync(path.join(cacheDir(encoded), `${id}.json`), 'utf-8'));
+        if (rec.v === CACHE_VERSION && rec.mtime === mtime && rec.size === size && rec.meta)
+            return rec.meta;
+    }
+    catch { }
+    return null;
+}
+function writeDiskCache(encoded, id, mtime, size, meta) {
+    try {
+        const dir = cacheDir(encoded);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = path.join(dir, `${id}.json.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify({ v: CACHE_VERSION, mtime, size, meta }));
+        fs.renameSync(tmp, path.join(dir, `${id}.json`));
+    }
+    catch { }
+}
+function cacheTranscriptDetail(file, mtime, size, detail) {
+    _detailCache.delete(file);
+    _detailCache.set(file, { mtime, size, detail });
+    while (_detailCache.size > MAX_DETAIL_CACHE_ENTRIES) {
+        const oldest = _detailCache.keys().next().value;
+        if (!oldest)
+            break;
+        _detailCache.delete(oldest);
+    }
+}
+function pruneCacheFiles(encoded, validIds) {
+    const dir = cacheDir(encoded);
+    try {
+        for (const name of fs.readdirSync(dir)) {
+            const match = name.match(/^(.+)\.json(?:\.tmp)?$/);
+            if (!match || validIds.has(match[1]))
+                continue;
+            try {
+                fs.unlinkSync(path.join(dir, name));
+            }
+            catch { }
+        }
+        if (fs.readdirSync(dir).length === 0)
+            fs.rmdirSync(dir);
+    }
+    catch { }
+}
+function pruneCacheProjects(validProjects) {
+    const root = path.join(resolvePaths().dataDir, 'ecweb-cache', 'ecagent');
+    try {
+        for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || validProjects.has(entry.name))
+                continue;
+            try {
+                fs.rmSync(path.join(root, entry.name), { recursive: true, force: true });
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+function extractMeta(ref, stat) {
+    const entries = parseEntries(ref.file);
+    let firstUser = '', userMsgs = 0, totalMsgs = 0, hasRealUserInput = false, evolcoreRouted = false;
+    for (const entry of entries) {
+        if (entry?.type !== 'message')
+            continue;
+        const role = entry.message?.role;
+        if (role !== 'user' && role !== 'assistant' && role !== 'toolResult')
+            continue;
+        totalMsgs++;
+        if (role !== 'user')
+            continue;
+        userMsgs++;
+        const text = userText(entry.message);
+        if (!text.trim())
+            continue;
+        if (!firstUser)
+            firstUser = preview(text);
+        if (isEvolcoreRoutedMessage(text))
+            evolcoreRouted = true;
+        else
+            hasRealUserInput = true;
+    }
+    const title = sessionName(entries) || preview(firstUser, 50);
+    return {
+        id: ref.id,
+        title: title || 'Untitled',
+        firstUser,
+        gitBranch: '',
+        version: '',
+        userMsgs,
+        totalMsgs,
+        sizeKB: Math.round(stat.size / 1024),
+        lastActivity: stat.mtimeMs,
+        hasRealUserInput,
+        evolcoreRouted,
+    };
+}
+function listTranscripts(encoded, cwd) {
+    const refs = [];
+    for (const { agentAid, sessionsDir } of listAgentSessionsDirs()) {
+        const dir = path.join(sessionsDir, encoded);
+        for (const ref of listSessionFiles(agentAid, dir)) {
+            if (readHeader(ref.file)?.cwd !== cwd)
+                continue;
+            refs.push(ref);
+        }
+    }
+    pruneCacheFiles(encoded, new Set(refs.map(ref => ref.id)));
+    const out = [];
+    let parsed = 0, hitMem = 0, hitDisk = 0;
+    for (const ref of refs) {
+        let stat;
+        try {
+            stat = fs.statSync(ref.file);
+        }
+        catch {
+            continue;
+        }
+        const mtime = stat.mtimeMs;
+        const mem = _metaCache.get(ref.file);
+        if (mem && mem.mtime === mtime) {
+            out.push(mem.meta);
+            hitMem++;
+            continue;
+        }
+        const disk = readDiskCache(encoded, ref.id, mtime, stat.size);
+        if (disk) {
+            _metaCache.set(ref.file, { mtime, meta: disk });
+            out.push(disk);
+            hitDisk++;
+            continue;
+        }
+        const meta = extractMeta(ref, stat);
+        _metaCache.set(ref.file, { mtime, meta });
+        writeDiskCache(encoded, ref.id, mtime, stat.size, meta);
+        out.push(meta);
+        parsed++;
+    }
+    dlog(`[ecagent] listTranscripts ${encoded.slice(-20)}: ${refs.length} sessions (mem=${hitMem} disk=${hitDisk} parsed=${parsed})`);
+    out.sort((a, b) => b.lastActivity - a.lastActivity);
+    return out;
+}
+function isEcagentCliCandidate(meta) {
+    return meta.hasRealUserInput && !meta.evolcoreRouted;
+}
+// ── 会话详情 ──
+function emptyDetail(cwd = '') {
+    return {
+        turns: [], totalTurns: 0, userMsgs: 0, totalMsgs: 0,
+        counts: { userInput: 0, modelOutput: 0, toolCall: 0, toolResult: 0, msgSend: 0 },
+        inputTokens: 0, outputTokens: 0, contextTokens: 0, costUsd: 0,
+        model: '', gitBranch: '', version: '', title: '', cwd,
+    };
+}
+function findSessionFile(sessionId, cwd, encoded) {
+    for (const { agentAid, sessionsDir } of listAgentSessionsDirs()) {
+        const dirs = encoded
+            ? [path.join(sessionsDir, encoded)]
+            : (() => {
+                try {
+                    return fs.readdirSync(sessionsDir, { withFileTypes: true })
+                        .filter(entry => entry.isDirectory() && isProjectDirName(entry.name))
+                        .map(entry => path.join(sessionsDir, entry.name));
+                }
+                catch {
+                    return [];
+                }
+            })();
+        for (const dir of dirs) {
+            for (const ref of listSessionFiles(agentAid, dir)) {
+                if (ref.id !== sessionId)
+                    continue;
+                if (cwd && readHeader(ref.file)?.cwd !== cwd)
+                    continue;
+                return ref;
+            }
+        }
+    }
+    return null;
+}
+function readTranscriptFile(ref, readStats) {
+    const empty = emptyDetail();
+    let stat;
+    try {
+        stat = fs.statSync(ref.file);
+    }
+    catch {
+        return empty;
+    }
+    const cached = _detailCache.get(ref.file);
+    if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
+        _detailCache.delete(ref.file);
+        _detailCache.set(ref.file, cached);
+        if (readStats)
+            readStats.detailCacheHit = true;
+        return cached.detail;
+    }
+    const entries = parseEntries(ref.file);
+    const header = entries.find(entry => entry?.type === 'session');
+    const detail = emptyDetail(typeof header?.cwd === 'string' ? header.cwd : '');
+    detail.version = header?.version == null ? '' : String(header.version);
+    detail.title = sessionName(entries);
+    let inTok = 0, outTok = 0, contextTokens = 0, costUsd = 0, model = '';
+    let firstUser = '';
+    for (const entry of entries) {
+        if (entry?.type !== 'message')
+            continue;
+        const message = entry.message || {};
+        const role = message.role;
+        const ts = entry.timestamp ? Date.parse(entry.timestamp) : (Number(message.timestamp) || 0);
+        const blocks = [];
+        if (role === 'user') {
+            detail.totalMsgs++;
+            const content = Array.isArray(message.content) ? message.content : [];
+            for (const block of content) {
+                if (block?.type === 'text' && typeof block.text === 'string' && block.text) {
+                    blocks.push({ kind: 'text', text: block.text });
+                }
+            }
+            if (!blocks.length)
+                continue;
+            detail.userMsgs++;
+            if (!firstUser) {
+                const text = userText(message);
+                if (text.trim())
+                    firstUser = preview(text);
+            }
+            detail.counts.userInput++;
+            detail.turns.push({ role: 'user', ts, uuid: entry.id, category: 'user_input', blocks });
+            continue;
+        }
+        if (role === 'assistant') {
+            detail.totalMsgs++;
+            let hasToolUse = false;
+            const content = Array.isArray(message.content) ? message.content : [];
+            for (const block of content) {
+                if (block?.type === 'text' && typeof block.text === 'string' && block.text) {
+                    blocks.push({ kind: 'text', text: block.text });
+                }
+                else if (block?.type === 'thinking' && typeof block.thinking === 'string' && block.thinking) {
+                    blocks.push({ kind: 'thinking', text: block.thinking });
+                }
+                else if (block?.type === 'toolCall') {
+                    const input = block.arguments && typeof block.arguments === 'object' ? block.arguments : {};
+                    blocks.push({
+                        kind: 'tool_use',
+                        name: block.name || '',
+                        input,
+                        inputStr: JSON.stringify(input, null, 2),
+                    });
+                    hasToolUse = true;
+                }
+            }
+            if (message.model)
+                model = String(message.model);
+            const usage = message.usage || {};
+            if (usage.input || usage.output || usage.cacheRead || usage.cacheWrite) {
+                inTok += Number(usage.input) || 0;
+                outTok += Number(usage.output) || 0;
+                contextTokens = (Number(usage.input) || 0) + (Number(usage.cacheRead) || 0) + (Number(usage.cacheWrite) || 0);
+                costUsd += Number(usage.cost?.total) || 0;
+            }
+            if (!blocks.length)
+                continue;
+            const category = hasToolUse ? 'tool_call' : 'model_output';
+            if (category === 'tool_call')
+                detail.counts.toolCall++;
+            else
+                detail.counts.modelOutput++;
+            detail.turns.push({ role: 'assistant', ts, uuid: entry.id, category, blocks });
+            continue;
+        }
+        if (role === 'toolResult') {
+            detail.totalMsgs++;
+            const text = contentText(message.content);
+            detail.counts.toolResult++;
+            detail.turns.push({
+                role: 'user',
+                ts,
+                uuid: entry.id,
+                category: 'tool_result',
+                blocks: [{ kind: 'tool_result', text, isError: message.isError === true }],
+            });
+            continue;
+        }
+    }
+    detail.inputTokens = inTok;
+    detail.outputTokens = outTok;
+    detail.contextTokens = contextTokens;
+    detail.costUsd = costUsd;
+    detail.model = model;
+    if (!detail.title)
+        detail.title = preview(firstUser, 50);
+    cacheTranscriptDetail(ref.file, stat.mtimeMs, stat.size, detail);
+    return detail;
+}
+// ── 轮次聚合（转录 + runner 子任务）──
+async function collectTurns(sessionId, cwd, encoded, bind, readStats) {
+    const ref = findSessionFile(sessionId, cwd, encoded);
+    const detail = ref ? readTranscriptFile(ref, readStats) : emptyDetail(cwd);
+    const taskTurns = bind?.evolSessionId ? await readRunnerTaskTurns(resolvePaths().logs, bind.evolSessionId) : [];
+    const turns = detail.turns.concat(taskTurns).sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    return { detail, turns, ref };
+}
+// ── Snapshot ──
+async function buildSnapshot(params) {
+    const projects = listProjects();
+    const project = resolveProject(params, projects);
+    if (!project) {
+        return { baseagent: 'ecagent', projects: [], project: null, transcripts: [], turns: [], sessionId: null };
+    }
+    const bindMap = buildSessionBindMap();
+    const metas = listTranscripts(project.encoded, project.cwd);
+    const selfNames = await getAgentSelfNames();
+    const transcripts = metas.map(meta => {
+        const bind = bindMap.get(meta.id);
+        return {
+            ...meta,
+            title: bind?.name?.trim() || meta.title,
+            sourceType: classifyTranscriptSource(bind, isEcagentCliCandidate(meta)),
+            bound: !!bind,
+            boundChannel: bind?.channelType ?? null,
+            boundSelf: resolveSessionBindSelfName(bind, selfNames),
+            online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false,
+        };
+    });
+    const projList = projects.map(p => ({ encoded: p.encoded, label: p.label, cwd: p.cwd, count: p.count }));
+    const sessionId = params.sessionId || null;
+    if (!sessionId) {
+        return { baseagent: 'ecagent', projects: projList, project: project.encoded, transcripts, turns: [], sessionId: null };
+    }
+    const bind = bindMap.get(sessionId);
+    const { detail, turns } = await collectTurns(sessionId, project.cwd, project.encoded, bind);
+    const page = windowTranscriptTurns(turns, params.turnLimit, params.turnBefore);
+    const counts = { ...detail.counts, subtask: turns.length - detail.turns.length };
+    const transcript = metas.find(meta => meta.id === sessionId);
+    const header = {
+        sessionId,
+        title: bind?.name?.trim() || detail.title || transcript?.title || '',
+        model: detail.model,
+        gitBranch: detail.gitBranch,
+        version: detail.version,
+        cwd: detail.cwd || project.cwd,
+        totalTurns: detail.totalTurns,
+        userMsgs: detail.userMsgs,
+        totalMsgs: detail.totalMsgs,
+        counts,
+        inputTokens: detail.inputTokens,
+        outputTokens: detail.outputTokens,
+        contextTokens: detail.contextTokens,
+        costUsd: detail.costUsd,
+        sourceType: classifyTranscriptSource(bind, transcript ? isEcagentCliCandidate(transcript) : false),
+        bound: !!bind,
+        boundChannel: bind?.channelType ?? null,
+        boundSelf: resolveSessionBindSelfName(bind, selfNames),
+        online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false,
+    };
+    return {
+        baseagent: 'ecagent',
+        projects: projList,
+        project: project.encoded,
+        transcripts,
+        turns: previewLargeToolResults(page.turns, page.turnPage.start),
+        turnPage: page.turnPage,
+        sessionId,
+        header,
+    };
+}
+export async function readEcagentSessionResult(params) {
+    const projects = listProjects();
+    const project = resolveProject(params, projects);
+    const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+    const key = parseTranscriptResultKey(params.resultKey);
+    if (!project || !sessionId || !key)
+        return null;
+    const bind = buildSessionBindMap().get(sessionId);
+    const { turns } = await collectTurns(sessionId, project.cwd, project.encoded, bind);
+    const block = turns[key[0]]?.blocks?.[key[1]];
+    return block?.kind === 'tool_result' && typeof block.text === 'string' ? block.text : null;
+}
+// ── Export ──
+export async function snapshotEcagent(params = {}) {
+    return buildSnapshot(params);
+}
+export function subscribeEcagent(params, push) {
+    const p = resolvePaths();
+    const watchers = [];
+    let debounce = null;
+    const fire = () => {
+        if (debounce)
+            clearTimeout(debounce);
+        debounce = setTimeout(() => {
+            void buildSnapshot(params).then(push).catch(() => { });
+        }, 300);
+    };
+    const project = resolveProject(params, listProjects());
+    for (const { sessionsDir } of listAgentSessionsDirs()) {
+        if (project) {
+            const dir = path.join(sessionsDir, project.encoded);
+            try {
+                watchers.push(fs.watch(dir, (_event, filename) => {
+                    if (!filename || String(filename).endsWith('.jsonl'))
+                        fire();
+                }));
+            }
+            catch { }
+        }
+    }
+    try {
+        watchers.push(fs.watch(p.sessionsDir, { recursive: true }, (_event, filename) => {
+            const name = filename ? String(filename) : '';
+            if (!name || name.endsWith('.jsonl') || name.endsWith('active.json'))
+                fire();
+        }));
+    }
+    catch { }
+    if (params.sessionId) {
+        try {
+            watchers.push(fs.watch(p.logs, (_event, filename) => {
+                if (!filename || /^events(?:-.+)?\.log$/.test(String(filename)))
+                    fire();
+            }));
+        }
+        catch { }
+    }
+    return () => {
+        for (const watcher of watchers) {
+            try {
+                watcher.close();
+            }
+            catch { }
+        }
+        if (debounce)
+            clearTimeout(debounce);
+    };
+}

package/dist/sources/session-origin.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { resolveParentDistModule, toFileUrl } from './parent-package.js';
 import { resolvePaths } from '../paths.js';
 import { readJsonFile, scanChatDirs } from '../fs-utils.js';
 /** Resolve the local Agent's display name for a session binding. */
@@ -193,3 +194,18 @@ export function classifyTranscriptSource(binding, cliCandidate) {
         return binding.sourceType;
     return 'unknown';
 }
+let historyModulePromise = null;
+async function historyModule() {
+    if (!historyModulePromise) {
+        historyModulePromise = import(toFileUrl(resolveParentDistModule('core', 'session', 'runner-task-history.js')));
+    }
+    return historyModulePromise;
+}
+export async function readRunnerTaskTurns(logsDir, evolSessionId) {
+    const module = await historyModule();
+    return module.readRunnerTaskHistory(logsDir, evolSessionId).map((task) => ({
+        role: 'system', ts: task.startedAt,
+        uuid: `runner-task:${evolSessionId}:${task.taskId}`,
+        category: 'subtask', blocks: [{ kind: 'subtask', ...task }],
+    }));
+}