evolcore 0.0.39 → 0.0.40

package/dist/core/memory/relation-sweep.js

@@ -0,0 +1,206 @@
+/**
+ * relation-sweep.ts — 关系整理链
+ *
+ * 一个关系空闲 / 兜底到期后，对它依次跑：
+ *
+ *   notes → generalize → promote（仅 owner 关系）→ profile → forget（关系层）
+ *
+ * 每一步在上一步收尾之后才判定要不要做（notes 新产出的 to-generalize 要被第 2 步看到），
+ * 没有候选的步骤跳过，一个候选都没有就一个会话都不起。所有步骤走同一个整理队列，同 agent 串行。
+ * 触发来源记为 `relation-idle`，静默不反馈。
+ *
+ * 链中途收到新入站不中断：兜底本就发生在聊天进行中，主会话只写 pending，链写 consolidated。
+ *
+ * 群聊 notes 会按发言人用 `--peer` 把记忆写进发言人自己的关系。那些关系不一定有入站
+ * （发言人从不私聊），所以链结束时把它们交给 onSweepFinished 的 touchedPeerKeys，
+ * 由调用方各自补一轮整理（不再继续传播）。
+ */
+import { logger } from '../../utils/logger.js';
+import { RELATION_SWEEP_ORDER, isRelationModeDue } from './consolidation-trigger.js';
+/** 单步整理会话迟迟不收尾时，链最多等这么久就放弃（整理会话自身 15 分钟超时，留余量）。 */
+const DEFAULT_STEP_WATCHDOG_MS = 30 * 60_000;
+/**
+ * 写进会话 metadata 的 relationSweepId 带上步骤序号：`<链 id>#<步骤序号>`。
+ * 看门狗放弃的那一步，会话之后才收尾时，回调里的序号对不上当前步骤，直接忽略，
+ * 不会被误认成下一步的收尾而让链提前推进。
+ */
+function stepTag(sweepId, step) {
+    return `${sweepId}#${step}`;
+}
+function parseStepTag(tag) {
+    const idx = tag.lastIndexOf('#');
+    if (idx <= 0)
+        return undefined;
+    const step = Number(tag.slice(idx + 1));
+    if (!Number.isInteger(step))
+        return undefined;
+    return { sweepId: tag.slice(0, idx), step };
+}
+let sweepSeq = 0;
+export class RelationSweepRunner {
+    deps;
+    sweeps = new Map();
+    isModeDue;
+    stepWatchdogMs;
+    constructor(deps) {
+        this.deps = deps;
+        this.isModeDue = deps.isModeDue ?? isRelationModeDue;
+        this.stepWatchdogMs = deps.stepWatchdogMs ?? DEFAULT_STEP_WATCHDOG_MS;
+    }
+    /** 开始一条整理链。保证之后恰好调用一次 onSweepFinished。 */
+    start(request) {
+        const id = `sweep-${Date.now().toString(36)}-${(++sweepSeq).toString(36)}`;
+        const state = {
+            id,
+            request,
+            remaining: [...RELATION_SWEEP_ORDER],
+            ran: [],
+            touched: new Set(),
+            step: 0,
+        };
+        this.sweeps.set(id, state);
+        void this.deps.resolveOwner(request.selfAid)
+            .catch(() => undefined)
+            .then(ownerAid => {
+            state.ownerAid = ownerAid;
+            return this.advance(state);
+        });
+    }
+    /** 整理会话收尾回调（来自 finalizer 的 onSessionFinalized）。 */
+    onSessionFinalized(info) {
+        const state = this.currentStep(info.relationSweepId, info.sessionId);
+        if (!state)
+            return;
+        if (state.request.propagate) {
+            for (const peerKey of info.touchedPeerKeys) {
+                if (peerKey !== state.request.peerKey)
+                    state.touched.add(peerKey);
+            }
+        }
+        this.stepDone(state);
+    }
+    /** 排队后拉起失败的通知（来自 ConsolidationQueue.setLaunchFailedListener）。 */
+    onLaunchFailed(params) {
+        const state = this.currentStep(params.relationSweepId);
+        if (!state)
+            return;
+        this.stepDone(state);
+    }
+    /** 回调对应的是某条链**正在等的那一步**时返回该链；过期步骤、无关会话返回 undefined。 */
+    currentStep(tag, sessionId) {
+        if (tag) {
+            const parsed = parseStepTag(tag);
+            if (!parsed)
+                return undefined;
+            const state = this.sweeps.get(parsed.sweepId);
+            if (!state || !state.waiting || state.step !== parsed.step)
+                return undefined;
+            return state;
+        }
+        // 收尾时读不到会话 metadata（会话记录已丢失）：按会话 ID 认领
+        if (!sessionId)
+            return undefined;
+        for (const state of this.sweeps.values()) {
+            if (state.waiting && state.waitingSessionId === sessionId)
+                return state;
+        }
+        return undefined;
+    }
+    /** 测试与诊断用：在跑的链数量。 */
+    get activeCount() {
+        return this.sweeps.size;
+    }
+    stepDone(state) {
+        if (state.watchdog)
+            clearTimeout(state.watchdog);
+        state.watchdog = undefined;
+        state.waiting = undefined;
+        state.waitingSessionId = undefined;
+        void this.advance(state);
+    }
+    async advance(state) {
+        const { selfAid, peerKey, route } = state.request;
+        while (state.remaining.length > 0) {
+            const mode = state.remaining.shift();
+            const agent = this.deps.getAgent(selfAid);
+            const memoryConfig = agent?.config?.memory;
+            let due = false;
+            try {
+                due = this.isModeDue({ mode, selfAid, peerKey, ownerAid: state.ownerAid, config: memoryConfig });
+            }
+            catch (error) {
+                logger.warn(`[Memory] 关系整理链判定失败（peerKey=${peerKey}，mode=${mode}）: ${error?.message}`);
+            }
+            if (!due)
+                continue;
+            if (!agent?.baseagent)
+                break;
+            const taskCtx = {
+                selfAid,
+                peerKey,
+                baseagent: agent.baseagent,
+                ...(route ? {
+                    channel: route.channel,
+                    channelId: route.channelId,
+                    peerId: route.peerId,
+                    chatType: route.chatType,
+                    ...(route.channelKey ? { channelKey: route.channelKey } : {}),
+                    ...(route.threadId ? { threadId: route.threadId } : {}),
+                } : {}),
+            };
+            // 先挂上等待标记再入队：会话可能在 enqueue 返回前就收尾，收尾回调要能认出这一步
+            const token = ++state.step;
+            state.waiting = mode;
+            let launched = null;
+            try {
+                launched = await this.deps.enqueue({
+                    taskCtx,
+                    mode,
+                    triggeredBy: 'relation-idle',
+                    ownerAid: state.ownerAid,
+                    forgetAfterDays: memoryConfig?.forgetAfterDays,
+                    ...(mode === 'forget' ? { scopeOverride: 'relation' } : {}),
+                    relationSweepId: stepTag(state.id, token),
+                });
+            }
+            catch (error) {
+                logger.warn(`[Memory] 关系整理链入队失败（peerKey=${peerKey}，mode=${mode}）: ${error?.message}`);
+            }
+            if (state.step !== token || state.waiting !== mode) {
+                // enqueue 返回前这一步已经收尾，后续由那次 stepDone 推进
+                if (launched)
+                    state.ran.push(mode);
+                return;
+            }
+            if (!launched) {
+                // 立即拉起失败：这一步作废，继续下一步
+                state.waiting = undefined;
+                continue;
+            }
+            state.ran.push(mode);
+            if (launched.executionSessionId)
+                state.waitingSessionId = launched.executionSessionId;
+            state.watchdog = setTimeout(() => {
+                logger.warn(`[Memory] 关系整理链等待收尾超时，跳过该步（peerKey=${peerKey}，mode=${mode}）`);
+                this.stepDone(state);
+            }, this.stepWatchdogMs);
+            state.watchdog.unref?.();
+            return;
+        }
+        this.finish(state);
+    }
+    finish(state) {
+        if (!this.sweeps.delete(state.id))
+            return;
+        const { selfAid, peerKey } = state.request;
+        if (state.ran.length > 0) {
+            logger.info(`[Memory] 关系整理链结束（aid=${selfAid}，peerKey=${peerKey}）：${state.ran.join(' → ')}`);
+        }
+        try {
+            this.deps.onSweepFinished({ selfAid, peerKey, ran: state.ran, touchedPeerKeys: [...state.touched] });
+        }
+        catch (error) {
+            logger.warn(`[Memory] 关系整理链结束回调失败（peerKey=${peerKey}）: ${error?.message}`);
+        }
+    }
+}

package/dist/core/message/aun-ipc-sender.js

@@ -15,6 +15,7 @@ import { resolveThreadRouteTarget } from '../thread/thread-route.js';
 import { isTopicThreadId, parseMainTopicId, safeFormatMainTopicId, sessionLocalTopicId } from '../thread/topic-id.js';
 import { ThreadService } from '../thread/thread-service.js';
 import { getAunRequestRegistry, requestTtlSeconds } from './aun-request-registry.js';
+const TASK_ID_MESSAGE_PAYLOAD_TYPES = new Set(['text', 'link', 'image', 'video', 'voice', 'file']);
 /** payload.debug 只是诊断字段：取不到时照常发送，不带 debug。 */
 async function resolveOutboundDebug(resolver, sessionId) {
     if (!resolver || !sessionId)
@@ -408,6 +409,10 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         if (!payload) {
             return { ok: false, error: 'message payload is required', code: 'INVALID_PAYLOAD' };
         }
+        if (params.rawPayload !== true && runtime?.taskId
+            && typeof payload.type === 'string' && TASK_ID_MESSAGE_PAYLOAD_TYPES.has(payload.type)) {
+            payload = { ...payload, task_id: runtime.taskId };
+        }
         // 托管 argv 通道（runManagedSend）先前不带 log 元数据：群聊 sendDaemonGroupMsg
         // 自身会写日志，私聊 sendDaemonMsg 只在 args.log 存在时才写，于是同一份
         // `ec msg send` 在私聊下不落 messages.jsonl，话题历史里查不到已发出的消息。

package/dist/core/message/message-bridge.js

@@ -19,7 +19,7 @@ import { findContactRequestNote, expirePendingContactRequests, reviewContactRequ
 import { isValidAid } from '../../aun/aid/validation.js';
 import { PeerIdentityCache, formatPeerKey } from '../relation/peer-identity.js';
 import { ownerResolver } from '../ownership/owner-resolver.js';
-import { isTopicSession, sessionLocalTopicId } from '../thread/topic-id.js';
+import { isMainSession, isTopicSession, sessionLocalTopicId } from '../thread/topic-id.js';
 import { resolveEffective } from '../../config/config-manager.js';
 import { createDecisionInferenceProvider } from '../inference/text-inference.js';
 import { AutoMentionGate } from './auto-mention-gate.js';
@@ -39,8 +39,7 @@ import { recordCausationSpan } from '../causation/audit.js';
 import { renderActionAsText } from '../interaction-router.js';
 import { planApprovalRoute } from '../permission/approval-gateway.js';
 import { guardGroupSlashCommand, parseFullAccessCommand } from '../command/slash-gate.js';
-import { createAgentPolicyAuthorization } from '../role/runtime-policy.js';
-import { auditFullAccessEvent } from '../auth/authorization-audit.js';
+import { createAgentPolicyAuthorization, createSessionFullAccessAuthorization, hasSessionFullAccessOverride } from '../role/runtime-policy.js';
 import { DIAGNOSTIC_AGENT_AID, DiagnosticSessionRouter, parseDiagnosticEvent, isDiagnosticSessionActive } from '../command/diag-service.js';
 import { consumeAdmissionReplyBudget, clearAdmissionReplyBudgets, evaluateInboundAdmissionPreflight, evaluateOrdinaryInboundAdmission, } from './message-admission.js';
 const CONTACT_REJECTION_NOTICE = '[rejection] Not accepting messages from you.';
@@ -279,6 +278,43 @@ export class MessageBridge {
                 return { handled: true, status: 'not-first-owner', reply: '仅 Agent 配置中的首个 Owner 可在 AUN 私聊发送 /bind 发起 ownership 绑定。' };
             }
             try {
+                const current = await ownerResolver.refresh(selfAid, { force: true });
+                if (current.consensusStatus === 'consensus') {
+                    return current.ownerAid === actorId
+                        ? { handled: true, status: 'already-bound', reply: '协议 Owner 已绑定，无需重复操作。' }
+                        : {
+                            handled: true,
+                            status: 'owner-already-bound',
+                            reply: `该 Agent 已绑定协议 Owner ${current.ownerAid ?? '（身份未知）'}，暂不支持重新绑定。`,
+                        };
+                }
+                const taskStatus = current.task?.status;
+                const hasActiveSubmission = taskStatus === 'pending'
+                    || (['requesting', 'submitted'].includes(current.requestStatus ?? '')
+                        && (!taskStatus || taskStatus === 'completed'));
+                const interruptedSubmissionNeedsCheck = current.requestStatus === 'interrupted'
+                    && current.consensusStatus === 'single_sided';
+                if (hasActiveSubmission || interruptedSubmissionNeedsCheck) {
+                    const requestedOwner = current.requestedOwnerAid ?? current.task?.owner_aid;
+                    if (interruptedSubmissionNeedsCheck) {
+                        return {
+                            handled: true,
+                            status: 'ownership-unverified',
+                            reply: '上一笔协议 Owner 绑定请求状态尚未确认，请先核验状态，暂不重复发起。',
+                        };
+                    }
+                    return requestedOwner && requestedOwner !== actorId
+                        ? {
+                            handled: true,
+                            status: 'ownership-pending-conflict',
+                            reply: `已有发往 ${requestedOwner} 的协议 Owner 绑定请求正在处理中，请先完成或核验该请求。`,
+                        }
+                        : {
+                            handled: true,
+                            status: 'ownership-pending',
+                            reply: '协议 Owner 绑定请求正在处理中，请在 Evol 中确认；无需重复发送 /bind。',
+                        };
+                }
                 const state = await ownerResolver.bind(selfAid, actorId);
                 const alreadyBound = state.consensusStatus === 'consensus' && state.ownerAid === actorId;
                 if (!alreadyBound && state.task && ['rejected', 'stopped', 'error'].includes(state.task.status)) {
@@ -1150,9 +1186,9 @@ export class MessageBridge {
                         return;
                     }
                 }
-                // /fa is an execution prefix, not a session-mode switch or a normal
-                // quick command. Only this trusted bridge path can construct the
-                // internal per-call authorization carried into ResponseEngine.
+                // /fa is a persistent current-session control. The slash handler owns
+                // its storage and authorization; the bridge only enforces source and
+                // group boundaries before normal command routing.
                 const fullAccessCommand = parseFullAccessCommand(content);
                 if (fullAccessCommand.matched) {
                     const groupGuard = guardGroupSlashCommand(content, chatType);
@@ -1160,51 +1196,14 @@ export class MessageBridge {
                         await this.sendSlashControlReply(channelName, msg, sendReply, groupGuard, adapter);
                         return;
                     }
-                    const reject = async (text) => {
-                        logger.warn(`[MessageBridge] fullaccess command rejected: channel=${channelName} `
-                            + `actor=${authSubject.principalId ?? authSubject.actorId ?? '<none>'} reason=${text}`);
-                        auditFullAccessEvent({
-                            event: 'fullaccess.command.rejected',
-                            source: 'fullaccess-command',
-                            decision: 'deny',
-                            actorId: authSubject.principalId ?? authSubject.actorId,
-                            processRole: authSubject.processRole,
-                            messageId: msg.messageId,
-                            reason: text,
-                        });
-                        await sendReply(msg.channelId, `❌ ${text}`, msg.replyContext);
-                    };
                     if (msg.source !== undefined && msg.source !== 'user') {
-                        await reject('fullaccess 只能由用户直接发送的 /fa 或 /fullaccess 命令发起');
-                        return;
-                    }
-                    if (!fullAccessCommand.prompt) {
-                        await reject('用法：/fa <提示词> 或 /fullaccess <提示词>');
+                        await sendReply(msg.channelId, '❌ /fa 只能由用户直接发送', msg.replyContext);
                         return;
                     }
-                    if (!authSubject.isDaemonOwner || !authSubject.principalId) {
-                        await reject('仅可信 daemon-owner 可以使用 fullaccess');
+                    if (fullAccessCommand.action === 'invalid') {
+                        await sendReply(msg.channelId, '❌ 用法：/fa、/fa on 或 /fa off', msg.replyContext);
                         return;
                     }
-                    if (!msg.messageLogContent)
-                        msg.messageLogContent = content;
-                    content = fullAccessCommand.prompt;
-                    executionPermissionOverride = {
-                        permissionMode: 'fullaccess',
-                        processRole: 'fullaccess-run',
-                        dataScope: 'daemon',
-                        source: 'fullaccess-command',
-                        authorizedBy: authSubject.principalId,
-                    };
-                    logger.warn(`[MessageBridge] fullaccess command accepted: channel=${channelName} `
-                        + `actor=${authSubject.principalId} message=${msg.messageId ?? '<none>'}`);
-                    auditFullAccessEvent({
-                        event: 'fullaccess.command.accepted',
-                        source: 'fullaccess-command',
-                        actorId: authSubject.principalId,
-                        processRole: authSubject.processRole,
-                        messageId: msg.messageId,
-                    });
                 }
                 // 0. 仅阻止协议遥测进入 session / model / messages.jsonl；协议本身已在
                 // channel/main/events/AUN/handoff 专用链路中处理和记录。
@@ -1248,6 +1247,7 @@ export class MessageBridge {
                 // 2. 命令快速路径（去除引用前缀后检查，兼容话题中引用上文的情况）
                 const contentForCmd = content.replace(/^(>[^\n]*\n)+\n?/, '').trim();
                 const cmdContent = contentForCmd || content;
+                const parsedFullAccessControl = parseFullAccessCommand(cmdContent);
                 let autoMode = false;
                 if (resolvedChannelType === 'aun' && chatType === 'group' && selfAid && msg.source !== 'handoff') {
                     try {
@@ -1281,7 +1281,10 @@ export class MessageBridge {
                     // A prompt such as `/fa /status` must not be re-routed as the
                     // ordinary `/status` quick command after the prefix is removed.
                     && !executionPermissionOverride
-                    && !parseFullAccessCommand(cmdContent).matched
+                    && (!parsedFullAccessControl.matched
+                        || parsedFullAccessControl.action === 'status'
+                        || parsedFullAccessControl.action === 'on'
+                        || parsedFullAccessControl.action === 'off')
                     && this.cmdHandler.isCommand(cmdContent);
                 if (isCmd && /^\/new(?:\s|$)/i.test(cmdContent)) {
                     // /new changes the active main-session boundary. Serialize it with
@@ -1333,14 +1336,6 @@ export class MessageBridge {
                         return sendReply(msg.channelId, text, msg.replyContext);
                     }, msg.peerId, msg.threadId, msg.chatType, msg.source, msg.replyContext, msg.messageId, msg.selfAID, authSubject))
                     return;
-                // Commands retain their normal route. Only authenticated direct model
-                // input can obtain the Agent policy's per-call authorization.
-                if (!executionPermissionOverride && selfAid && owningAgent?.aid === selfAid) {
-                    executionPermissionOverride = createAgentPolicyAuthorization({
-                        agentAid: selfAid, actor: roleDetail.actor, chatType,
-                        source: msg.source, peerType: msg.peerType,
-                    });
-                }
                 // 3. session 解析（使用 Channel 层填充的 chatType）
                 if (!(await this.canCreateThreadSession(channelName, msg, chatType))) {
                     // 静默丢弃：绝不向群里注入回复。
@@ -1481,6 +1476,20 @@ export class MessageBridge {
                     causation: inboundCausation,
                 });
                 session = renewResult.session;
+                if (!executionPermissionOverride && selfAid && owningAgent?.aid === selfAid) {
+                    executionPermissionOverride = createSessionFullAccessAuthorization({
+                        session,
+                        actor: roleDetail.actor,
+                        source: msg.source,
+                        peerType: msg.peerType,
+                    });
+                    if (!executionPermissionOverride && isMainSession(session) && !hasSessionFullAccessOverride(session)) {
+                        executionPermissionOverride = createAgentPolicyAuthorization({
+                            agentAid: selfAid, actor: roleDetail.actor, chatType,
+                            source: msg.source, peerType: msg.peerType,
+                        });
+                    }
+                }
                 if ('renewed' in renewResult && renewResult.renewed) {
                     const notice = '已自动切换到新会话';
                     try {

package/dist/core/message/message-log.js

@@ -295,6 +295,20 @@ export function findMessageLogOperationMessageId(chatDir, operationId) {
 export function resolveChatDir(sessionsDir, channelType, channelId, selfAID) {
     return chatDirPath(sessionsDir, channelType, channelId, selfAID);
 }
+let inboundLogListener;
+export function setInboundLogListener(listener) {
+    inboundLogListener = listener;
+}
+function notifyInbound(chatDir, entry) {
+    if (entry.dir !== 'in' || !inboundLogListener)
+        return;
+    try {
+        inboundLogListener(chatDir, entry);
+    }
+    catch (e) {
+        logger.warn(`[MessageLog] Inbound listener failed: ${e}`);
+    }
+}
 /** Append conversation history only. Protocol telemetry stays in its dedicated logs/stores. */
 export function appendMessageLog(chatDir, entry) {
     if (isTransientProtocolMessage(entry))
@@ -311,7 +325,9 @@ export function appendMessageLog(chatDir, entry) {
     }
     catch (e) {
         logger.warn(`[MessageLog] Failed to write message log: ${e}`);
+        return;
     }
+    notifyInbound(chatDir, entry);
 }
 /** Strict conversation-history append used by handoff reply binding. */
 export function appendMessageLogStrict(chatDir, entry, durable = false) {
@@ -323,6 +339,7 @@ export function appendMessageLogStrict(chatDir, entry, durable = false) {
     (durable ? appendJsonlDurable : appendJsonl)(messageLogPath(chatDir), entry);
     if (entry.dir === 'in')
         rememberMessageId(chatDir, entry.msgId);
+    notifyInbound(chatDir, entry);
 }
 export function buildInboundEntry(opts) {
     const ts = opts.timestamp || Date.now();

package/dist/core/message/message-queue.js

@@ -719,6 +719,7 @@ export class MessageQueue {
                 sessionId: sessionKey,
                 reason: 'daemon_restart',
                 agentName,
+                agentAid: this.activeStates.get(queueKey)?.selfAID,
                 taskId: this.activeStates.get(queueKey)?.taskId,
                 generation: this.activeStates.get(queueKey)?.generation,
                 causation: item.message.causation,
@@ -1154,6 +1155,7 @@ export class MessageQueue {
                         sessionId: sessionKey,
                         reason: 'new_message',
                         agentName: this.processingAgent.get(queueKey),
+                        agentAid: this.activeStates.get(queueKey)?.selfAID,
                         taskId: this.activeStates.get(queueKey)?.taskId,
                         generation: this.activeStates.get(queueKey)?.generation,
                         causation: this.activeBatches.get(queueKey)?.message.causation,
@@ -1755,6 +1757,7 @@ export class MessageQueue {
                     sessionId: sessionKey,
                     reason,
                     agentName,
+                    agentAid: activeState?.selfAID,
                     taskId: activeState?.taskId,
                     generation: activeState?.generation,
                     causation: active?.message.causation,
@@ -2043,6 +2046,7 @@ export class MessageQueue {
                     sessionId: sessionKey,
                     reason: 'stop',
                     agentName: name,
+                    agentAid: activeState?.selfAID,
                     taskId: this.activeStates.get(queueKey)?.taskId,
                     generation: this.activeStates.get(queueKey)?.generation,
                     causation: this.activeBatches.get(queueKey)?.message.causation,
@@ -2317,6 +2321,7 @@ export class MessageQueue {
             sessionId: sessionKey,
             reason: 'new_message',
             agentName: targetAgentName,
+            agentAid: this.activeStates.get(targetQueueKey)?.selfAID,
             taskId: this.activeStates.get(targetQueueKey)?.taskId,
             generation: this.activeStates.get(targetQueueKey)?.generation,
             causation: this.activeBatches.get(targetQueueKey)?.message.causation,
@@ -2336,6 +2341,7 @@ export class MessageQueue {
             this.eventBus?.publish({
                 type: 'task:interrupted', sessionId, reason: 'new_message',
                 agentName: this.processingAgent.get(queueKey),
+                agentAid: this.activeStates.get(queueKey)?.selfAID,
                 taskId: this.activeStates.get(queueKey)?.taskId,
                 generation: this.activeStates.get(queueKey)?.generation,
                 causation: active.message.causation,

package/dist/core/message/outbound.js

@@ -1,5 +1,70 @@
 import { isDeliveryTargetForChannel } from './message-utils.js';
 import { readEvolcoreRuntimeFlavor, readEvolcoreStartedAtIso, readInstalledEvolcoreVersion, tagErrorTextWithEvolcoreVersion, } from '../../utils/evolcore-version.js';
+import { getErrorRawText } from '../../utils/error-utils.js';
+function appendRawErrorText(text, raw) {
+    if (!raw || text === raw || text.includes(`原因：${raw}`))
+        return text;
+    return `${text}\n原因：${raw}`;
+}
+function resolveRawErrorText(raw, fallback) {
+    return getErrorRawText(raw) || getErrorRawText(fallback);
+}
+/** Ensure every outbound error carries the best available diagnostic text. */
+export function normalizeOutboundErrorPayload(payload) {
+    switch (payload.kind) {
+        case 'result.error':
+        case 'system.error':
+        case 'command.error': {
+            const raw = resolveRawErrorText(payload.raw, payload.text);
+            if (!raw)
+                return payload;
+            return {
+                ...payload,
+                text: appendRawErrorText(payload.text, raw),
+                raw,
+            };
+        }
+        case 'status.error': {
+            const metadata = payload.metadata;
+            if (!metadata)
+                return payload;
+            const raw = resolveRawErrorText(metadata.raw, metadata.message);
+            if (!raw)
+                return payload;
+            return {
+                ...payload,
+                metadata: {
+                    ...metadata,
+                    message: typeof metadata.message === 'string'
+                        ? appendRawErrorText(metadata.message, raw)
+                        : metadata.message,
+                    raw,
+                },
+            };
+        }
+        case 'status.timeout': {
+            const metadata = payload.metadata;
+            if (!metadata)
+                return payload;
+            const message = metadata.message ?? (typeof metadata.totalExecutionMs === 'number'
+                ? `任务超过总执行时限（${Math.round(metadata.totalExecutionMs / 1000)}秒），已自动中断`
+                : typeof metadata.idleSec === 'number' && metadata.idleSec > 0
+                    ? `任务超时（${metadata.idleSec}秒无响应），已自动中断`
+                    : '任务超时，已自动中断');
+            const raw = resolveRawErrorText(metadata.raw, metadata.reason) || message;
+            return {
+                ...payload,
+                metadata: {
+                    ...metadata,
+                    message: appendRawErrorText(message, raw),
+                    raw,
+                },
+            };
+        }
+        default:
+            return payload;
+    }
+}
 /** 出站 payload 摘要（用于 channel-out.log）。 */
 export function summarizeOutboundPayload(payload) {
     if (!payload)
@@ -18,6 +83,8 @@ export function summarizeOutboundPayload(payload) {
         case 'command.error':
         case 'result.error':
             summary.text = payload.text;
+            if (payload.raw !== undefined)
+                summary.raw = payload.raw;
             break;
         case 'result.file':
             summary.filePath = payload.filePath;
@@ -26,6 +93,8 @@ export function summarizeOutboundPayload(payload) {
         case 'system.error':
             summary.subtype = payload.subtype;
             summary.text = payload.text;
+            if (payload.raw !== undefined)
+                summary.raw = payload.raw;
             break;
         case 'interaction':
             summary.interactionId = payload.interaction?.id;
@@ -47,6 +116,7 @@ export function summarizeOutboundPayload(payload) {
 }
 /** Add the current EvolCore version marker to user-visible error payloads. */
 export function tagErrorPayloadWithEvolcoreVersion(payload) {
+    payload = normalizeOutboundErrorPayload(payload);
     switch (payload.kind) {
         case 'result.error':
         case 'system.error':

package/dist/core/message/peer-mode.js

@@ -51,10 +51,15 @@ export function isPrivateChatmodeRoleLocked(field, role) {
  *   - 人类且非 owner/admin（含角色未知）→ proactive
  *   - 人类且 owner/admin → 分层配置（未配置时取出厂默认）
  */
-export function chatmodeForPeerIdentity(identity, role) {
+export function chatmodeForPeerIdentity(identity, role, configContext = {}) {
     if (identity.isMachine)
         return 'proactive';
-    return resolveChatMode({ role: role ?? undefined, chatType: 'private', peerType: identity.type ?? 'human' });
+    return resolveChatMode({
+        ...configContext,
+        role: role ?? undefined,
+        chatType: 'private',
+        peerType: identity.type ?? 'human',
+    });
 }
 export function resolveChatModeForField(params) {
     return resolveChatMode({