evolcore 0.0.26 → 0.0.27

package/dist/core/permission/tool-policy.js

@@ -5,7 +5,7 @@ import { randomUUID } from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { resolveRoot } from '../../paths.js';
 import { containsHClassReference, containsLClassReference, checkProtectedPathAccess, getExistingHClassMaskTargets, hClassGrantIncludesProtectedPath, isHClassPath, isSameOrDescendant, isLClassPath, lClassGrantIncludesProtectedPath, resolveProtectedCandidate, resolveProtectedCandidateWithoutFinalSymlink, } from './protected-paths.js';
-import { classifyEvolcoreShellCommand, hasCodexCmdCarrierEcIntent, hasPowerShellDelegationAssignment, parseCodexToolCommand, parseBoundedOutputShellCommand, parseLiteralShellArgv, resolveCodexShellCarrierArgv, resolveCodexShellCarrierString, } from './ec-command-parser.js';
+import { classifyEvolcoreShellCommand, hasCodexCmdCarrierEcIntent, hasPowerShellCredentialAssignment, parseCodexToolCommand, parseBoundedOutputShellCommand, parseLiteralShellArgv, resolveCodexShellCarrierArgv, resolveCodexShellCarrierString, } from './ec-command-parser.js';
 import { analyzeReadonlyShellQuery, } from './readonly-shell-query.js';
 /** Resolve the session-owned temporary root supplied by the execution host. */
 export function resolveManagedTempDir(env = process.env) {
@@ -2210,8 +2210,8 @@ export function evaluateToolPreflight(toolName, input, context) {
         const parserOptions = {
             verifyShellExecutable: process.platform === 'win32',
             managedTempDir: context.managedTempDir,
-            ...(context.delegationCarrier
-                ? { expectedDelegationToken: context.delegationCarrier }
+            ...(context.sessionCredential
+                ? { expectedCredentialToken: context.sessionCredential }
                 : {}),
         };
         const parsedCodex = context.sessionId ? parseCodexToolCommand(input, parserOptions) : null;
@@ -2223,12 +2223,12 @@ export function evaluateToolPreflight(toolName, input, context) {
                 policyCode: 'ec_shell_untrusted_executable',
             };
         }
-        if (context.sessionId && parsedCodex?.ok && parsedCodex.delegationToken
-            && !context.delegationCarrier) {
+        if (context.sessionId && parsedCodex?.ok && parsedCodex.credentialToken
+            && !context.sessionCredential) {
             return {
                 behavior: 'deny',
                 input,
-                message: '🔒 PowerShell 命令中的 EVOLCORE_DELEGATION_TOKEN 必须与当前托管 thread carrier 绑定；无法确认时拒绝执行。',
+                message: '🔒 PowerShell 命令中的会话凭据必须与当前托管 Codex thread 绑定；无法确认时拒绝执行。',
                 policyCode: 'delegation_token_unbound',
             };
         }
@@ -2293,7 +2293,7 @@ export function evaluateToolPreflight(toolName, input, context) {
         const shellDialect = stringShellCarrier?.dialect
             ?? (hasCodexCmdCarrierEcIntent(input) ? 'cmd' : undefined);
         const hasPowerShellCarrierAssignment = stringShellCarrier?.dialect === 'powershell'
-            && hasPowerShellDelegationAssignment(stringShellCarrier.command);
+            && hasPowerShellCredentialAssignment(stringShellCarrier.command);
         const ecCommand = hasPowerShellCarrierAssignment && parsedCodex
             ? parsedCodex.ok && parsedCodex.argv[0] === 'ec'
                 ? { kind: 'literal' }

package/dist/core/relation/peer-identity.js

@@ -37,6 +37,10 @@ export function parsePeerKey(key) {
 export class PeerIdentityCache {
     /** 缓存最大时效：30 天 */
     static CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+    static invalidationRevisions = new Map();
+    static nextInvalidationRevision = 0;
+    /** Missing agent.md is recoverable; do not retain this negative result for 30 days. */
+    static UNKNOWN_CACHE_MAX_AGE_MS = 5 * 60 * 1000;
     /**
      * 获取 peer-identity.json 文件路径
      */
@@ -58,6 +62,22 @@ export class PeerIdentityCache {
             return null;
         }
     }
+    /** Expire only the freshness check; retain the last snapshot and its trust level. */
+    static invalidate(channelType, peerId, agentDir) {
+        const cached = this.get(channelType, peerId, agentDir);
+        if (!cached)
+            return;
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
+        this.invalidationRevisions.set(filePath, ++this.nextInvalidationRevision);
+        if (cached.lastCheckedAt === 0)
+            return;
+        try {
+            fs.writeFileSync(filePath, JSON.stringify({ ...cached, lastCheckedAt: 0 }, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logger.warn(`[PeerIdentityCache] Failed to invalidate ${channelType}#${peerId}: ${error}`);
+        }
+    }
     /**
      * 检查缓存是否需要刷新
      * @param maxAgeMs 最大缓存时间（默认 30 天）
@@ -67,7 +87,10 @@ export class PeerIdentityCache {
         const cached = this.get(channelType, peerId, agentDir);
         if (!cached)
             return true;
-        return Date.now() - cached.lastCheckedAt > maxAgeMs;
+        const effectiveMaxAge = cached.source === 'unknown'
+            ? Math.min(maxAgeMs, this.UNKNOWN_CACHE_MAX_AGE_MS)
+            : maxAgeMs;
+        return cached.lastCheckedAt === 0 || Date.now() - cached.lastCheckedAt > effectiveMaxAge;
     }
     /**
      * 从 agent.md 更新身份信息
@@ -95,7 +118,7 @@ export class PeerIdentityCache {
         };
         const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.mkdirSync(path.join(path.dirname(filePath), 'shared'), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
             logger.debug(`[PeerIdentityCache] Updated: ${channelType}#${peerId} type=${type} isAgent=${isAgent} source=${source}`);
         }
@@ -132,7 +155,7 @@ export class PeerIdentityCache {
         };
         const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.mkdirSync(path.join(path.dirname(filePath), 'shared'), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
             logger.debug(`[PeerIdentityCache] Marked unknown: ${channelType}#${peerId}`);
         }
@@ -149,8 +172,13 @@ export class PeerIdentityCache {
      * @param agentDir agent 数据根目录
      * @param store AIDStore 实例（由调用方提供，负责 checkAgentMd + downloadAgentMd）
      * @param forceRefresh 强制刷新（忽略缓存时效）
+     * @param aunPath AUN SDK 数据根目录；与关系缓存所在的 agentDir 分开
      */
-    static async resolve(channelType, peerId, agentDir, store, forceRefresh = false) {
+    static async resolve(channelType, peerId, agentDir, store, forceRefresh = false, aunPath) {
+        // AIDStore is authoritative for the SDK cache root. Callers that predate
+        // the explicit aunPath parameter must still fall back to that same root,
+        // otherwise the error path could read a different agent.md tree.
+        const resolvedAunPath = aunPath ?? store.aunPath;
         // A malformed transport envelope must never turn into a relation key such
         // as `aun#` or trigger an agent.md lookup for an empty AID.  Keep the
         // fallback in-memory so callers can safely render an unknown peer without
@@ -177,15 +205,36 @@ export class PeerIdentityCache {
                 return cached;
             }
         }
+        const cachePath = this.getFilePath(channelType, peerId, agentDir);
+        const revision = this.invalidationRevisions.get(cachePath) ?? 0;
+        const stale = this.get(channelType, peerId, agentDir);
         // 2. 通过 agentmdSync 拉取（内部走 store.checkAgentMd → store.downloadAgentMd）
         try {
             logger.debug(`[PeerIdentityCache] Syncing agent.md: ${channelType}#${peerId}`);
             const { agentmdSync } = await import('../../aun/aid/agentmd.js');
-            const result = await agentmdSync(peerId, { store });
+            const invalidated = stale?.lastCheckedAt === 0 || revision > 0;
+            const result = await agentmdSync(peerId, {
+                store,
+                aunPath: resolvedAunPath,
+                forceRefresh: invalidated,
+                ttlDays: stale?.source === 'unknown' ? 0 : undefined,
+            });
+            if ((this.invalidationRevisions.get(cachePath) ?? 0) !== revision) {
+                // A newer event arrived during this read. Its next lookup must refresh.
+                return this.get(channelType, peerId, agentDir) ?? {
+                    aid: peerId, type: 'unknown', isAgent: true, agentMdHash: '', agentMdUpdatedAt: 0,
+                    verifiedAt: 0, lastCheckedAt: 0, source: 'unknown',
+                };
+            }
+            // A failed refresh may return old local bytes. Keep the invalidated
+            // snapshot so the next lookup retries instead of caching it for 30 days.
+            if (invalidated && !result.verification && stale)
+                return stale;
             const content = result.content;
             if (!content) {
                 throw new Error('agent.md content unavailable');
             }
+            this.invalidationRevisions.delete(cachePath);
             // 验签通过 → 可信（source=agentmd）；否则 type 仍解析但标记未验证
             const verified = result.verification?.status === 'verified';
             const source = verified ? 'agentmd' : 'agentmd-unverified';
@@ -201,10 +250,12 @@ export class PeerIdentityCache {
             return this.updateFromAgentMd(channelType, peerId, agentDir, content, verified ? Date.now() : 0, source);
         }
         catch (err) {
+            if (stale?.lastCheckedAt === 0)
+                return stale;
             // 4. agentmdSync 抛错（非网络失败——网络失败时它内部已 fallback 返回本地内容；
             //    这里通常是无内容或解析异常）。兜底读本地文件，但无法重新验签，
             //    故沿用缓存里已有的可信级别，绝不凭空升级为已验签。
-            const localPath = agentMdPath(peerId);
+            const localPath = agentMdPath(peerId, resolvedAunPath);
             try {
                 if (fs.existsSync(localPath)) {
                     const localContent = fs.readFileSync(localPath, 'utf-8');

package/dist/core/relation/shared-data.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { agentRelationDir, agentRelationSharedDir, agentRelationsDir, resolvePaths } from '../../paths.js';
+import { parsePeerKey } from './peer-identity.js';
+import { logger } from '../../utils/logger.js';
+export const RELATION_SHARED_FILE_ALLOWLIST = Object.freeze(['rules.md']);
+function isAllowedSharedFile(relativePath) {
+    return RELATION_SHARED_FILE_ALLOWLIST.includes(relativePath);
+}
+function copyFileAtomically(source, target) {
+    const targetDir = path.dirname(target);
+    fs.mkdirSync(targetDir, { recursive: true });
+    const temporary = path.join(targetDir, `.${path.basename(target)}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+    try {
+        fs.copyFileSync(source, temporary);
+        const sourceStat = fs.statSync(source);
+        fs.utimesSync(temporary, sourceStat.atime, sourceStat.mtime);
+        fs.renameSync(temporary, target);
+    }
+    finally {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch { }
+    }
+}
+export function ensureRelationSharedDirectory(selfAid, peerKey) {
+    parsePeerKey(peerKey);
+    const sharedDir = agentRelationSharedDir(selfAid, peerKey);
+    fs.mkdirSync(sharedDir, { recursive: true });
+    return sharedDir;
+}
+export function syncRelationSharedFile(selfAid, peerKey, relativePath) {
+    if (!isAllowedSharedFile(relativePath)) {
+        throw Object.assign(new Error(`Relation shared file is not allowlisted: ${relativePath}`), {
+            code: 'SHARED_FILE_NOT_ALLOWED',
+        });
+    }
+    parsePeerKey(peerKey);
+    const relationDir = agentRelationDir(selfAid, peerKey);
+    const source = path.join(relationDir, relativePath);
+    const target = path.join(ensureRelationSharedDirectory(selfAid, peerKey), relativePath);
+    let sourceStat;
+    try {
+        sourceStat = fs.statSync(source);
+    }
+    catch {
+        return { copied: false, target };
+    }
+    if (!sourceStat.isFile())
+        return { copied: false, target };
+    try {
+        const targetStat = fs.statSync(target);
+        if (targetStat.isFile()
+            && targetStat.size === sourceStat.size
+            && Math.abs(targetStat.mtimeMs - sourceStat.mtimeMs) < 1) {
+            return { copied: false, target };
+        }
+    }
+    catch { }
+    copyFileAtomically(source, target);
+    return { copied: true, target };
+}
+export function migrateRelationSharedDirectories() {
+    const agentsDir = resolvePaths().agentsDir;
+    let relations = 0;
+    let copied = 0;
+    if (!fs.existsSync(agentsDir))
+        return { relations, copied };
+    for (const agentEntry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const selfAid = agentEntry.name;
+        const relationsDir = agentRelationsDir(selfAid);
+        let relationEntries;
+        try {
+            relationEntries = fs.readdirSync(relationsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const relationEntry of relationEntries) {
+            if (!relationEntry.isDirectory() || relationEntry.name.startsWith('_'))
+                continue;
+            try {
+                parsePeerKey(relationEntry.name);
+            }
+            catch {
+                continue;
+            }
+            relations += 1;
+            try {
+                ensureRelationSharedDirectory(selfAid, relationEntry.name);
+                for (const file of RELATION_SHARED_FILE_ALLOWLIST) {
+                    if (syncRelationSharedFile(selfAid, relationEntry.name, file).copied)
+                        copied += 1;
+                }
+            }
+            catch (error) {
+                logger.warn(`[RelationShared] failed self=${selfAid} peer=${relationEntry.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    return { relations, copied };
+}

package/dist/core/role/runtime-policy.js

@@ -1,5 +1,9 @@
 import { getRoleDefinition } from '../../config/roles.js';
 import { PUBLIC_PERMISSION_MODES } from '../permission/mode.js';
+import { ConfigTarget, read } from '../../config/config-manager.js';
+import { resolvePrincipal } from '../../config/contact-book.js';
+import { isFullAccessEnabled, loadDaemonConfig } from '../../config-store.js';
+import { hasTrustedPrincipal } from '../auth/authenticated-actor.js';
 const PERMISSION_MODE_AUTHORITY = {
     readonly: 0,
     auto: 1,
@@ -139,3 +143,63 @@ export function validateRuntimeStringFieldOverride(input) {
     }
     return { ok: true };
 }
+/**
+ * Resolve the Agent-level host execution policy for one authenticated principal.
+ * The Agent flag is subordinate to daemon fullaccess and independent of role permissionMode values.
+ */
+export function agentFullAccessStatus(agentAid, principalId) {
+    const config = read(ConfigTarget.Agent, { self: agentAid }, { cache: false });
+    const daemon = loadDaemonConfig();
+    const enabled = config?.fullaccess?.enabled === true;
+    const hostEnabled = isFullAccessEnabled(daemon);
+    const eligible = !!principalId
+        && !!config?.owners?.includes(principalId)
+        && !!daemon.owners?.includes(principalId);
+    return { enabled, hostEnabled, eligible, effective: enabled && hostEnabled && eligible };
+}
+/** Create a trusted per-call claim for a direct private message. */
+export function createAgentPolicyAuthorization(input) {
+    if (input.chatType !== 'private'
+        || (input.source !== undefined && input.source !== 'user')
+        || ['agent', 'ai', 'bot', 'service', 'group'].includes((input.peerType ?? '').toLowerCase())
+        || !hasTrustedPrincipal(input.actor))
+        return undefined;
+    if (!agentFullAccessStatus(input.agentAid, input.actor.principalId).effective)
+        return undefined;
+    return {
+        permissionMode: 'fullaccess',
+        processRole: 'fullaccess-run',
+        dataScope: 'daemon',
+        source: 'agent-policy',
+        agentAid: input.agentAid,
+        authorizedBy: input.actor.principalId,
+        policyActor: { ...input.actor },
+    };
+}
+/** Revalidate a claim before Runner calls, retries, and daemon IPC. */
+export function assertAgentPolicyAuthorization(authorization) {
+    const actor = authorization.policyActor;
+    if (!authorization.agentAid || !hasTrustedPrincipal(actor)) {
+        throw new Error('Agent fullaccess policy lacks authenticated origin');
+    }
+    const current = resolvePrincipal(authorization.agentAid, actor.operatorChannelType, actor.operatorId, actor.operatorChannelKey);
+    if (!hasTrustedPrincipal({ ...actor, ...current }) || current.principalId !== authorization.authorizedBy) {
+        throw new Error('Agent fullaccess policy origin identity changed');
+    }
+    if (!agentFullAccessStatus(authorization.agentAid, authorization.authorizedBy).effective) {
+        throw new Error('Agent fullaccess policy disabled or current owner is no longer eligible');
+    }
+}
+/** Only the authenticated EC Web Agent settings may mutate this policy. */
+export function agentFullAccessWriteError(input) {
+    if (!input.ecwebManagement) {
+        return 'Agent fullaccess can only be configured from ECWeb';
+    }
+    if (!input.daemonOwner || input.delegated) {
+        return 'Only authenticated ECWeb management may configure Agent fullaccess';
+    }
+    if (input.enabled && !isFullAccessEnabled()) {
+        return 'Host fullaccess is disabled';
+    }
+    return undefined;
+}

package/dist/core/runtime-lock.js

@@ -17,28 +17,21 @@ export function resolveManagedLockPath(namespace, identity, legacyPath) {
 }
 function isTrustedRuntimeLockDir(candidate) {
     const resolved = path.resolve(candidate);
-    if (path.basename(resolved) !== 'evolcore-locks')
-        return false;
     const tmpRoot = process.env.TMPDIR?.trim();
     if (!tmpRoot || !path.isAbsolute(tmpRoot))
         return false;
     const resolvedTmpRoot = path.resolve(tmpRoot);
-    const relative = path.relative(resolvedTmpRoot, resolved);
-    const isWithinTmp = relative !== '..'
-        && !relative.startsWith(`..${path.sep}`)
-        && !path.isAbsolute(relative);
-    // The daemon supplies each task either a generic evolcore-runtime-* child
-    // or Codex's private digest directory. Both share a sibling evolcore-locks
-    // directory so mutations from separate sessions still serialize. Do not
-    // accept arbitrary TMPDIR siblings supplied by a child process.
     const tmpBase = path.basename(resolvedTmpRoot);
-    const tmpParent = path.dirname(resolvedTmpRoot);
-    const isGenericSessionRuntime = /^evolcore-runtime-[a-f0-9]{24}$/.test(tmpBase);
-    const isCodexSessionRuntime = /^[a-f0-9]{24}$/.test(tmpBase)
-        && /^evolcore-codex-(?:\d+|user)$/.test(path.basename(tmpParent));
-    const isManagedSessionSibling = (isGenericSessionRuntime || isCodexSessionRuntime)
-        && path.dirname(resolved) === tmpParent;
-    if (!isWithinTmp && !isManagedSessionSibling)
+    const isSessionLockDir = /^ec-session-[a-f0-9]{24}$/.test(tmpBase)
+        && path.basename(resolved) === 'locks'
+        && path.dirname(resolved) === resolvedTmpRoot;
+    // The app-server process has no EvolCore session yet and retains its own
+    // process-lifetime lock namespace. Both process and session roots use the
+    // same `$TMPDIR/locks` layout.
+    const isProcessLockDir = /^evolcore-managed-tmp-/.test(tmpBase)
+        && path.basename(resolved) === 'locks'
+        && path.dirname(resolved) === resolvedTmpRoot;
+    if (!isSessionLockDir && !isProcessLockDir)
         return false;
     try {
         // Windows Stats.mode does not describe ACL privacy. The managed runtime
@@ -53,15 +46,6 @@ function isTrustedRuntimeLockDir(candidate) {
             return false;
         if (!isWindows && (tmpStat.mode & 0o077) !== 0)
             return false;
-        if (isManagedSessionSibling) {
-            const parentStat = fs.lstatSync(tmpParent);
-            if (!parentStat.isDirectory() || parentStat.isSymbolicLink())
-                return false;
-            if (!isWindows && typeof process.getuid === 'function' && parentStat.uid !== process.getuid())
-                return false;
-            if (!isWindows && (parentStat.mode & 0o077) !== 0)
-                return false;
-        }
         const stat = fs.lstatSync(resolved);
         if (!stat.isDirectory() || stat.isSymbolicLink())
             return false;

package/dist/core/session/runner-task-history.js

@@ -0,0 +1,170 @@
+import fs from 'fs';
+import path from 'path';
+const RUNNER_TASK_EVENT_TYPES = new Set([
+    'runner:task-started',
+    'runner:task-progress',
+    'runner:task-notification',
+]);
+export const RUNNER_TASK_LOG_RE = /^events(?:-.+)?\.log$/;
+const runnerLogCache = new Map();
+function parseRunnerTaskLines(raw) {
+    const events = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.includes('runner:task-'))
+            continue;
+        try {
+            const event = JSON.parse(line);
+            if (event && RUNNER_TASK_EVENT_TYPES.has(event.type) && typeof event.sessionId === 'string')
+                events.push(event);
+        }
+        catch { }
+    }
+    return events;
+}
+function readRunnerLogFile(file) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        runnerLogCache.delete(file);
+        return [];
+    }
+    let cached = runnerLogCache.get(file);
+    if (!cached || stat.size < cached.offset || stat.ino !== cached.inode || stat.dev !== cached.device
+        || (stat.size === cached.offset && stat.mtimeMs !== cached.mtimeMs)) {
+        cached = { device: stat.dev, inode: stat.ino, offset: 0, mtimeMs: 0, events: [] };
+    }
+    if (stat.size === cached.offset) {
+        runnerLogCache.set(file, cached);
+        return cached.events;
+    }
+    const bytes = stat.size - cached.offset;
+    const buffer = Buffer.allocUnsafe(bytes);
+    let fd = null;
+    try {
+        fd = fs.openSync(file, 'r');
+        const read = fs.readSync(fd, buffer, 0, bytes, cached.offset);
+        if (read !== bytes)
+            return cached.events;
+    }
+    catch {
+        return cached.events;
+    }
+    finally {
+        if (fd != null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    const lastBreak = buffer.lastIndexOf(0x0a);
+    if (lastBreak < 0) {
+        runnerLogCache.set(file, cached);
+        return cached.events;
+    }
+    cached = {
+        device: stat.dev,
+        inode: stat.ino,
+        offset: cached.offset + lastBreak + 1,
+        mtimeMs: stat.mtimeMs,
+        events: cached.events.concat(parseRunnerTaskLines(buffer.subarray(0, lastBreak + 1).toString('utf8'))),
+    };
+    runnerLogCache.set(file, cached);
+    return cached.events;
+}
+function eventTimestamp(event) {
+    const numeric = Number(event.timestamp);
+    if (Number.isFinite(numeric) && numeric > 0)
+        return numeric;
+    const parsed = event.ts ? Date.parse(event.ts) : 0;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function eventTaskId(event, aliases) {
+    if (typeof event.taskId === 'string' && event.taskId)
+        return event.taskId;
+    const useId = typeof event.toolUseId === 'string' ? event.toolUseId.trim() : '';
+    return useId ? aliases.get(useId) ?? `tool:${useId}` : null;
+}
+export function readRunnerTaskHistory(logsDir, evolSessionId) {
+    let files;
+    try {
+        files = fs.readdirSync(logsDir)
+            .filter(name => RUNNER_TASK_LOG_RE.test(name))
+            .sort()
+            .map(name => path.join(logsDir, name));
+    }
+    catch {
+        return [];
+    }
+    const validFiles = new Set(files);
+    for (const cachedFile of runnerLogCache.keys()) {
+        if (path.dirname(cachedFile) === logsDir && !validFiles.has(cachedFile))
+            runnerLogCache.delete(cachedFile);
+    }
+    const events = files.flatMap(readRunnerLogFile)
+        .filter(event => event.sessionId === evolSessionId)
+        .sort((a, b) => eventTimestamp(a) - eventTimestamp(b));
+    const tasks = new Map();
+    const aliases = new Map();
+    for (const event of events) {
+        if (typeof event.taskId === 'string' && event.taskId && typeof event.toolUseId === 'string' && event.toolUseId) {
+            aliases.set(event.toolUseId, event.taskId);
+        }
+    }
+    const hidden = new Set();
+    const terminal = new Set();
+    for (const event of events) {
+        const taskId = eventTaskId(event, aliases);
+        if (!taskId)
+            continue;
+        if (event.skipTranscript)
+            hidden.add(taskId);
+        const at = eventTimestamp(event);
+        let task = tasks.get(taskId);
+        if (!task) {
+            task = {
+                taskId,
+                taskKind: event.taskKind || 'agent',
+                toolUseId: event.toolUseId || null,
+                description: event.description || taskId,
+                subagentType: event.subagentType || null,
+                status: 'running',
+                terminalReason: '',
+                progress: '',
+                lastToolName: '',
+                totalTokens: 0,
+                toolUses: 0,
+                durationMs: 0,
+                startedAt: at,
+                updatedAt: at,
+            };
+            tasks.set(taskId, task);
+        }
+        if (event.type === 'runner:task-started') {
+            task.startedAt = task.startedAt ? Math.min(task.startedAt, at) : at;
+            if (!terminal.has(taskId))
+                task.status = 'running';
+        }
+        else if (event.type === 'runner:task-progress') {
+            task.progress = event.summary || event.description || task.progress;
+        }
+        else if (event.type === 'runner:task-notification') {
+            terminal.add(taskId);
+            task.status = event.status || 'completed';
+            task.terminalReason = event.terminalReason || task.terminalReason;
+        }
+        task.updatedAt = Math.max(task.updatedAt, at);
+        task.taskKind = event.taskKind || task.taskKind;
+        task.toolUseId = event.toolUseId || task.toolUseId;
+        if (event.type !== 'runner:task-progress')
+            task.description = event.description || task.description;
+        task.subagentType = event.subagentType || task.subagentType;
+        task.lastToolName = event.lastToolName || task.lastToolName;
+        task.totalTokens = event.usage?.totalTokens ?? event.totalTokens ?? task.totalTokens;
+        task.toolUses = event.usage?.toolUses ?? event.toolUses ?? task.toolUses;
+        task.durationMs = event.usage?.durationMs ?? event.durationMs ?? task.durationMs;
+    }
+    return [...tasks.values()].filter(task => !hidden.has(task.taskId))
+        .sort((a, b) => a.startedAt - b.startedAt || a.taskId.localeCompare(b.taskId));
+}