evolcore 0.0.26 → 0.0.27

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)
@@ -1598,6 +1622,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 +1765,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;

package/dist/core/task/task-recovery-service.js

@@ -0,0 +1,176 @@
+import { replyContextFromSession } from '../message/message-utils.js';
+export const TASK_RECOVERY_PROMPT = '继续当前会话尚未完成的任务。先核对最新用户指令、已有结果和任务状态；若已完成、用户已停止或正在等待必要输入/审批，则不要重复执行。对可能已产生副作用的步骤先核实结果，再继续未完成的工作。';
+function lastTask(state) {
+    return state?.active ?? state?.lastTerminal;
+}
+function sameRecoveryRun(previous, requested) {
+    return !!previous && !!requested
+        && previous.triggerId === requested.triggerId && previous.runId === requested.runId
+        && previous.taskId === requested.taskId && previous.generation === requested.generation;
+}
+function canRecover(session, automatic, origin) {
+    const state = session.metadata?.turnState;
+    const task = lastTask(state);
+    if (!task)
+        return !automatic && !!session.processingState;
+    if (task.status === 'committed' || task.status === 'waiting_interaction')
+        return false;
+    if (state?.active?.interactions.some(item => !item.settlement))
+        return false;
+    const context = task.recoveryContext;
+    if ((context?.baseagent && context.baseagent !== session.baseagent)
+        || (context?.agentSessionId && context.agentSessionId !== session.agentSessionId))
+        return false;
+    const reason = 'cancelReason' in task ? task.cancelReason : 'reason' in task ? task.reason : undefined;
+    if (reason && /interaction|approval|permission|denied|recalled|new_message|empty_prompt/i.test(reason))
+        return false;
+    if (task.status === 'cancelled' || task.status === 'superseded' || reason === 'stop' || reason === 'explicit_cancel') {
+        return !automatic && (reason === 'stop' || reason === 'explicit_cancel');
+    }
+    if (!automatic)
+        return true;
+    if (state?.active)
+        return false;
+    return !context?.originTriggerId || sameRecoveryRun(context.recovery, origin);
+}
+/** Check again at dequeue: a newer task, /stop, /renew or backend switch wins. */
+export function isTaskRecoveryCurrent(session, recovery) {
+    const state = session.metadata?.turnState;
+    return !session.deletedAt
+        && session.agentSessionId === recovery.agentSessionId
+        && session.baseagent === recovery.baseagent
+        && (state?.generation ?? 0) === recovery.generation
+        && lastTask(state)?.taskId === recovery.taskId
+        && canRecover(session, recovery.automatic, recovery.origin);
+}
+export class TaskRecoveryService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async resume(request) {
+        const result = (status, message, ok = true) => ({
+            ok, status, sessionId: request.sessionId, message,
+        });
+        return this.deps.queue.withSessionBarrier(request.sessionId, async () => {
+            if (request.signal?.aborted)
+                return result('not_recoverable', '恢复请求已取消', false);
+            if (request.automatic && (!request.expectedTaskId || !Number.isSafeInteger(request.expectedGeneration))) {
+                return result('not_recoverable', '自动恢复必须指定原任务及其版本', false);
+            }
+            const session = await this.deps.sessions.getSessionById(request.sessionId);
+            if (!session || session.deletedAt || (request.agentAid && session.selfAID !== request.agentAid)) {
+                return result('not_found', '目标会话不存在或不属于当前 Agent', false);
+            }
+            const state = session.metadata?.turnState;
+            const task = lastTask(state);
+            const trigger = request.message?.triggerMeta;
+            const origin = request.automatic && trigger
+                && typeof trigger.runId === 'string' && typeof trigger.attemptId === 'string'
+                && request.expectedTaskId && request.expectedGeneration !== undefined
+                ? { taskId: request.expectedTaskId, generation: request.expectedGeneration,
+                    triggerId: trigger.triggerId, runId: trigger.runId, attemptId: trigger.attemptId }
+                : undefined;
+            const retry = sameRecoveryRun(task?.recoveryContext?.recovery, origin);
+            if (!retry && ((request.expectedTaskId !== undefined && task?.taskId !== request.expectedTaskId)
+                || (request.expectedGeneration !== undefined && task?.generation !== request.expectedGeneration))) {
+                return result('stale', '原任务状态已变化，已忽略过期恢复请求');
+            }
+            if (retry && task?.recoveryContext?.recovery?.attemptId === origin?.attemptId) {
+                return result('stale', '该恢复 attempt 已执行，已忽略重复请求');
+            }
+            if (state?.active?.status === 'waiting_interaction'
+                || state?.active?.interactions.some(item => !item.settlement)) {
+                return result('waiting_interaction', '任务正在等待必要输入或审批，请先完成交互');
+            }
+            let runner;
+            try {
+                runner = this.deps.getRunner(session);
+            }
+            catch {
+                return result('not_recoverable', '原 baseagent 当前不可用', false);
+            }
+            if (!request.automatic && this.deps.resumePause(session.id)) {
+                return result('resumed_pause', '✓ 已继续暂停的任务');
+            }
+            // Other gate holders may have captured an older cutoff. Recovery must
+            // see messages admitted during the session-store read as well.
+            const snapshot = this.deps.queue.getSessionSnapshot(session.id);
+            // task:error is published before queue cleanup. Only the exact durable
+            // failed task may queue its successor while that batch is winding down.
+            const finishingFailedTask = request.automatic && !!request.expectedTaskId
+                && !state?.active && state?.lastTerminal?.status === 'failed'
+                && !snapshot.dispatching
+                && snapshot.activeTaskIds.length > 0 && snapshot.activeTaskIds.every(id => id === task?.taskId);
+            if (snapshot.prequeue || snapshot.queued || ((snapshot.active || snapshot.dispatching
+                || runner.hasActiveStream(session.id)) && !finishingFailedTask)) {
+                return result('already_running', '任务正在执行或已有待处理消息，无需重复恢复');
+            }
+            if (task?.status === 'committed')
+                return result('completed', '上一任务已正常完成，无需恢复');
+            if (!canRecover(session, request.automatic === true, origin)) {
+                return result('not_recoverable', '当前没有可恢复的异常任务', false);
+            }
+            if (!runner.capabilities?.taskRecovery || !session.agentSessionId) {
+                return result('not_recoverable', '原 baseagent 会话不可恢复；不会创建替代会话', false);
+            }
+            if (runner.resolveSessionFile && !runner.resolveSessionFile(session.agentSessionId, session.projectPath)) {
+                return result('not_recoverable', '原 baseagent 会话文件不存在；不会创建替代会话', false);
+            }
+            if (!this.deps.hasChannel(session))
+                return result('not_recoverable', '原会话渠道当前不可用', false);
+            const context = task?.recoveryContext;
+            const peerId = context?.peerId || request.peerId || session.metadata?.peerId;
+            const peerName = session.metadata?.peerName;
+            const peerType = session.metadata?.peerType;
+            const channelType = session.channelType || session.channel.split('#')[0];
+            const encrypted = context?.encrypted ?? request.encrypted;
+            if (!peerId || (channelType === 'aun' && typeof encrypted !== 'boolean')) {
+                return result('not_recoverable', '缺少原任务身份或加密状态，无法安全恢复', false);
+            }
+            const recovery = {
+                generation: state?.generation ?? 0, taskId: task?.taskId,
+                agentSessionId: session.agentSessionId, baseagent: session.baseagent,
+                automatic: request.automatic === true,
+                origin,
+            };
+            const replyContext = replyContextFromSession(session);
+            const message = {
+                ...request.message,
+                ...(trigger ? { triggerMeta: {
+                        ...trigger,
+                        originPeerId: peerId,
+                        originChannelKey: session.metadata?.channelKey || session.channel,
+                        originChannelType: channelType,
+                        originChatType: session.chatType === 'group' ? 'group' : 'private',
+                        originConversationId: session.channelId,
+                        originControl: false,
+                    } } : {}),
+                channel: session.metadata?.channelKey || session.channel,
+                channelType, channelId: session.channelId, selfAID: session.selfAID,
+                baseagent: session.baseagent, threadId: session.threadId,
+                chatType: session.chatType === 'group' ? 'group' : 'private',
+                groupId: session.chatType === 'group' ? session.metadata?.groupId || session.channelId : undefined,
+                peerId, peerName, peerType,
+                encrypted, content: TASK_RECOVERY_PROMPT,
+                source: request.message?.source ?? 'recovery',
+                messageId: request.message?.messageId ?? `recovery:${session.id}:${recovery.generation}:${task?.taskId ?? session.processingState}`,
+                timestamp: Date.now(), boundSessionId: session.id, taskRecovery: recovery,
+                replyContext: { ...replyContext, metadata: { ...replyContext?.metadata, encrypted } },
+            };
+            // Keep the completion promise alive for Trigger cancellation, but release
+            // the dequeue gate as soon as admission is durable (never await the run).
+            let admitted;
+            const persisted = new Promise(resolve => { admitted = resolve; });
+            const completion = this.deps.queue.enqueue(session.id, message, session.projectPath, {
+                interruptible: false, onPersisted: admitted, selfAID: session.selfAID,
+                agentName: session.selfAID, sessionKeyField: session.sessionKey, signal: request.signal,
+            });
+            await Promise.race([persisted, completion]);
+            // Manual callers need only the acknowledgement. Trigger callers retain
+            // completion to observe failure and wait for the interrupt barrier.
+            void completion.catch(() => { });
+            return { ...result('queued_recovery', '✓ 已排入恢复队列，将继续原 baseagent 会话'), completion };
+        });
+    }
+}

package/dist/core/task/task-resume-operation.js

@@ -0,0 +1,32 @@
+/** IPC has authenticated the transport; this enforces the Agent/task boundary. */
+export async function executeTaskResume(request, deps) {
+    const authorization = request.sessionId
+        ? await deps.authorizeManaged({
+            sessionId: request.sessionId,
+            delegationToken: request.delegationToken,
+            delegationCommandHash: request.delegationCommandHash,
+        }, 'ec.task.resume')
+        : undefined;
+    if (authorization && !authorization.ok)
+        return authorization;
+    if (!authorization && !request.localControl) {
+        return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
+    }
+    if (authorization && !authorization.management && authorization.dataScope !== 'daemon') {
+        return { ok: false, code: 'NOT_ALLOWED', error: 'task resume requires Agent management authority' };
+    }
+    const target = await deps.sessions.getSessionById(request.targetSessionId);
+    if (!target || target.deletedAt || !target.selfAID) {
+        return { ok: false, code: 'SESSION_NOT_FOUND', error: 'target Agent session not found' };
+    }
+    if (authorization && authorization.dataScope !== 'daemon' && target.selfAID !== authorization.aid) {
+        return { ok: false, code: 'SCOPE_MISMATCH', error: 'only sessions of the current Agent can be resumed' };
+    }
+    // Identity, encryption, task version and backend binding are read from the
+    // target's durable state. None may be overridden by the CLI payload.
+    const { completion: _completion, ...result } = await deps.recover({
+        sessionId: target.id,
+        agentAid: target.selfAID,
+    });
+    return result;
+}

package/dist/eck/group-rules-sync.js

@@ -2,10 +2,10 @@ import fs from 'fs';
 import path from 'path';
 import { TextDecoder } from 'util';
 import { getAidStore, isValidAid, loadClient, SLOT } from '../aun/aid/index.js';
-import { downloadGroupFsBytes, GroupFsDownloadError } from '../aun/group-fs-download.js';
-import { checkGroupIndex as checkGroupIndexRpc, getGroupIndex as getGroupIndexRpc } from '../aun/msg/group-index.js';
+import { downloadGroupFsBytes, GroupFsDownloadError, checkGroupIndex as checkGroupIndexRpc, getGroupIndex as getGroupIndexRpc, } from '../aun/group/index.js';
 import { agentRelationsDir } from '../paths.js';
 import { formatPeerKey } from '../core/relation/peer-identity.js';
+import { syncRelationSharedFile } from '../core/relation/shared-data.js';
 import { atomicWriteBytes } from '../utils/atomic-write.js';
 import { logger } from '../utils/logger.js';
 import { invalidateKitCache } from './kit-renderer.js';
@@ -23,8 +23,10 @@ export async function syncGroupRulesContext(opts) {
     const group = lazyGroupClient(selfAid);
     try {
         const resolved = await resolveGroupRules(group.client, groupId, paths.localRulesPath);
-        if (resolved.changed)
+        if (resolved.changed) {
+            syncRelationSharedFile(selfAid, paths.peerKey, RULES_LOCAL_PATH);
             invalidateKitCache();
+        }
         return {
             groupRulesPath: resolved.usable ? paths.localRulesPath : undefined,
             groupRulesStatus: resolved.status,

package/dist/eck/kit-renderer.js

@@ -228,6 +228,7 @@ const PARAM_DESCRIPTIONS = {
     channel: '渠道类型（aun/feishu/wechat/dingtalk/qqbot/wecom）',
     venueUid: '场所唯一标识（预留）',
     mentionMode: '群 @ 处理模式（mention-only=被@才响应 / disabled=所有消息都响应）',
+    groupHistoryAvailable: '本地群历史读取能力是否可用',
     clientType: '客户端类型（desktop/web/mobile）',
     permissionMode: '权限模式（readonly/auto/request/bypass；旧值会安全迁移）',
     capabilities: '当前渠道支持的能力列表',