evolcore 0.0.26 → 0.0.28

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));
+}

package/dist/core/session/session-manager.js

@@ -1,8 +1,10 @@
 import { ensureDir } from '../../utils/atomic-write.js';
+import { resolvePaths } from '../../paths.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
+import { readRunnerTaskHistory } from './runner-task-history.js';
 import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, appendJsonlDurable, fsyncJsonlFile, readJsonFile, readLastJsonlLine, readLastJsonlLineStrict, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
-import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID } from './session-mapper.js';
+import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID, isArchivedTopicLable, normalizeTopicLable, } from './session-mapper.js';
 import { tryParseChannelKey } from '../channel-loader.js';
 import { isSystemControlChannel } from '../system-channels.js';
 import path from 'path';
@@ -330,6 +332,9 @@ export class SessionManager {
                 // backend boundary itself. Always take the latest binding and owner.
                 session.agentSessionId = latestId;
                 session.baseagent = latest.baseagent;
+                // Classification is owned by setTopicLable, not stale turn snapshots.
+                if (!opts?.lableMutation)
+                    session.lable = latest.lable;
                 // Merge metadata at field level as well.  A caller can hold a stale
                 // Session object across an await; preserving keys from the latest
                 // snapshot prevents unrelated turn/route updates from being erased.
@@ -725,7 +730,7 @@ export class SessionManager {
         return result;
     }
     // ─── Session lifecycle ───
-    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, baseagent, selfAID, channelType, peerType, identity) {
+    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, baseagent, selfAID, channelType, peerType, identity, lable) {
         if (isSystemControlChannel(channel) || isSystemControlChannel(channelType)) {
             throw new Error(`[SessionManager] system control channel is sessionless. channel="${channel}"`);
         }
@@ -739,7 +744,7 @@ export class SessionManager {
         // 用于 resolveIdentity fallback 正确命中群成员角色表（见 resolvePeerRoleDetail）。
         const identityConversationId = chatType === 'group' ? (metadata?.groupId || channelId) : userId;
         if (threadId) {
-            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType, lable);
             session.identity = identity ?? this.resolveIdentity(channel, userId, chatType, identityConversationId);
             return session;
         }
@@ -960,7 +965,7 @@ export class SessionManager {
         current.metadata = metadata;
         this.persistSession(current, 'sync', { turnStateMutation: true });
     }
-    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType) {
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType, lable) {
         // 使用精确路径（channelType + selfAID）
         const chatDir = (channelType && selfAID)
             ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfAID, channel); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
@@ -1023,6 +1028,7 @@ export class SessionManager {
             chatType: effectiveChatType,
             metadata,
             name: name || '话题会话',
+            lable: normalizeTopicLable(lable),
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
@@ -1286,7 +1292,7 @@ export class SessionManager {
         const validSessionId = normalizeBackendSessionId(session.agentSessionId);
         return { ...session, agentSessionId: validSessionId };
     }
-    async listSessions(channel, channelId) {
+    async listSessions(channel, channelId, options = {}) {
         let chatDir;
         try {
             chatDir = this.resolveChatDirSafe(channel, channelId);
@@ -1294,7 +1300,16 @@ export class SessionManager {
         catch {
             return [];
         }
-        const sessions = this.findAllSessionsInChat(chatDir, true);
+        const archiveFilter = options.archiveFilter ?? 'active';
+        const sessions = this.findAllSessionsInChat(chatDir, true)
+            .filter(session => {
+            if (archiveFilter === 'all')
+                return true;
+            if (!session.threadId)
+                return archiveFilter !== 'archived';
+            const archived = isArchivedTopicLable(session.lable);
+            return archiveFilter === 'archived' ? archived : !archived;
+        });
         return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
     }
     async getSessionByProjectPath(channel, channelId, projectPath) {
@@ -1361,6 +1376,15 @@ export class SessionManager {
         this.persistSession(current, 'sync');
         return true;
     }
+    async setTopicLable(sessionId, lable) {
+        const normalized = normalizeTopicLable(lable);
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded?.current.threadId)
+            return false;
+        loaded.current.lable = normalized;
+        this.persistSession(loaded.current, 'sync', { lableMutation: true });
+        return true;
+    }
     async unbindSession(sessionId) {
         const found = this.findSessionFileById(sessionId);
         if (!found)
@@ -1477,6 +1501,10 @@ export class SessionManager {
         if (identityMetadata?.sessionBoundaryOperationId) {
             metadata.sessionBoundaryOperationId = identityMetadata.sessionBoundaryOperationId;
         }
+        // Only an explicit caller may bind a diagnostic case. Never inherit a
+        // previous case (or any provider thread binding) from the active session.
+        if (identityMetadata?.diagnostic)
+            metadata.diagnostic = { ...identityMetadata.diagnostic };
         const session = {
             id: generateSessionId(),
             channel,
@@ -1598,6 +1626,7 @@ export class SessionManager {
             agentSessionId: forkedAgentSessionId,
             metadata,
             name: options.name || `${sourceSession.name || '会话'} · 第 ${options.sourceTurn} 轮`,
+            lable: normalizeTopicLable(options.lable === undefined ? sourceSession.lable : options.lable),
             createdAt: now,
             updatedAt: now,
         };
@@ -1740,6 +1769,9 @@ export class SessionManager {
         }
         return adapter.getFileInfo(projectPath, agentSessionId, agentAid);
     }
+    getRunnerTaskHistory(sessionId) {
+        return readRunnerTaskHistory(resolvePaths().logs, sessionId);
+    }
     async listSdkSessions(projectPath, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter?.listSdkSessions)

package/dist/core/session/session-mapper.js

@@ -1,6 +1,45 @@
 import { formatTimestamp } from './session-fs-store.js';
 /** Default topic component used by the stable session routing key. */
 export const DEFAULT_THREAD_ID = 'main';
+/** Normalize the optional topic category. The public field is spelled `lable`. */
+export function normalizeTopicLable(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new Error('lable 必须是字符串或 null');
+    const lable = value.trim();
+    if (lable.length > 100 || /[\x00-\x1F\x7F]/.test(lable)) {
+        throw new Error('lable 最多 100 个字符，且不能包含控制字符');
+    }
+    return lable || undefined;
+}
+/** The reserved category used to hide a topic from the default topic list. */
+export const ARCHIVED_TOPIC_LABLE = '归档';
+export function isArchivedTopicLable(lable) {
+    return lable === ARCHIVED_TOPIC_LABLE;
+}
+/** Resolve the public archived query flag while keeping omitted values backward compatible. */
+export function resolveTopicArchiveFilter(value) {
+    if (value === undefined || value === false)
+        return 'active';
+    if (value === true)
+        return 'archived';
+    if (value === 'all')
+        return 'all';
+    throw new Error('archived 必须是布尔值或 "all"');
+}
+/** Ordinary messages may initialize a category; malformed metadata is ignored. */
+export function readTopicLable(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    const fields = payload;
+    try {
+        return normalizeTopicLable(Object.hasOwn(fields, 'lable') ? fields.lable : fields.label);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function formatSessionKey(channelType, channelId, threadId) {
     const tid = threadId || DEFAULT_THREAD_ID;
     return `${channelType}#${encodeURIComponent(channelId)}#${encodeURIComponent(tid)}`;
@@ -64,6 +103,7 @@ export function sessionToFile(session) {
         projectPath: session.projectPath,
         agentSessionId: session.agentSessionId ?? null,
         name: session.name ?? null,
+        ...(session.lable ? { lable: session.lable } : {}),
         activeTask: session.processingState ?? null,
         metadata,
         createdAt: session.createdAt,
@@ -113,6 +153,7 @@ export function fileToSession(file) {
         projectPath: file.projectPath,
         agentSessionId: file.agentSessionId ?? undefined,
         name: file.name ?? undefined,
+        ...(file.lable ? { lable: file.lable } : {}),
         processingState: file.activeTask ?? undefined,
         metadata,
         createdAt: file.createdAt,

package/dist/core/session/session-turn-coordinator.js

@@ -13,6 +13,19 @@ function cloneTurnMetadata(value) {
 export function readTurnMetadata(session) {
     return cloneTurnMetadata(session.metadata?.turnState);
 }
+function terminalRecoveryContext(session, context) {
+    if (!context)
+        return undefined;
+    return {
+        ...context,
+        baseagent: context.baseagent ?? session.baseagent,
+        // A newly allocated backend becomes known only after begin(). Preserve
+        // that binding at the terminal boundary, without adopting a backend switch.
+        agentSessionId: (!context.baseagent || context.baseagent === session.baseagent)
+            ? session.agentSessionId ?? context.agentSessionId
+            : context.agentSessionId,
+    };
+}
 export class SessionTurnCoordinator {
     sessionManager;
     states = new Map();
@@ -69,7 +82,7 @@ export class SessionTurnCoordinator {
         this.states.set(sessionId, cloneTurnMetadata(next));
         return cloneTurnMetadata(next);
     }
-    async begin(session, taskId, inputId = crypto.randomUUID()) {
+    async begin(session, taskId, inputId = crypto.randomUUID(), recoveryContext) {
         const state = this.hydrate(session);
         const generation = state.generation + 1;
         const turnId = `turn-${crypto.randomUUID()}`;
@@ -82,6 +95,7 @@ export class SessionTurnCoordinator {
             status: 'starting',
             startedAt,
             interactions: [],
+            recoveryContext,
         };
         const next = { ...state, schemaVersion: 1, generation, active };
         await this.persist(session, next);
@@ -96,20 +110,34 @@ export class SessionTurnCoordinator {
     async completeInterrupt(session, reason) {
         const state = this.hydrate(session);
         const active = state.active;
-        if (!active || active.status !== 'interrupting')
+        if (!active) {
+            // A delayed task:error must not resurrect work after an idle /stop or a
+            // replacement message. Keep completed tasks completed.
+            const terminal = state.lastTerminal;
+            const cancelled = reason === 'stop' || reason === 'explicit_cancel';
+            const superseded = reason === 'new_message' || reason === 'recalled' || reason === 'restart';
+            await this.persist(session, terminal && terminal.status !== 'committed' && (cancelled || superseded)
+                ? { ...state, lastTerminal: { ...terminal, status: cancelled ? 'cancelled' : 'superseded', reason } }
+                : state);
+            return undefined;
+        }
+        if (active.status !== 'interrupting')
             return undefined;
         const next = {
             ...state,
             active: undefined,
             lastTerminal: {
                 turnId: active.turnId,
+                recoveryContext: terminalRecoveryContext(session, active.recoveryContext),
                 taskId: active.taskId,
                 generation: active.generation,
-                status: reason === 'daemon_restart'
-                    ? 'interrupted'
-                    : reason === 'stop' || reason === 'explicit_cancel'
-                        ? 'cancelled'
-                        : 'superseded',
+                status: reason === 'timeout' || reason === 'execution_error'
+                    ? 'failed'
+                    : reason === 'daemon_restart'
+                        ? 'interrupted'
+                        : reason === 'stop' || reason === 'explicit_cancel'
+                            ? 'cancelled'
+                            : 'superseded',
                 reason,
                 finishedAt: Date.now(),
             },
@@ -178,6 +206,7 @@ export class SessionTurnCoordinator {
                 taskId: lease.taskId,
                 generation: lease.generation,
                 status: 'committed',
+                recoveryContext: terminalRecoveryContext(session, state.active?.recoveryContext),
                 finishedAt: Date.now(),
             },
         };
@@ -196,6 +225,7 @@ export class SessionTurnCoordinator {
                 taskId: lease.taskId,
                 generation: lease.generation,
                 status,
+                recoveryContext: terminalRecoveryContext(session, state.active?.recoveryContext),
                 reason,
                 finishedAt: Date.now(),
             },

package/dist/core/session/session-turns.js

@@ -1,4 +1,23 @@
-export function extractSessionUserContent(message) {
+import { createHash } from 'node:crypto';
+// These prompts are steered into the active base-agent turn by EvolCore. The
+// Codex history adapter exposes steered input as a regular `user` item, so it
+// must not split the user's actual turn when reconstructing fork anchors.
+const TASK_RECOVERY_PROMPT = '继续当前会话尚未完成的任务。先核对最新用户指令、已有结果和任务状态；若已完成、用户已停止或正在等待必要输入/审批，则不要重复执行。对可能已产生副作用的步骤先核实结果，再继续未完成的工作。';
+function isInternalInjectedUserMessage(message) {
+    const text = extractUserText(message);
+    if (!text)
+        return false;
+    if (text === TASK_RECOVERY_PROMPT)
+        return true;
+    if (text.startsWith('⚠️ 策略拒绝')
+        && text.endsWith('命令未执行，请按提示重新执行正确的命令。'))
+        return true;
+    if (text.startsWith('⚠️ proactive 模式违规：')
+        && text.endsWith('请重新执行正确的命令。'))
+        return true;
+    return false;
+}
+function extractText(message) {
     const value = message;
     let text = '';
     if (typeof value?.content === 'string') {
@@ -10,8 +29,12 @@ export function extractSessionUserContent(message) {
             .map((block) => block.text)
             .join(' ');
     }
-    text = text.trim();
-    text = text.replace(/^【新消息插入】\s*/, '').replace(/\s*【请无视之前中断继续处理】$/, '').trim();
+    return text.trim();
+}
+function extractUserText(message) {
+    let text = extractText(message);
+    text = text.replace(/^【新消息插入】\s*/, '')
+        .replace(/\s*【(?:请无视之前中断继续处理|请根据前后消息酌情处理)】$/, '').trim();
     if (text.startsWith('‹')) {
         const newline = text.indexOf('\n');
         if (newline !== -1)
@@ -27,10 +50,15 @@ export function extractSessionUserContent(message) {
             text = parts.join(' ');
     }
     text = text.replace(/\s+/g, ' ').trim();
-    if (!text)
-        return '';
+    return text;
+}
+export function extractSessionUserContent(message) {
+    const text = extractUserText(message);
     return text.length > 50 ? `${text.slice(0, 50)}…` : text;
 }
+function textHash(text) {
+    return createHash('sha256').update(text.replace(/\s+/g, ' ').trim()).digest('hex');
+}
 function isToolResultMessage(message) {
     const content = message?.content;
     return Array.isArray(content)
@@ -48,19 +76,32 @@ export function buildSessionTurnList(messages) {
             userContent: pending.userContent,
             userUuid: pending.userUuid,
             assistantUuid: pending.assistantUuid,
+            assistantUuids: [...(pending.assistantUuids ?? [])],
+            userTextHash: pending.userTextHash,
+            assistantTextHashes: [...pending.assistantTextHashes],
         });
     };
     for (const message of messages) {
         if (message.type === 'user') {
             if (isToolResultMessage(message.message))
                 continue;
+            if (isInternalInjectedUserMessage(message.message))
+                continue;
             finishPending();
             const userContent = extractSessionUserContent(message.message);
-            pending = userContent ? { userContent, userUuid: message.uuid } : undefined;
+            pending = userContent ? {
+                userContent, userUuid: message.uuid, assistantUuids: [],
+                userTextHash: textHash(extractUserText(message.message)), assistantTextHashes: [],
+            } : undefined;
             continue;
         }
-        if (message.type === 'assistant' && pending)
+        if (message.type === 'assistant' && pending) {
             pending.assistantUuid = message.uuid;
+            pending.assistantUuids.push(message.uuid);
+            const text = extractText(message.message);
+            if (text)
+                pending.assistantTextHashes.push(textHash(text));
+        }
     }
     finishPending();
     return turns;