evolcore 0.0.27 → 0.0.29-test.0

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

@@ -2,14 +2,228 @@ 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 { readRunnerEventSummary } from './runner-event-summary.js';
+import { isInternalInjectedUserMessage, isToolResultMessage } from './session-transcript.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, isArchivedTopicLable, normalizeTopicLable, } from './session-mapper.js';
+import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID, normalizeTopicLabel, normalizeTopicStatus, } from './session-mapper.js';
 import { tryParseChannelKey } from '../channel-loader.js';
 import { isSystemControlChannel } from '../system-channels.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
+import { createHash } from 'node:crypto';
+function forkHistoryRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function isForkHistorySnapshot(value) {
+    const snapshot = forkHistoryRecord(value);
+    if (snapshot?.version !== 1 || typeof snapshot.assistantMessageId !== 'string'
+        || !snapshot.assistantMessageId || !Array.isArray(snapshot.items))
+        return false;
+    return snapshot.items.every((value, index) => {
+        const item = forkHistoryRecord(value);
+        return item?.index === index
+            && typeof item.sourceMessageId === 'string'
+            && (item.role === 'user' || item.role === 'assistant')
+            && ['text', 'tool_call', 'tool_result', 'attachment', 'file_change'].includes(String(item.kind))
+            && typeof item.text === 'string'
+            && (item.tool === undefined || forkHistoryRecord(item.tool) !== undefined);
+    });
+}
+const MAX_FORK_HISTORY_ITEM_TEXT_BYTES = 16 * 1024;
+const MAX_FORK_HISTORY_TOOL_VALUE_BYTES = 8 * 1024;
+const MAX_FORK_HISTORY_PAGE_JSON_BYTES = 128 * 1024;
+function cleanForkHistoryUserText(text) {
+    let cleaned = text.replace(/^【新消息插入】\s*/, '')
+        .replace(/\s*【(?:请无视之前中断继续处理|请根据前后消息酌情处理)】$/, '').trim();
+    if (cleaned.startsWith('‹')) {
+        const newline = cleaned.indexOf('\n');
+        if (newline >= 0)
+            cleaned = cleaned.slice(newline + 1).trim();
+    }
+    if (cleaned.startsWith('<messages>')) {
+        const parts = [...cleaned.matchAll(/<message(?:\s[^>]*)?>([\s\S]*?)<\/message>/g)]
+            .map(match => match[1].trim());
+        if (parts.length > 0)
+            cleaned = parts.join('\n');
+    }
+    return cleaned;
+}
+function splitForkHistoryText(text) {
+    if (Buffer.byteLength(text, 'utf8') <= MAX_FORK_HISTORY_ITEM_TEXT_BYTES)
+        return [text];
+    const chunks = [];
+    let chunk = '';
+    let bytes = 0;
+    for (const character of text) {
+        const characterBytes = Buffer.byteLength(character, 'utf8');
+        if (bytes + characterBytes > MAX_FORK_HISTORY_ITEM_TEXT_BYTES && chunk) {
+            chunks.push(chunk);
+            chunk = '';
+            bytes = 0;
+        }
+        chunk += character;
+        bytes += characterBytes;
+    }
+    if (chunk)
+        chunks.push(chunk);
+    return chunks;
+}
+function projectForkHistoryToolValue(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            return undefined;
+        if (Buffer.byteLength(serialized, 'utf8') <= MAX_FORK_HISTORY_TOOL_VALUE_BYTES) {
+            return JSON.parse(serialized);
+        }
+        let preview = '';
+        let bytes = 0;
+        for (const character of serialized) {
+            const characterBytes = Buffer.byteLength(character, 'utf8');
+            if (bytes + characterBytes > MAX_FORK_HISTORY_TOOL_VALUE_BYTES - 16)
+                break;
+            preview += character;
+            bytes += characterBytes;
+        }
+        return `${preview}... [truncated]`;
+    }
+    catch {
+        return '[unavailable]';
+    }
+}
+function projectForkHistoryContent(content, type) {
+    if (typeof content === 'string') {
+        const text = type === 'user' ? cleanForkHistoryUserText(content) : content.trim();
+        return text ? [{ kind: 'text', text }] : [];
+    }
+    if (!Array.isArray(content))
+        return [];
+    const parts = [];
+    for (const rawBlock of content) {
+        const block = forkHistoryRecord(rawBlock);
+        if (!block)
+            continue;
+        const blockType = typeof block.type === 'string' ? block.type : '';
+        if (blockType === 'text' || blockType === 'input_text' || blockType === 'output_text') {
+            const text = typeof block.text === 'string'
+                ? (type === 'user' ? cleanForkHistoryUserText(block.text) : block.text.trim())
+                : '';
+            if (text)
+                parts.push({ kind: 'text', text });
+        }
+        else if (blockType === 'tool_use') {
+            const name = typeof block.name === 'string' ? block.name : '工具';
+            parts.push({
+                kind: 'tool_call',
+                text: name,
+                tool: {
+                    name,
+                    ...(typeof block.id === 'string' ? { callId: block.id } : {}),
+                    ...(block.input !== undefined ? { arguments: projectForkHistoryToolValue(block.input) } : {}),
+                },
+            });
+        }
+        else if (blockType === 'tool_result') {
+            parts.push({
+                kind: 'tool_result',
+                text: '工具返回结果',
+                tool: {
+                    ...(typeof block.name === 'string' ? { name: block.name } : {}),
+                    ...(typeof block.tool_use_id === 'string' ? { callId: block.tool_use_id } : {}),
+                    ...(block.content !== undefined ? { result: projectForkHistoryToolValue(block.content) } : {}),
+                    ok: block.is_error !== true,
+                },
+            });
+        }
+        else if (blockType === 'image' || blockType === 'localImage' || blockType === 'image_url') {
+            parts.push({ kind: 'attachment', text: '[图片]' });
+        }
+        else if (blockType === 'document' || blockType === 'file') {
+            const name = typeof block.name === 'string' ? block.name : '';
+            parts.push({ kind: 'attachment', text: name ? `[文件] ${name}` : '[文件]' });
+        }
+        else if (blockType === 'file_change') {
+            parts.push({ kind: 'file_change', text: '文件变更' });
+        }
+    }
+    return parts;
+}
+export function buildForkHistorySnapshot(messages, assistantMessageId) {
+    let boundary = -1;
+    for (let index = 0; index < messages.length; index++) {
+        if (messages[index].uuid === assistantMessageId
+            && (messages[index].type === 'assistant'
+                || (messages[index].type === 'user'
+                    && !isInternalInjectedUserMessage(messages[index].message)))) {
+            if (boundary >= 0)
+                throw new Error('fork history anchor is ambiguous');
+            boundary = index;
+        }
+    }
+    if (boundary < 0)
+        throw new Error('fork history anchor is missing');
+    const items = [];
+    for (let sourceIndex = 0; sourceIndex <= boundary; sourceIndex++) {
+        const source = messages[sourceIndex];
+        if (source.type === 'user' && isInternalInjectedUserMessage(source.message))
+            continue;
+        if (source.type !== 'user' && source.type !== 'assistant' && source.type !== 'system')
+            continue;
+        const message = forkHistoryRecord(source.message);
+        const content = message?.content ?? source.message;
+        const toolResult = source.type === 'user' && isToolResultMessage(source.message);
+        const role = source.type === 'user' && !toolResult ? 'user' : 'assistant';
+        const projected = projectForkHistoryContent(content, source.type);
+        for (let partIndex = 0; partIndex < projected.length; partIndex++) {
+            const part = projected[partIndex];
+            if (source.type === 'system' && part.kind !== 'file_change')
+                continue;
+            const chunks = splitForkHistoryText(part.text);
+            for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+                items.push({
+                    index: items.length,
+                    sourceMessageId: `${source.uuid || sourceIndex}:${sourceIndex}:${partIndex}:${chunkIndex}`,
+                    role,
+                    kind: toolResult ? 'tool_result' : part.kind,
+                    text: chunks[chunkIndex],
+                    ...(part.tool ? { tool: part.tool } : {}),
+                });
+            }
+        }
+    }
+    if (items.length === 0)
+        throw new Error('fork history has no displayable messages');
+    return { version: 1, assistantMessageId, items };
+}
+export function pageForkHistory(snapshot, before = snapshot.items.length, limit = 20) {
+    if (!Number.isInteger(before) || before < 1 || before > snapshot.items.length
+        || !Number.isInteger(limit) || limit < 1 || limit > 20) {
+        throw new Error('invalid fork history page');
+    }
+    let start = before;
+    let bytes = 2;
+    while (start > 0 && before - start < limit) {
+        const itemBytes = Buffer.byteLength(JSON.stringify(snapshot.items[start - 1]), 'utf8');
+        const nextBytes = bytes + itemBytes + (start < before ? 1 : 0);
+        if (nextBytes > MAX_FORK_HISTORY_PAGE_JSON_BYTES) {
+            if (start === before)
+                throw new Error('fork history item exceeds page budget');
+            break;
+        }
+        bytes = nextBytes;
+        start--;
+    }
+    return {
+        items: snapshot.items.slice(start, before),
+        nextBefore: start > 0 ? start : null,
+        total: snapshot.items.length,
+    };
+}
 /** Metadata keys owned by ordinary topic/session routing writers. */
 const TOPIC_METADATA_PROTECTED_KEYS = new Set(['turnState', 'resumeAt', 'agentSessions']);
 const TOPIC_BACKEND_SCOPED_KEYS = ['resumeAt', 'agentSessions'];
@@ -292,6 +506,119 @@ export class SessionManager {
         const targetDir = session.threadId ? path.join(dir, '_threads') : dir;
         return this.metaFilePath(targetDir, session.id);
     }
+    forkHistoryPath(session) {
+        if (!session.threadId)
+            throw new Error('fork history requires a topic session');
+        return path.join(this.resolveChatDirFromSession(session), '_threads', `${session.id}.fork-history.json`);
+    }
+    forkHistoryBackupPath(session) {
+        return `${this.forkHistoryPath(session)}.bak`;
+    }
+    forkHistoryText(snapshot, assistantMessageId) {
+        if (!isForkHistorySnapshot(snapshot) || snapshot.items.length === 0
+            || snapshot.assistantMessageId !== assistantMessageId) {
+            throw new Error('invalid fork history snapshot');
+        }
+        return `${JSON.stringify(snapshot)}\n`;
+    }
+    forkHistoryDigest(content) {
+        return createHash('sha256').update(content, 'utf8').digest('hex');
+    }
+    readForkHistory(session) {
+        const source = session.metadata?.forkSource;
+        if (!source?.historyVersion)
+            return undefined;
+        if (source.historyVersion !== 1 || typeof source.historyDigest !== 'string'
+            || !/^[a-f0-9]{64}$/.test(source.historyDigest)
+            || !Number.isInteger(source.historyCount) || source.historyCount < 1) {
+            throw new Error('fork history metadata is invalid');
+        }
+        const primary = this.forkHistoryPath(session);
+        const backup = this.forkHistoryBackupPath(session);
+        const checkedRead = (file) => {
+            const content = fs.readFileSync(file, 'utf8');
+            if (this.forkHistoryDigest(content) !== source.historyDigest) {
+                throw new Error('fork history checksum mismatch');
+            }
+            const snapshot = JSON.parse(content);
+            if (!isForkHistorySnapshot(snapshot) || snapshot.assistantMessageId !== source.assistantMessageId
+                || snapshot.items.length !== source.historyCount) {
+                throw new Error('fork history snapshot is invalid');
+            }
+            return snapshot;
+        };
+        try {
+            return checkedRead(primary);
+        }
+        catch (primaryError) {
+            try {
+                const snapshot = checkedRead(backup);
+                try {
+                    atomicWriteText(primary, fs.readFileSync(backup, 'utf8'));
+                }
+                catch (error) {
+                    logger.warn(`[SessionManager] Failed to repair fork history primary: ${error}`);
+                }
+                return snapshot;
+            }
+            catch {
+                throw primaryError;
+            }
+        }
+    }
+    async attachForkHistory(sessionId, snapshot) {
+        const loaded = this.loadSessionForUpdate(sessionId);
+        const session = loaded?.current;
+        const source = session?.metadata?.forkSource;
+        if (!session?.threadId || !source)
+            throw new Error('fork topic is missing');
+        if (source.historyVersion) {
+            this.readForkHistory(session);
+            return session;
+        }
+        const file = this.forkHistoryPath(session);
+        const backup = this.forkHistoryBackupPath(session);
+        let content;
+        let validFile;
+        let recovered;
+        for (const candidate of [file, backup]) {
+            try {
+                const existingContent = fs.readFileSync(candidate, 'utf8');
+                const existing = JSON.parse(existingContent);
+                if (!isForkHistorySnapshot(existing) || existing.items.length === 0
+                    || existing.assistantMessageId !== source.assistantMessageId)
+                    continue;
+                content = existingContent;
+                recovered = existing;
+                validFile = candidate;
+                break;
+            }
+            catch {
+                // Try the other copy or a projected legacy transcript.
+            }
+        }
+        if (!content || !recovered) {
+            if (!snapshot)
+                return undefined;
+            content = this.forkHistoryText(snapshot, source.assistantMessageId);
+            recovered = snapshot;
+        }
+        if (validFile !== file)
+            atomicWriteText(file, content);
+        if (validFile !== backup)
+            atomicWriteText(backup, content);
+        session.metadata = {
+            ...session.metadata,
+            forkSource: {
+                ...source,
+                historyVersion: 1,
+                historyCount: recovered.items.length,
+                historyDigest: this.forkHistoryDigest(content),
+            },
+        };
+        this.persistSession(session, 'none');
+        return session;
+    }
     appendMeta(channel, channelId, session) {
         const file = sessionToFile(session);
         const metaPath = this.metaPathForSession(session);
@@ -332,9 +659,10 @@ 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;
+                if (!opts?.topicMutation) {
+                    session.label = latest.label;
+                    session.topicStatus = latest.topicStatus;
+                }
                 // 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.
@@ -349,6 +677,9 @@ export class SessionManager {
                             : { turnState: undefined })
                         : {}),
                 };
+                if (latest.metadata?.forkSource?.historyVersion === 1) {
+                    mergedMetadata.forkSource = JSON.parse(JSON.stringify(latest.metadata.forkSource));
+                }
                 for (const key of TOPIC_BACKEND_SCOPED_KEYS) {
                     if (Object.prototype.hasOwnProperty.call(latest.metadata ?? {}, key)) {
                         const value = latest.metadata[key];
@@ -445,6 +776,12 @@ export class SessionManager {
         this.persistSession(session, 'sync');
         return undefined;
     }
+    hasBoundAgentSession(session) {
+        if (!session.agentSessionId)
+            return false;
+        const adapter = this.getFileAdapter(session.baseagent);
+        return !!adapter?.checkExists(session.projectPath, session.agentSessionId, session.selfAID);
+    }
     getActiveChatType(channel, channelId) {
         const active = this.readActive(channel, channelId);
         if (active && !active.threadId)
@@ -550,6 +887,69 @@ export class SessionManager {
             throw error;
         }
     }
+    assertTopicResumeMutationTarget(current, input) {
+        if (!current.threadId || current.threadId !== input.expectedThreadId) {
+            const error = new Error('topic resumeAt threadId mismatch');
+            error.code = 'THREAD_MISMATCH';
+            throw error;
+        }
+        if (input.expectedAgentSessionId !== undefined
+            && normalizeBackendSessionId(current.agentSessionId) !== normalizeBackendSessionId(input.expectedAgentSessionId)) {
+            const error = new Error('topic resumeAt backend mismatch');
+            error.code = 'BACKEND_MISMATCH';
+            throw error;
+        }
+    }
+    /** Persist a pending Claude-style topic rewind anchor without generic metadata writers. */
+    async setTopicResumeAt(input) {
+        const resumeAt = input.resumeAt.trim();
+        if (!input.expectedThreadId.trim())
+            throw new Error('topic resumeAt requires a non-empty threadId');
+        if (!resumeAt)
+            throw new Error('topic resumeAt requires a non-empty anchor');
+        this.mutateLatestTopicSession(input.sessionId, (current, found) => {
+            this.assertTopicResumeMutationTarget(current, input);
+            const next = JSON.parse(JSON.stringify(current));
+            next.metadata = { ...(next.metadata ?? {}), resumeAt };
+            this.persistConfirmedTopicBoundary(current, found, next);
+        });
+    }
+    /** Clear a pending topic rewind anchor after provider rollback or backend rotation. */
+    async clearTopicResumeAt(input) {
+        if (!input.expectedThreadId.trim())
+            throw new Error('topic resumeAt requires a non-empty threadId');
+        this.mutateLatestTopicSession(input.sessionId, (current, found) => {
+            this.assertTopicResumeMutationTarget(current, input);
+            if (!current.metadata || !Object.prototype.hasOwnProperty.call(current.metadata, 'resumeAt'))
+                return;
+            const next = JSON.parse(JSON.stringify(current));
+            const metadata = { ...(next.metadata ?? {}) };
+            delete metadata.resumeAt;
+            next.metadata = metadata;
+            this.persistConfirmedTopicBoundary(current, found, next);
+        });
+    }
+    /** Atomically consume a topic rewind anchor for the matching backend turn. */
+    async consumeTopicResumeAt(input) {
+        if (!input.expectedThreadId.trim())
+            throw new Error('topic resumeAt requires a non-empty threadId');
+        return this.mutateLatestTopicSession(input.sessionId, (current, found) => {
+            this.assertTopicResumeMutationTarget(current, input);
+            const resumeAt = typeof current.metadata?.resumeAt === 'string'
+                ? current.metadata.resumeAt.trim()
+                : '';
+            if (!resumeAt)
+                return undefined;
+            if (input.expectedResumeAt !== undefined && resumeAt !== input.expectedResumeAt.trim())
+                return undefined;
+            const next = JSON.parse(JSON.stringify(current));
+            const metadata = { ...(next.metadata ?? {}) };
+            delete metadata.resumeAt;
+            next.metadata = metadata;
+            this.persistConfirmedTopicBoundary(current, found, next);
+            return resumeAt;
+        });
+    }
     /** Clear a topic binding in one short latest-snapshot mutation. */
     async rotateTopicBackend(input) {
         if (!input.expectedThreadId.trim())
@@ -730,7 +1130,7 @@ export class SessionManager {
         return result;
     }
     // ─── Session lifecycle ───
-    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, baseagent, selfAID, channelType, peerType, identity, lable) {
+    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, baseagent, selfAID, channelType, peerType, identity, label, topicStatus) {
         if (isSystemControlChannel(channel) || isSystemControlChannel(channelType)) {
             throw new Error(`[SessionManager] system control channel is sessionless. channel="${channel}"`);
         }
@@ -744,7 +1144,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, lable);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType, label, topicStatus);
             session.identity = identity ?? this.resolveIdentity(channel, userId, chatType, identityConversationId);
             return session;
         }
@@ -965,7 +1365,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, lable) {
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, baseagent, selfAID, channelType, peerType, chatType, label, topicStatus) {
         // 使用精确路径（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; })()
@@ -1028,7 +1428,8 @@ export class SessionManager {
             chatType: effectiveChatType,
             metadata,
             name: name || '话题会话',
-            lable: normalizeTopicLable(lable),
+            label: normalizeTopicLabel(label),
+            topicStatus: topicStatus ? normalizeTopicStatus(topicStatus) : 'pending',
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
@@ -1307,7 +1708,7 @@ export class SessionManager {
                 return true;
             if (!session.threadId)
                 return archiveFilter !== 'archived';
-            const archived = isArchivedTopicLable(session.lable);
+            const archived = session.topicStatus === 'archived';
             return archiveFilter === 'archived' ? archived : !archived;
         });
         return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
@@ -1376,13 +1777,22 @@ export class SessionManager {
         this.persistSession(current, 'sync');
         return true;
     }
-    async setTopicLable(sessionId, lable) {
-        const normalized = normalizeTopicLable(lable);
+    async setTopicLabel(sessionId, label) {
+        const normalized = normalizeTopicLabel(label);
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded?.current.threadId)
+            return false;
+        loaded.current.label = normalized;
+        this.persistSession(loaded.current, 'sync', { topicMutation: true });
+        return true;
+    }
+    async setTopicStatus(sessionId, status) {
+        const normalized = normalizeTopicStatus(status);
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded?.current.threadId)
             return false;
-        loaded.current.lable = normalized;
-        this.persistSession(loaded.current, 'sync', { lableMutation: true });
+        loaded.current.topicStatus = normalized;
+        this.persistSession(loaded.current, 'sync', { topicMutation: true });
         return true;
     }
     async unbindSession(sessionId) {
@@ -1401,6 +1811,17 @@ export class SessionManager {
         }
         // If thread session, remove from thread-index
         if (found.isThread) {
+            for (const suffix of ['.fork-history.json', '.fork-history.json.bak', '.fork-history.json.tmp']) {
+                const historyFile = path.join(found.chatDir, '_threads', `${sessionId}${suffix}`);
+                const historyTrash = path.join(trashDir, `${sessionId}${suffix}`);
+                try {
+                    fs.renameSync(historyFile, historyTrash);
+                }
+                catch (e) {
+                    if (e.code !== 'ENOENT')
+                        logger.warn(`[SessionManager] Failed to move fork history to trash: ${e}`);
+                }
+            }
             const threadIndex = readThreadIndex(found.chatDir);
             for (const [tid, entry] of Object.entries(threadIndex)) {
                 if (entry.sessionId === sessionId) {
@@ -1454,6 +1875,19 @@ export class SessionManager {
                         throw e;
                 }
             }
+            if (fs.existsSync(threadsDir)) {
+                for (const file of fs.readdirSync(threadsDir).filter(name => /\.fork-history\.json(?:\.bak|\.tmp)?$/.test(name))) {
+                    const src = path.join(threadsDir, file);
+                    const dst = path.join(trashDir, file);
+                    try {
+                        fs.renameSync(src, dst);
+                    }
+                    catch (e) {
+                        if (e.code !== 'ENOENT')
+                            throw e;
+                    }
+                }
+            }
             // Clear active.json
             const activePath = path.join(dirPath, 'active.json');
             try {
@@ -1501,6 +1935,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,
@@ -1589,6 +2027,8 @@ export class SessionManager {
         const threadIndex = readThreadIndex(chatDir);
         if (threadIndex[targetThreadId])
             throw new Error('target thread already exists');
+        const historyContent = this.forkHistoryText(options.historySnapshot, options.sourceAssistantMessageId);
+        const historyDigest = this.forkHistoryDigest(historyContent);
         const now = Date.now();
         const sessionKey = formatSessionKey(channelType, sourceSession.channelId, targetThreadId);
         const sourceMetadata = sourceSession.metadata || {};
@@ -1602,9 +2042,14 @@ export class SessionManager {
                 sessionId: sourceSession.id,
                 threadId: sourceSession.threadId || null,
                 assistantMessageId: options.sourceAssistantMessageId,
+                ...(options.requestedSourceAssistantMessageId
+                    ? { requestedAssistantMessageId: options.requestedSourceAssistantMessageId } : {}),
                 turn: options.sourceTurn,
                 name: sourceSession.name || null,
                 createdAt: now,
+                historyVersion: 1,
+                historyCount: options.historySnapshot.items.length,
+                historyDigest,
                 ...(options.requestId ? { requestId: options.requestId } : {}),
             },
         };
@@ -1622,12 +2067,17 @@ export class SessionManager {
             agentSessionId: forkedAgentSessionId,
             metadata,
             name: options.name || `${sourceSession.name || '会话'} · 第 ${options.sourceTurn} 轮`,
-            lable: normalizeTopicLable(options.lable === undefined ? sourceSession.lable : options.lable),
+            label: normalizeTopicLabel(options.label === undefined ? sourceSession.label : options.label),
+            topicStatus: options.topicStatus ? normalizeTopicStatus(options.topicStatus) : 'pending',
             createdAt: now,
             updatedAt: now,
         };
-        this.persistSession(session, 'none');
+        const historyFile = this.forkHistoryPath(session);
+        const historyBackup = this.forkHistoryBackupPath(session);
         try {
+            atomicWriteText(historyFile, historyContent);
+            atomicWriteText(historyBackup, historyContent);
+            this.persistSession(session, 'none');
             threadIndex[targetThreadId] = {
                 sessionId: session.id,
                 sessionKey,
@@ -1640,6 +2090,14 @@ export class SessionManager {
                 fs.unlinkSync(this.metaPathForSession(session));
             }
             catch { }
+            try {
+                fs.unlinkSync(historyFile);
+            }
+            catch { }
+            try {
+                fs.unlinkSync(historyBackup);
+            }
+            catch { }
             throw error;
         }
         this.eventBus.publish({
@@ -1696,6 +2154,13 @@ export class SessionManager {
             cause: 'renew',
             sourceSessionId: sourceSession.id,
             renewSource: context?.source,
+            // 渠道快照：供记忆整理触发用（不依赖旧会话是否还有活动 taskCtx）
+            sourceChannel: sourceSession.channelType || sourceSession.channel,
+            sourceChannelId: sourceSession.channelId,
+            sourceChatType: sourceSession.chatType,
+            sourceThreadId: sourceSession.threadId,
+            sourceSelfAid: sourceSession.selfAID,
+            sourcePeerId: sourceSession.metadata?.peerId,
             timestamp: Date.now(),
             causation: context?.causation,
         });
@@ -1766,7 +2231,7 @@ export class SessionManager {
         return adapter.getFileInfo(projectPath, agentSessionId, agentAid);
     }
     getRunnerTaskHistory(sessionId) {
-        return readRunnerTaskHistory(resolvePaths().logs, sessionId);
+        return readRunnerEventSummary(resolvePaths().logs, sessionId);
     }
     async listSdkSessions(projectPath, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);