evolcore 0.0.32 → 0.0.33

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

@@ -1,14 +1,17 @@
+import crypto from 'crypto';
 import { authorizeDelegatedAunMsgSend, } from '../auth/agent-delegation.js';
-import { tryParseChannelKey } from '../channel-loader.js';
+import { formatChannelKey, tryParseChannelKey } from '../channel-loader.js';
 import { AUN_HANDOFF_MARKER_FIELD } from '../../channels/aun.js';
 import { classifyAunPayloadForLog } from './message-log.js';
 import { isValidAunDeliveryForChannel } from './outbound.js';
 import { isHClassPath } from '../permission/protected-paths.js';
 import { evaluateOutboundContactAdmission } from './message-admission.js';
 import { normalizeAunMentionEntries, withAunAttention } from '../../aun/msg/mention-schema.js';
-import { resolveManagedSendArgv } from '../../cli/aun-commands.js';
+import { buildThreadCheckTrigger, resolveManagedSendArgv } from '../../cli/aun-commands.js';
 import { readTriggerLocalFile, resolveTriggerLocalPath } from '../../trigger/local-files.js';
 import { sameGroupAid } from '../../aun/group/identity.js';
+import { resolveThreadRouteTarget } from '../thread/thread-route.js';
+import { ThreadService } from '../thread/thread-service.js';
 export function createAunHandoffSender(sessionManager, channelInstances) {
     return async (handoff) => {
         const targetSession = await sessionManager.getSessionById(handoff.target_session_id);
@@ -58,7 +61,92 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         return { ok: result.ok, message_id: result.message_id, error: result.error };
     };
 }
-export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, }) {
+async function applyManagedCrossThreadSendEffects(input) {
+    const originSessionId = input.runtime?.sessionId;
+    if (!originSessionId)
+        return undefined;
+    const originThreadId = input.runtime?.threadId || 'main';
+    const originPeer = input.runtime?.channelId || input.targetChannelId;
+    const originChatType = input.runtime?.chatType === 'group' ? 'group' : 'private';
+    const originChannelKey = input.runtime?.channelKey;
+    const originChannelId = input.runtime?.channelId;
+    const originPeerId = input.runtime?.peerId || (originChatType === 'private' ? originChannelId : undefined);
+    const origin = originChannelKey && originChannelId && originPeerId
+        ? {
+            channelKey: originChannelKey,
+            channelType: input.runtime?.channel || 'aun',
+            channelId: originChannelId,
+            session: input.runtime?.threadId ? 'thread' : 'main',
+            ...(input.runtime?.threadId ? { threadId: input.runtime.threadId } : {}),
+            peerId: originPeerId,
+            delivery: originChatType === 'group'
+                ? { chatType: 'group', groupId: originChannelId }
+                : { chatType: 'private' },
+        }
+        : undefined;
+    const triggerSeed = `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    const triggerId = `trig_${triggerSeed}`;
+    const triggerName = `check-${input.targetThreadId}-from-${originThreadId}-${triggerSeed.split('_')[1]}`;
+    const prompt = [
+        `【Trigger 复查】话题 ${input.targetThreadId}（对端 ${input.targetChannelId}）`,
+        `这是周期复查：每 ${input.checkEveryLabel} 唤醒一次，直到你显式结束它。`,
+        '',
+        input.triggerPromptExtra
+            || `请检查该话题的最新进度，根据情况：继续等待、调整周期（ec trigger update ${triggerId} --every <时长>）或结束复查（ec trigger cancel ${triggerId}）。`,
+        '',
+        '参考命令：',
+        `  ec thread history ${input.targetChannelId}/${input.targetThreadId} --limit 10`,
+        `  ec thread history ${originPeer}/${originThreadId} --after ${Date.now()}`,
+        `  ec trigger cancel ${triggerId}`,
+        `  ec trigger update ${triggerId} --every <时长>`,
+        `Trigger id：${triggerId}`,
+        `Trigger 名称：${triggerName}`,
+    ].join('\n');
+    let createdTriggerId;
+    try {
+        if (!origin)
+            throw new Error('managed task runtime context is missing a trusted Trigger origin');
+        const scheduler = input.triggerSchedulers.get(input.selfAid);
+        if (!scheduler)
+            throw new Error(`trigger scheduler not found for agent: ${input.selfAid}`);
+        const definition = buildThreadCheckTrigger({
+            agentAid: input.selfAid,
+            id: triggerId,
+            name: triggerName,
+            prompt,
+            everyMs: input.durationMs,
+            checkEvery: input.checkEveryLabel,
+            channelKey: formatChannelKey({ type: 'aun', selfAID: input.selfAid, name: 'main' }),
+            targetChannelId: input.targetChannelId,
+            targetThreadId: input.targetThreadId,
+            originThreadId,
+            originPeer,
+            origin,
+            feedbackChatType: input.feedbackChatType,
+        });
+        createdTriggerId = scheduler.create(definition, [], { enable: true }).id;
+    }
+    catch (error) {
+        console.warn(`⚠ Trigger 创建失败: ${error instanceof Error ? error.message : String(error)}（inbox 仍会写入）`);
+    }
+    try {
+        ThreadService.appendInbox(input.selfAid, {
+            messageId: input.messageId,
+            content: input.contentSummary,
+            timestamp: input.timestamp,
+            originThreadId,
+            originPeer,
+            originSessionId,
+            targetSessionId: input.targetSessionId,
+            ...(createdTriggerId ? { triggerId: createdTriggerId } : {}),
+        });
+    }
+    catch (error) {
+        console.warn(`⚠ 话题 inbox 写入失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return createdTriggerId;
+}
+export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers, }) {
     const sender = async (params) => {
         let textFile;
         try {
@@ -76,6 +164,12 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         }
         const runtime = params.originSessionId ? responseEngine.getTaskRuntimeContext(params.originSessionId) : undefined;
         const runtimeCausation = runtime?.causation;
+        const threadRoute = params.thread
+            ? resolveThreadRouteTarget(params.aid, params.thread, params.scope, params.to)
+            : undefined;
+        if (params.thread && !threadRoute) {
+            return { ok: false, code: 'TOPIC_NOT_FOUND', error: `话题不存在或不属于目标对端: ${params.thread}` };
+        }
         if (params.argv !== undefined && !params.delegationCommandHash) {
             return { ok: false, code: 'INVALID_DELEGATION', error: 'Managed AUN sends require an approved command hash' };
         }
@@ -88,6 +182,7 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             to: params.to,
             scope: params.scope,
             action: params.file ? 'file' : 'send',
+            threadRouted: !!threadRoute,
         });
         if (!delegation.ok) {
             return { ok: false, error: delegation.reason, code: delegation.code };
@@ -219,13 +314,33 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 });
                 targetSessionId = created.targetSession.id;
                 if (created.crossSession && created.handoff) {
-                    return {
+                    const response = {
                         ok: true,
                         status: created.handoff.state === 'target_sent' ? 'delivered' : 'queued',
                         message_id: created.handoff.target_message_id ?? undefined,
                         handoff_id: created.handoff.handoff_id,
                         target_session_id: created.targetSession.id,
                     };
+                    if (params.thread && params.checkEveryMs !== undefined && response.message_id && threadRoute) {
+                        const triggerId = await applyManagedCrossThreadSendEffects({
+                            triggerSchedulers,
+                            runtime,
+                            selfAid: params.aid,
+                            targetThreadId: params.thread,
+                            targetSessionId: threadRoute.sessionId,
+                            targetChannelId: params.to,
+                            feedbackChatType: params.scope === 'group' ? 'group' : 'private',
+                            messageId: response.message_id,
+                            contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                            timestamp: response.timestamp ?? Date.now(),
+                            durationMs: params.checkEveryMs,
+                            checkEveryLabel: params.checkEvery ?? '5m',
+                            triggerPromptExtra: params.triggerPromptExtra,
+                        });
+                        if (triggerId)
+                            response.trigger_id = triggerId;
+                    }
+                    return response;
                 }
                 if (params.scope === 'msg' && !payload.ref_message_id) {
                     payload.ref_message_id = params.originMessageId;
@@ -247,24 +362,64 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             if (typeof ch.sendDaemonGroupMsg !== 'function') {
                 return { ok: false, error: 'AUN channel does not support daemon group sends', code: 'AUN_GROUP_UNSUPPORTED' };
             }
-            return await ch.sendDaemonGroupMsg({
+            const sent = await ch.sendDaemonGroupMsg({
                 groupId: params.to,
                 payload,
                 mentions: params.mentions,
                 encrypt,
                 log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
             });
+            if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
+                const triggerId = await applyManagedCrossThreadSendEffects({
+                    triggerSchedulers,
+                    runtime,
+                    selfAid: params.aid,
+                    targetThreadId: params.thread,
+                    targetSessionId: threadRoute.sessionId,
+                    targetChannelId: params.to,
+                    feedbackChatType: 'group',
+                    messageId: sent.message_id,
+                    contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                    timestamp: sent.timestamp ?? Date.now(),
+                    durationMs: params.checkEveryMs,
+                    checkEveryLabel: params.checkEvery ?? '5m',
+                    triggerPromptExtra: params.triggerPromptExtra,
+                });
+                if (triggerId)
+                    sent.trigger_id = triggerId;
+            }
+            return sent;
         }
         if (typeof ch.sendDaemonMsg !== 'function') {
             return { ok: false, error: 'AUN channel does not support daemon private sends', code: 'AUN_MSG_UNSUPPORTED' };
         }
-        return await ch.sendDaemonMsg({
+        const sent = await ch.sendDaemonMsg({
             to: params.to,
             payload,
             encrypt,
             causation: runtimeCausation,
             log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
         });
+        if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
+            const triggerId = await applyManagedCrossThreadSendEffects({
+                triggerSchedulers,
+                runtime,
+                selfAid: params.aid,
+                targetThreadId: params.thread,
+                targetSessionId: threadRoute.sessionId,
+                targetChannelId: params.to,
+                feedbackChatType: 'private',
+                messageId: sent.message_id,
+                contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                timestamp: sent.timestamp ?? Date.now(),
+                durationMs: params.checkEveryMs,
+                checkEveryLabel: params.checkEvery ?? '5m',
+                triggerPromptExtra: params.triggerPromptExtra,
+            });
+            if (triggerId)
+                sent.trigger_id = triggerId;
+        }
+        return sent;
     };
     ipcServer.setAunMsgSender(sender);
 }

package/dist/core/message/im-renderer.js

@@ -4,6 +4,7 @@ import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.j
 import { tagErrorTextWithEvolcoreVersion } from '../../utils/evolcore-version.js';
 import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
 import { classifyAunToolErrorCode, normalizeToolErrorClassification } from '../permission/tool-error-code.js';
+import { foldSubtaskTerminal } from './subtask-tool-projection.js';
 export class IMRenderer {
     opts;
     itemsQueue = [];
@@ -22,6 +23,16 @@ export class IMRenderer {
     syntheticCallSeq = 0;
     currentAssistantUuid;
     currentTextPhase;
+    /** 无来源工具时合成的子任务卡片；与 lifecycle 边界一样，不算抑制兜底错误的正文/过程内容。 */
+    subtaskItems = new WeakSet();
+    /** 本轮已投影的工具调用 call_id → 工具名；子任务只归拢到本轮可见的来源工具卡片。 */
+    toolCallNames = new Map();
+    /**
+     * 归拢到来源工具的子任务：call_id → 状态。
+     * running 期间到达的 tool_result（后台占位结果）先扣住，等终态合并后再发；
+     * 终态先到（前台）时记下终态，等真实 tool_result 到达时合并。
+     */
+    parentSubtasks = new Map();
     constructor(opts) {
         this.opts = opts;
     }
@@ -66,7 +77,8 @@ export class IMRenderer {
     /** 强制刷新所有 pending 事件 */
     async flush(isFinal, attention) {
         if (this.opts.envelope.chatmode === 'proactive') {
-            // proactive 是 fire-and-forget，无 pending buffer
+            // proactive 是 fire-and-forget，无 pending buffer；只需放出仍被扣住的工具结果
+            this.releaseHeldToolResults();
             return;
         }
         return this.flushInternal(isFinal, attention);
@@ -79,16 +91,24 @@ export class IMRenderer {
     }
     /** 是否有 pending 内容 */
     hasContent() {
-        return this.textBuffer.length > 0 || this.itemsQueue.some(it => it.kind !== 'text');
+        return this.textBuffer.length > 0 || this.itemsQueue.some(it => it.kind !== 'text') || this.hasHeldToolResults();
     }
     /** 是否有会抑制兜底错误消息的正文/过程内容；lifecycle 边界不算。 */
     hasNonLifecycleContent() {
-        return this.textBuffer.trim().length > 0 || this.itemsQueue.some(it => {
+        return this.textBuffer.trim().length > 0 || this.hasHeldToolResults() || this.itemsQueue.some(it => {
             if (it.kind === 'text')
                 return it.text.trim().length > 0;
+            if (this.subtaskItems.has(it))
+                return false;
             return it.kind !== 'started' && it.kind !== 'completed';
         });
     }
+    hasHeldToolResults() {
+        for (const state of this.parentSubtasks.values())
+            if (state.held)
+                return true;
+        return false;
+    }
     /** 是否有待发送的文本 */
     hasTextPending() {
         return this.textBuffer.length > 0;
@@ -234,6 +254,7 @@ export class IMRenderer {
             ...(evolCommand ? { evolCommand } : {}),
             ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
         };
+        this.toolCallNames.set(item.call_id, name);
         this.recordActivity(item);
         if (this.suppressActivityItems())
             return;
@@ -245,7 +266,6 @@ export class IMRenderer {
     addToolResult(name, ok, result, error, callId, durationMs, descText, classification, assistantUuid) {
         if (this.opts.envelope.chatmode === 'proactive')
             return;
-        this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
         const normalizedClassification = !ok
             ? normalizeToolErrorClassification(classification ?? {})
             : undefined;
@@ -269,6 +289,22 @@ export class IMRenderer {
             ...(descText !== undefined && { text: descText }),
             ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
         };
+        const resolved = this.resolveParentToolResult(item);
+        if (!resolved)
+            return;
+        this.deliverToolResult(resolved);
+    }
+    /** 投递一条工具结果（interactive 入队 / proactive 直发），并记录任务活动。 */
+    deliverToolResult(item) {
+        if (item.kind !== 'tool_result')
+            return;
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactiveItem(item);
+            return;
+        }
+        this.emitProgress('tool_result', undefined, undefined, {
+            toolName: item.name, callId: item.call_id, ok: item.ok, durationMs: item.duration_ms,
+        });
         this.recordActivity(item);
         if (this.suppressActivityItems())
             return;
@@ -276,6 +312,73 @@ export class IMRenderer {
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
+    /**
+     * 工具结果与归拢子任务的会合点。
+     * - 无归拢子任务：原样放行
+     * - 子任务已终态（前台：通知先于真实结果到达）：合并终态后放行
+     * - 子任务仍在跑（后台：先到的是占位结果）：扣住，返回 null，等 endParentSubtask 合并后发出
+     */
+    resolveParentToolResult(item) {
+        if (item.kind !== 'tool_result')
+            return item;
+        const state = this.parentSubtasks.get(item.call_id);
+        if (!state)
+            return item;
+        if (state.terminal) {
+            this.parentSubtasks.delete(item.call_id);
+            return foldSubtaskTerminal(item, state.terminal);
+        }
+        state.held = item;
+        return null;
+    }
+    /**
+     * 子任务开始：若来源工具卡片在本轮可见，登记归拢，不另出卡片。
+     * 返回 false 表示无法归拢（无来源工具或卡片不在本轮），调用方应改发独立卡片。
+     */
+    beginParentSubtask(toolUseId) {
+        if (!toolUseId || !this.toolCallNames.has(toolUseId))
+            return false;
+        if (!this.parentSubtasks.has(toolUseId))
+            this.parentSubtasks.set(toolUseId, {});
+        return true;
+    }
+    /**
+     * 子任务终态：合并进来源工具的 tool_result。
+     * - 已扣住占位结果（后台）：合并后立即发出
+     * - 结果尚未到达（前台）：记下终态，等结果到达时合并
+     * 返回 false 表示本轮没有登记该归拢（卡片已提前释放或不在本轮），调用方应补发一条同 call_id 的终态结果。
+     */
+    endParentSubtask(toolUseId, terminal) {
+        if (!toolUseId)
+            return false;
+        const state = this.parentSubtasks.get(toolUseId);
+        if (!state)
+            return false;
+        if (state.held) {
+            this.parentSubtasks.delete(toolUseId);
+            this.deliverToolResult(foldSubtaskTerminal(state.held, terminal));
+        }
+        else {
+            state.terminal = terminal;
+        }
+        return true;
+    }
+    /** 来源工具的名称（本轮可见时）；补发终态结果时用来对齐卡片名。 */
+    toolNameForCall(callId) {
+        return callId ? this.toolCallNames.get(callId) : undefined;
+    }
+    /**
+     * 放出仍被扣住的工具结果（不带子任务终态，原样发出）。
+     * 轮次结束或出错收尾时调用，避免来源工具卡片停在"执行中"。
+     */
+    releaseHeldToolResults() {
+        for (const [callId, state] of this.parentSubtasks) {
+            if (!state.held)
+                continue;
+            this.parentSubtasks.delete(callId);
+            this.deliverToolResult(state.held);
+        }
+    }
     /** 添加进度提示 */
     addProgress(text, opts = {}) {
         if (this.opts.envelope.chatmode === 'proactive')
@@ -348,6 +451,26 @@ export class IMRenderer {
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
+    /**
+     * 添加子任务活动（由 subtask-tool-projection 构造的 tool_call / tool_result）。
+     *
+     * 与 addToolCall/addToolResult 不同：不发 status.progress（子任务不是本轮模型正在发起的工具调用），
+     * 且 proactive 下照常投影为 thought（mapEventToItem 不处理 task_* 事件，不会重复）。
+     * 活动记录与 addToolCall 一致，在抑制前写入，保证任务活动 Menu 历史完整。
+     */
+    addSubtaskActivity(item) {
+        this.subtaskItems.add(item);
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactiveItem(item);
+            return;
+        }
+        this.recordActivity(item);
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push(item);
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
     /**
      * proactive 下放行为 thought 的 notice subtype 白名单——仅"真·终态错误"：
      * - context-too-long：上下文超限且无法 auto-compact，任务到此终止
@@ -553,6 +676,16 @@ export class IMRenderer {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
+        // 显式 flush（轮次结束、出错收尾）时放出被扣住的后台占位结果；定时 flush 不放，
+        // 否则长时间后台任务会在终态到达前就把占位结果发出去。放出的结果随本次 flush 一起发，
+        // 不需要它重新挂上的定时器。
+        if (!scheduled) {
+            this.releaseHeldToolResults();
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer = undefined;
+            }
+        }
         // 文件标记过滤：marker 任何时候都不该出现在用户文本里，必须在 *每次* flush
         // （含非最终的定时 flush）执行。否则文本块若滞留 buffer 后被定时器触发，会走
         // 下方非-final 的 result.text 路径，把 [SEND_FILE:...] 原样发给用户。
@@ -717,6 +850,16 @@ export class IMRenderer {
         if (item.kind === 'progress') {
             return;
         }
+        if (item.kind === 'tool_call') {
+            this.toolCallNames.set(item.call_id, item.name);
+        }
+        else if (item.kind === 'tool_result') {
+            const resolved = this.resolveParentToolResult(item);
+            if (!resolved)
+                return;
+            this.emitProactiveItem(resolved);
+            return;
+        }
         this.emitProactiveItem(item);
     }
     /** proactive 模式逐条投影：单个 ThoughtItem 包成 activity.batch[1] 发出（fire-and-forget）。 */
@@ -814,7 +957,7 @@ export class IMRenderer {
                 // 上下文过长错误不输出（留给外层 auto-compact 处理）
                 if (isContextTooLongText(event.error || ''))
                     return null;
-                const text = getErrorMessage(new Error(event.error || '任务执行失败'), undefined, false);
+                const text = getErrorMessage(new Error(event.error), undefined, false);
                 return { kind: 'notice', text: tagErrorTextWithEvolcoreVersion(text), severity: 'warn' };
             }
             case 'complete': {
@@ -828,7 +971,7 @@ export class IMRenderer {
                     return null;
                 }
                 if (event.isError) {
-                    const errText = event.errors?.join('; ') || event.result || '任务失败';
+                    const errText = event.errors?.join('; ') || event.result || '';
                     const text = getErrorMessage(new Error(errText), event.terminalReason, false);
                     const item = {
                         kind: 'summary',

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

@@ -1895,9 +1895,19 @@ export class MessageBridge {
                 case 'menu.list':
                     if (args?.view === 'catalog') {
                         validateMenuCatalogArgs(args);
-                        const data = await this.cmdHandler.getMenuCatalog(channel, msg.channelId, authSubject, args.context, msg.isControlChannel ? 'control' : 'agent', !msg.isControlChannel || (msg.encrypted === true
-                            && msg.protectedHeaders?.auth_method !== 'remote-access-token'
-                            && msg.protectedHeaders?.auth_method !== 'ecweb-token'));
+                        const catalogArgs = [
+                            channel,
+                            msg.channelId,
+                            authSubject,
+                            args.context,
+                            msg.isControlChannel ? 'control' : 'agent',
+                            !msg.isControlChannel || (msg.encrypted === true
+                                && msg.protectedHeaders?.auth_method !== 'remote-access-token'
+                                && msg.protectedHeaders?.auth_method !== 'ecweb-token'),
+                        ];
+                        const data = msg.threadId
+                            ? await this.cmdHandler.getMenuCatalog(...catalogArgs, transportReplyContext)
+                            : await this.cmdHandler.getMenuCatalog(...catalogArgs);
                         return menuSuccess(header, data);
                     }
                     if (args?.view !== undefined) {

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

@@ -20,6 +20,7 @@ const TRANSIENT_PROTOCOL_TYPES = new Set([
     'thought',
     'handoff_state',
     'handoff_result',
+    'topic-created', // 话题创建系统消息，不进大模型上下文
 ]);
 const KNOWN_AUN_PAYLOAD_TYPES = new Set([
     'text',

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

@@ -14,8 +14,11 @@ export function resolveChatMode(params) {
         configured = undefined;
     }
     const kind = normalizePeerType(params.peerType);
+    // 运行时硬约束（非配置项）：system/service 始终 interactive；agent 始终 proactive
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     const decision = resolveRuntimeStringField({
         selfAid: params.self,
@@ -70,9 +73,11 @@ export function isSystemOrServicePeer(peerType) {
  */
 export function resolveChatModeForPeer(params) {
     const kind = normalizePeerType(params.peerType);
-    // 运行时硬约束（非配置项）：system/service 对端始终同步交互
+    // 运行时硬约束（非配置项）：system/service 对端始终同步交互；agent 对端始终主动响应
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     // 合并后的场景表 → 出厂默认表
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     return params.configured?.[field] ?? chatmodeFactoryDefaults()[field];