evolcore 0.0.26 → 0.0.28

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: '当前渠道支持的能力列表',