evolcore 0.0.27 → 0.0.29-test.0

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

@@ -1,20 +1,26 @@
 import { loadAgent } from '../../config-store.js';
 import { initializationBlocksTasks } from '../../cli/agent-create.js';
 import { createHash, randomBytes } from 'crypto';
+import fs from 'fs';
+import path from 'path';
 import { agentStorageMenuService, isAgentStorageMenuRequest } from '../command/agent-storage-menu.js';
 import { logger } from '../../utils/logger.js';
 import { StreamDebouncer } from './stream-debouncer.js';
 import { appendMessageLog, appendMessageLogStrict, buildInboundEntry, isTransientProtocolMessage } from './message-log.js';
 import { buildEnvelope, isInteractionSendAccepted, sendInteractionPayload } from './message-utils.js';
 import { chatDirPath } from '../session/session-fs-store.js';
-import { readTopicLable } from '../session/session-mapper.js';
+import { readTopicLabel, readTopicStatus } from '../session/session-mapper.js';
 import { formatChannelKey, tryParseChannelKey } from '../channel-loader.js';
 import { agentDir, resolvePaths } from '../../paths.js';
 import { listStaticAgentAdmins, listStaticAgentOwners, resolvePeerRoleDetail, } from '../../config/peer-role-resolver.js';
 import { resolveContactView, resolvePeerDisplayLabel, resolvePrincipal } from '../../config/contact-book.js';
 import { findContactRequestNote, expirePendingContactRequests, reviewContactRequest, submitContactRequest, contactRequestSubmissionProtocolResult, queryOwnContactRequestStatus, } from '../../config/contact-request-service.js';
 import { isValidAid } from '../../aun/aid/validation.js';
-import { PeerIdentityCache } from '../relation/peer-identity.js';
+import { PeerIdentityCache, formatPeerKey } from '../relation/peer-identity.js';
+import { resolveEffective } from '../../config/config-manager.js';
+import { createDecisionInferenceProvider } from '../inference/text-inference.js';
+import { AutoMentionGate } from './auto-mention-gate.js';
+import { syncGroupRulesContext } from '../../eck/group-rules-sync.js';
 import { handlePendingDingtalkContactBindMessage, registerPendingDingtalkContactBind } from '../../channels/dingtalk.js';
 import { handlePendingFeishuContactBindMessage, registerPendingFeishuContactBind } from '../../channels/feishu.js';
 import { handlePendingQQBotContactBindMessage, registerPendingQQBotContactBind } from '../../channels/qqbot.js';
@@ -30,9 +36,9 @@ 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 { isFullAccessEnabled } from '../../config-store.js';
 import { createAgentPolicyAuthorization } from '../role/runtime-policy.js';
 import { auditFullAccessEvent } from '../auth/authorization-audit.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.';
 const REJECTABLE_PEER_TYPES = new Set(['ai', 'bot', 'agent', 'service']);
@@ -104,6 +110,79 @@ export class MessageBridge {
     cmdHandler;
     eventBus;
     processOwnersProvider;
+    autoMentionGate = new AutoMentionGate({
+        resolveInference: item => {
+            const config = resolveEffective({
+                self: item.selfAid,
+                peerKey: formatPeerKey('aun', item.groupId),
+            }, { cache: true, expand: true });
+            const model = config.decision_model?.model?.trim();
+            const provider = createDecisionInferenceProvider(config.decision_model);
+            return model && provider ? { model, provider } : undefined;
+        },
+        resolveResources: async (item) => {
+            const config = resolveEffective({
+                self: item.selfAid,
+                peerKey: formatPeerKey('aun', item.groupId),
+            }, { cache: true, expand: true });
+            const resources = {};
+            if (config.groupRules?.mode !== 'ignore') {
+                try {
+                    const synced = await syncGroupRulesContext({ selfAid: item.selfAid, groupId: item.groupId, channel: 'aun' });
+                    if (synced.groupRulesPath && fs.existsSync(synced.groupRulesPath)) {
+                        resources.groupRules = fs.readFileSync(synced.groupRulesPath, 'utf8');
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[MessageBridge] Decision context group rules unavailable: ${String(error)}`);
+                }
+            }
+            const personalPath = path.join(agentDir(item.selfAid), 'personal', 'personal.md');
+            if (fs.existsSync(personalPath))
+                resources.personal = fs.readFileSync(personalPath, 'utf8');
+            if (item.projectPath) {
+                const files = [];
+                let current = path.resolve(item.projectPath);
+                while (true) {
+                    const candidate = path.join(current, 'AGENTS.md');
+                    if (fs.existsSync(candidate))
+                        files.unshift(candidate);
+                    const parent = path.dirname(current);
+                    if (parent === current)
+                        break;
+                    current = parent;
+                }
+                if (files.length > 0) {
+                    resources.projectInstructions = files.map(file => (`# ${path.relative(item.projectPath, file) || 'AGENTS.md'}\n${fs.readFileSync(file, 'utf8')}`)).join('\n\n');
+                }
+            }
+            return resources;
+        },
+        resolveQuietWindowMs: item => resolveEffective({
+            self: item.selfAid,
+            peerKey: formatPeerKey('aun', item.groupId),
+        }, { cache: true, expand: true }).autoMentionQuietWindowMs,
+        resolveMessageState: item => {
+            if (!item.messageId)
+                return 'missing';
+            if (item.sessionId) {
+                const state = this.messageQueue.getMessageState?.(item.sessionId, item.messageId, item.selfAid)?.state ?? 'missing';
+                if (state !== 'missing')
+                    return state;
+            }
+            return this.messageQueue.getMessageStateByMessageId?.(item.messageId, item.selfAid, {
+                channelId: item.groupId,
+                groupId: item.groupId,
+                threadId: item.threadId || '',
+            })?.state ?? 'missing';
+        },
+        resolveProcessing: item => {
+            if (!item.sessionId)
+                return !!item.mainSessionBusy;
+            return (this.messageQueue.isProcessing?.(item.sessionId) ?? false)
+                || (this.messageQueue.getQueueLength?.(item.sessionId) ?? 0) > 0;
+        },
+    });
     debouncers = new Map();
     defaultDebounce;
     /** Serializes session selection/renewal with inbound log admission per route. */
@@ -115,6 +194,7 @@ export class MessageBridge {
     menuTokenStore = new MenuTokenStore();
     handoffRuntime;
     sessionRenewService;
+    diagnosticRouter;
     aidStatsCollector;
     contactBindRuntimeChecker;
     interactionRouter;
@@ -129,6 +209,13 @@ export class MessageBridge {
         this.processOwnersProvider = processOwnersProvider;
         this.defaultDebounce = defaultDebounce ?? 0;
         this.sessionRenewService = new SessionRenewService(sessionManager, processor, { eventBus });
+        this.diagnosticRouter = new DiagnosticSessionRouter(sessionManager, async (sessionId) => {
+            // Revoke in the router first, then clear pending work before awaiting the
+            // runner interruption. Delayed debounce and recovery are fenced below.
+            this.messageQueue.clearBySession(sessionId);
+            this.messageQueue.markActiveTerminal(sessionId, 'stop');
+            await this.processor.interruptSession(sessionId, 'stop');
+        });
     }
     /** Inject EvolAgentRegistry so owner lookups/writes route to agent.json for agent-owned channels. */
     setAgentRegistry(registry) {
@@ -520,6 +607,12 @@ export class MessageBridge {
         }
         return true;
     }
+    async sendAdmissionMenuResponse(context, adapter, channel, msg, response) {
+        if (!consumeAdmissionReplyBudget(context))
+            return false;
+        await this.sendMenuResponse(adapter, channel, msg, response);
+        return true;
+    }
     /** Controls handled before the normal slash handler still need structured group feedback. */
     async sendSlashControlReply(channel, msg, sendReply, payload, adapter = this.processor.getChannelInfo?.(channel)?.adapter) {
         if (msg.chatType === 'group' && adapter?.send) {
@@ -757,6 +850,12 @@ export class MessageBridge {
                 const conversationId = chatType === 'group' ? (msg.groupId || msg.channelId) : msg.peerId;
                 const selfAid = msg.selfAID || owningAgent?.aid || parsedChannelKey?.selfAID;
                 const resolvedChannelType = msg.channelType || parsedChannelKey?.type || effectiveChannelType;
+                const menuControl = resolvedChannelType === 'aun'
+                    ? parseMenuControl(content)
+                    : { isMenu: false };
+                const isPrivateMenuTokenRequest = menuControl.isMenu
+                    && menuControl.type === 'menu.token.request'
+                    && chatType === 'private';
                 const admissionRoute = [
                     resolvedChannelType,
                     selfAid || '',
@@ -793,7 +892,8 @@ export class MessageBridge {
                         if (chatType === 'private' && !peerType) {
                             peerType = PeerIdentityCache.get('aun', primaryId, agentDir(selfAid))?.type;
                         }
-                        if (chatType === 'private'
+                        if (!menuControl.isMenu
+                            && chatType === 'private'
                             && REJECTABLE_PEER_TYPES.has(String(peerType || '').trim().toLowerCase())) {
                             await this.sendAdmissionControlReply(admissionPreflight.context, msg, sendReply, CONTACT_REJECTION_NOTICE);
                         }
@@ -831,11 +931,23 @@ export class MessageBridge {
                     return;
                 }
                 const admissionDecision = evaluateOrdinaryInboundAdmission(admissionPreflight.context);
-                if (!admissionDecision.allow) {
+                if (!admissionDecision.allow && !isPrivateMenuTokenRequest) {
                     if (chatType === 'private') {
-                        const notice = this.admissionDeniedNotice(admissionDecision.context, resolvedChannelType);
-                        if (notice) {
-                            await this.sendAdmissionControlReply(admissionDecision.context, msg, sendReply, notice);
+                        if (menuControl.isMenu) {
+                            if (hasValidMenuId(menuControl)) {
+                                const header = { id: menuControl.id, ...(menuControl.name?.trim() ? { name: menuControl.name } : {}) };
+                                await this.sendAdmissionMenuResponse(admissionDecision.context, adapter, channelName, msg, menuFailure(header, {
+                                    code: 'ROLE_ACCESS_DENIED',
+                                    message: this.admissionDeniedNotice(admissionDecision.context, resolvedChannelType)
+                                        ?? '当前不接受陌生人消息。',
+                                }));
+                            }
+                        }
+                        else {
+                            const notice = this.admissionDeniedNotice(admissionDecision.context, resolvedChannelType);
+                            if (notice) {
+                                await this.sendAdmissionControlReply(admissionDecision.context, msg, sendReply, notice);
+                            }
                         }
                     }
                     logger.info(`[MessageBridge] Inbound admission denied before business routing: self=${selfAid} actor=${actorId ?? '<none>'} channel=${channelKey} reason=${admissionDecision.reason}`);
@@ -844,9 +956,6 @@ export class MessageBridge {
                 // Menu is a protocol control plane. Its parsing and response path must
                 // remain available throughout the agent lifecycle; lifecycle gates
                 // ordinary model execution, not protocol handling.
-                const menuControl = resolvedChannelType === 'aun'
-                    ? parseMenuControl(content)
-                    : { isMenu: false };
                 let menuResponseWarning;
                 if (menuControl.isMenu) {
                     // Menu is an AUN private control plane. Group messages must never
@@ -971,6 +1080,37 @@ export class MessageBridge {
                     await this.sendAccessDenied(adapter, channelName, msg, sendReply);
                     return;
                 }
+                // Diagnostic invitations carry their own execution boundary. Resolve
+                // that boundary before ordinary command/session routing so a new case
+                // cannot inherit an older Codex thread.
+                let diagnosticSession;
+                if (selfAid === DIAGNOSTIC_AGENT_AID && resolvedChannelType === 'aun'
+                    && chatType === 'private' && msg.source !== 'handoff') {
+                    try {
+                        const diagnosticEvent = parseDiagnosticEvent(content);
+                        if (diagnosticEvent) {
+                            releaseAdmission = await this.acquireAdmission(admissionRoute);
+                            const routed = await this.diagnosticRouter.route({
+                                event: diagnosticEvent, message: msg, channel: channelName,
+                                channelType: resolvedChannelType, selfAid,
+                                chatDir: chatDirPath(resolvePaths().sessionsDir, resolvedChannelType, msg.channelId, selfAid, channelName),
+                                projectPath: owningAgent?.projectPath ?? this.defaultProjectPath,
+                                baseagent: owningAgent?.baseagent,
+                            });
+                            if ('notice' in routed) {
+                                await sendReply(msg.channelId, routed.notice, msg.replyContext);
+                                return;
+                            }
+                            diagnosticSession = routed.session;
+                            diagnosticSession.identity = identity;
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`[MessageBridge] Diagnostic admission failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+                        await sendReply(msg.channelId, '诊断会话隔离未完成，本次未执行诊断。请检查诊断端日志后重试。', msg.replyContext);
+                        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.
@@ -1003,10 +1143,6 @@ export class MessageBridge {
                         await reject('用法：/fa <提示词> 或 /fullaccess <提示词>');
                         return;
                     }
-                    if (!isFullAccessEnabled()) {
-                        await reject('fullaccess 功能未启用，请先设置 daemon.json.fullaccess.enabled=true');
-                        return;
-                    }
                     if (!authSubject.isDaemonOwner || !authSubject.principalId) {
                         await reject('仅可信 daemon-owner 可以使用 fullaccess');
                         return;
@@ -1073,6 +1209,27 @@ export class MessageBridge {
                 // 2. 命令快速路径（去除引用前缀后检查，兼容话题中引用上文的情况）
                 const contentForCmd = content.replace(/^(>[^\n]*\n)+\n?/, '').trim();
                 const cmdContent = contentForCmd || content;
+                let autoMode = false;
+                if (resolvedChannelType === 'aun' && chatType === 'group' && selfAid && msg.source !== 'handoff') {
+                    try {
+                        const config = resolveEffective({ self: selfAid, peerKey: formatPeerKey('aun', msg.groupId || msg.channelId) }, { cache: true, expand: true });
+                        autoMode = config.mentionMode === 'auto';
+                    }
+                    catch (error) {
+                        logger.warn(`[MessageBridge] Auto mention configuration unavailable: ${String(error)}`);
+                    }
+                }
+                if (autoMode && !msg.isMentioned && /^\//.test(cmdContent)) {
+                    const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', msg.channelId, selfAid || '', channelKey);
+                    appendMessageLog(chatDir, buildInboundEntry({
+                        from: msg.peerId, to: selfAid || '', chatType: 'group', groupId: msg.groupId,
+                        threadId: msg.threadId, msgId: msg.messageId, content: msg.messageLogContent ?? content,
+                        timestamp: receivedAt, msgType: 'command', groupAttention: 'command', groupDelivery: 'filtered',
+                    }));
+                    if (msg.messageId)
+                        adapter?.acknowledge?.(msg.messageId).catch(() => { });
+                    return;
+                }
                 if (msg.source !== 'handoff' && !executionPermissionOverride) {
                     const groupGuard = guardGroupSlashCommand(cmdContent, chatType);
                     if (groupGuard?.kind === 'command.error') {
@@ -1154,6 +1311,72 @@ export class MessageBridge {
                     logger.info(`[MessageBridge] Thread creation denied (silent drop): channel=${channelName} channelId=${msg.channelId} thread=${msg.threadId} sender=${msg.peerId}`);
                     return;
                 }
+                let autoResult;
+                if (autoMode && selfAid && msg.groupId && !executionPermissionOverride
+                    && !isCmd && !/\[EvolCore\.(receive|reply|agent)\]/.test(content)) {
+                    const attentionItem = {
+                        value: msg, selfAid, groupId: msg.groupId, threadId: msg.threadId || '', channelKey,
+                        sessionId: msg.replyContext?.sessionId
+                            ?? this.sessionManager.getActiveSessionSync?.(channelName, msg.channelId, resolvedChannelType, selfAid)?.id,
+                        projectPath: owningAgent?.projectPath ?? this.defaultProjectPath,
+                        messageId: msg.messageId, sender: msg.peerId, role: identity.role,
+                        mentions: (msg.mentions ?? []).flatMap(mention => {
+                            if (typeof mention.aid === 'string')
+                                return [mention.aid];
+                            return mention.scope === 'all' ? ['all'] : [];
+                        }),
+                        content, receivedAt,
+                        mainSessionBusy: (() => {
+                            try {
+                                const active = this.sessionManager.getActiveSessionSync?.(channelName, msg.channelId, resolvedChannelType, selfAid);
+                                return !!active && ((this.messageQueue.isProcessing?.(active.id) ?? false)
+                                    || (this.messageQueue.getQueueLength?.(active.id) ?? 0) > 0);
+                            }
+                            catch {
+                                return false;
+                            }
+                        })(),
+                    };
+                    if (msg.isMentioned) {
+                        autoResult = {
+                            decision: 'interrupt', source: 'mention', leader: true, batch: [attentionItem], background: [],
+                            current: [{ source: 'current', message_id: msg.messageId ?? null, sender: msg.peerId,
+                                    role: identity.role, mentions: attentionItem.mentions,
+                                    timestamp: new Date(receivedAt).toISOString(), content }],
+                        };
+                    }
+                    else {
+                        if (msg.messageId)
+                            adapter?.acknowledge?.(msg.messageId).catch(() => { });
+                        autoResult = await this.autoMentionGate.offer(attentionItem);
+                        if (autoResult.decision === 'ignore') {
+                            try {
+                                const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', msg.channelId, selfAid, channelKey);
+                                appendMessageLogStrict(chatDir, buildInboundEntry({
+                                    from: msg.peerId, to: selfAid, chatType: 'group', groupId: msg.groupId,
+                                    threadId: msg.threadId, msgId: msg.messageId, content: msg.messageLogContent ?? content,
+                                    permMode: identity.role, timestamp: receivedAt, receivedAt: msg.receivedAt,
+                                    gatewaySeq: msg.gatewaySeq, encrypt: msg.encrypted, peerName: msg.peerName,
+                                    peerType: msg.peerType, msgType: msg.msgType, payloadType: msg.payloadType,
+                                    payloadSummary: msg.payloadSummary,
+                                    groupAttention: autoResult.source === 'fallback' ? 'auto-fallback' : 'auto-ignore',
+                                    groupDelivery: 'filtered',
+                                    attentionDecision: { ...autoResult.details, decision: 'ignore', source: autoResult.source },
+                                }), true);
+                                return;
+                            }
+                            catch (error) {
+                                logger.warn(`[MessageBridge] Auto ignore history append failed, responding: ${String(error)}`);
+                                autoResult = { ...autoResult, decision: 'interrupt', source: 'fallback', leader: true, batch: [attentionItem] };
+                            }
+                        }
+                        if (!autoResult.leader)
+                            return;
+                    }
+                }
+                const attentionDecision = autoResult
+                    ? { ...autoResult.details, decision: autoResult.decision, source: autoResult.source }
+                    : undefined;
                 const metadata = {};
                 // 话题会话创建时写入 replyContext（用于 threadId 路由）；主会话不写（避免群聊覆盖）
                 if (msg.threadId && msg.replyContext)
@@ -1186,9 +1409,10 @@ export class MessageBridge {
                 // transaction. Without this per-route single-flight, a second message
                 // can observe the just-renewed empty session before the first message
                 // has been appended and create another renewed session.
-                releaseAdmission = await this.acquireAdmission(admissionRoute);
+                if (!releaseAdmission)
+                    releaseAdmission = await this.acquireAdmission(admissionRoute);
                 const hadMainSession = msg.threadId ? true : this.sessionManager.hasMainSession(channelName, msg.channelId, msg.channelType || effectiveChannelType, msg.selfAID || selfAid);
-                let session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity, readTopicLable(msg) ?? readTopicLable(msg.replyContext?.metadata));
+                let session = diagnosticSession ?? await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, this.extractTopicName(msg), msg.peerId, chatType, owningAgent?.baseagent, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType, identity, readTopicLabel(msg) ?? readTopicLabel(msg.replyContext?.metadata), readTopicStatus(msg) ?? readTopicStatus(msg.replyContext?.metadata));
                 if (session.threadId && typeof this.messageQueue.reserveSessionIngress === 'function') {
                     releaseSessionIngress = this.messageQueue.reserveSessionIngress(session.id);
                 }
@@ -1201,7 +1425,7 @@ export class MessageBridge {
                 const inboundCausation = restoredCausation
                     ? deriveCausation(restoredCausation)
                     : createRootCausation();
-                const renewResult = await this.sessionRenewService.resolve({
+                const renewResult = session.metadata?.diagnostic ? { session } : await this.sessionRenewService.resolve({
                     session,
                     channelName,
                     channelType: msg.channelType || effectiveChannelType,
@@ -1218,6 +1442,32 @@ export class MessageBridge {
                     causation: inboundCausation,
                 });
                 session = renewResult.session;
+                if ('renewed' in renewResult && renewResult.renewed) {
+                    const notice = '已自动切换到新会话';
+                    try {
+                        if (adapter?.send) {
+                            await adapter.send(buildEnvelope({
+                                taskId: `session-renew-${randomBytes(5).toString('hex')}`,
+                                sessionId: session.id,
+                                channel: channelName,
+                                channelId: msg.channelId,
+                                agentName: owningAgent?.name ?? selfAid ?? '<unknown>',
+                                chatmode: 'interactive',
+                                replyContext: msg.replyContext,
+                            }), {
+                                kind: 'system.notice',
+                                text: notice,
+                                subtype: 'session.auto-renewed',
+                            });
+                        }
+                        else {
+                            await sendReply(msg.channelId, notice, msg.replyContext);
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`[MessageBridge] Failed to send automatic session-renew notice: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
                 // 4. 群聊发送者标注由消息渲染层（message-renderer）逐条承担，不再在此硬编码前缀，
                 //    消息日志因此保存干净原文。policy.messagePrefix 暂保留（未来清理）。
                 // 5. 构造完整消息（channel 字段存实例名，用于 session 精确匹配）
@@ -1244,15 +1494,45 @@ export class MessageBridge {
                     mentions: msg.mentions, mentionAids: msg.mentionAids, threadId: msg.threadId,
                     isMentioned: msg.isMentioned,
                     topicName: this.extractTopicName(msg),
-                    lable: session.lable,
+                    label: session.label,
+                    topicStatus: session.topicStatus,
                     replyContext: msg.replyContext,
                     source: msg.source,
                     ...(executionPermissionOverride ? { executionPermissionOverride } : {}),
                     boundSessionId: session.id,
                     resolvedIdentity: identity,
                     mentionMode: msg.mentionMode,
+                    ...(autoResult && autoResult.decision !== 'ignore' ? { attentionPolicy: autoResult.decision } : {}),
+                    ...(autoResult ? { autoMentionBatch: true } : {}),
                     causation: inboundCausation,
                 };
+                if (autoResult && autoResult.batch.length > 1) {
+                    fullMessage.content = autoResult.batch.map(item => item.content).join('\n');
+                    fullMessage.sourceMessageIds = autoResult.batch.flatMap(item => item.messageId ? [item.messageId] : []);
+                    fullMessage.items = autoResult.batch.map(item => ({
+                        peerId: item.sender, peerName: item.value.peerName, peerType: item.value.peerType,
+                        peerRole: item.role, content: item.content,
+                        mentions: item.value.mentions, mentionAids: item.value.mentionAids,
+                        images: item.value.images, timestamp: item.receivedAt,
+                        receivedAt: item.value.receivedAt, gatewaySeq: item.value.gatewaySeq,
+                        encrypted: item.value.encrypted,
+                        sameDevice: item.value.sameDevice, sameNetwork: item.value.sameNetwork,
+                        sameEgressIp: item.value.sameEgressIp,
+                    }));
+                    fullMessage.images = autoResult.batch.flatMap(item => item.value.images ?? []);
+                    fullMessage.mentions = autoResult.batch.flatMap(item => item.value.mentions ?? []);
+                    fullMessage.timestamp = autoResult.batch[0].receivedAt;
+                    fullMessage.receivedAt = autoResult.batch[0].receivedAt;
+                    fullMessage.encrypted = autoResult.batch.some(item => item.value.encrypted === true) ? true : fullMessage.encrypted;
+                    if (fullMessage.encrypted && fullMessage.replyContext) {
+                        fullMessage.replyContext = {
+                            ...fullMessage.replyContext,
+                            metadata: { ...fullMessage.replyContext.metadata, encrypted: true },
+                        };
+                    }
+                    if (!autoResult.batch.every(item => item.role === identity.role))
+                        fullMessage.batchRole = 'visitor';
+                }
                 recordCausationSpan(inboundCausation, 'message.inbound', {
                     status: 'completed',
                     refs: { messageId: msg.messageId, sessionId: session.id },
@@ -1285,6 +1565,11 @@ export class MessageBridge {
                             msgType: msg.msgType,
                             payloadType: msg.payloadType,
                             payloadSummary: msg.payloadSummary,
+                            groupAttention: autoResult?.source === 'mention' ? 'auto-mention'
+                                : autoResult?.source === 'fallback' ? 'auto-fallback'
+                                    : autoResult?.decision === 'defer' ? 'auto-defer'
+                                        : autoResult ? 'auto-interrupt' : undefined,
+                            attentionDecision,
                         }) };
                 })();
                 let handoffCandidate = false;
@@ -1317,6 +1602,23 @@ export class MessageBridge {
                 }
                 if (!handoffCandidate)
                     appendMessageLog(inboundEntry.chatDir, inboundEntry.entry);
+                if (autoResult && autoResult.batch.length > 1) {
+                    for (const item of autoResult.batch.slice(0, -1)) {
+                        const member = item.value;
+                        appendMessageLog(inboundEntry.chatDir, buildInboundEntry({
+                            from: item.sender, to: selfAid || '', sessionId: session.id,
+                            threadId: session.threadId || null, chatType: 'group', groupId: msg.groupId,
+                            msgId: item.messageId, content: member.messageLogContent ?? item.content,
+                            permMode: item.role, timestamp: item.receivedAt,
+                            receivedAt: member.receivedAt, gatewaySeq: member.gatewaySeq,
+                            encrypt: member.encrypted, peerName: member.peerName, peerType: member.peerType,
+                            msgType: member.msgType, payloadType: member.payloadType,
+                            payloadSummary: member.payloadSummary,
+                            groupAttention: autoResult?.decision === 'defer' ? 'auto-defer' : 'auto-interrupt',
+                            attentionDecision,
+                        }));
+                    }
+                }
                 // The authoritative session choice is now paired with its first
                 // conversation record. Release before waiting for queue completion so
                 // later group messages can still exercise the normal interrupt/FIFO
@@ -1335,16 +1637,24 @@ export class MessageBridge {
                     adapter?.acknowledge?.(fullMessage.messageId).catch(() => { });
                 }
                 const isInterrupt = chatType !== 'group' && !handoffCandidate;
+                const attentionPolicy = fullMessage.attentionPolicy;
+                const shouldInterrupt = isInterrupt || attentionPolicy === 'interrupt';
                 const enqueueAgentName = owningAgent?.name ?? '<unknown>';
                 const selfAID = session.selfAID;
                 const doEnqueue = async (m) => {
+                    // A cancellation can arrive while this message is being debounced.
+                    if (!isDiagnosticSessionActive(session, this.sessionManager.getChatDir(session)))
+                        return;
                     const enqueue = handoffCandidate ? this.messageQueue.enqueuePersisted.bind(this.messageQueue) : this.messageQueue.enqueue.bind(this.messageQueue);
                     try {
                         return await enqueue(session.id, m, session.projectPath, {
-                            interruptible: isInterrupt,
-                            interruptSamePeer: !isInterrupt, // 群聊：同人连发且队列无他人时打断
+                            interruptible: shouldInterrupt,
+                            attentionPolicy,
+                            interruptSamePeer: !shouldInterrupt && !attentionPolicy, // 旧群聊路径保留同人连发打断
+                            priority: attentionPolicy === 'interrupt',
                             agentName: enqueueAgentName,
-                            role: !isInterrupt ? (session.identity?.role ?? 'none') : undefined,
+                            role: chatType === 'group' ? (session.identity?.role ?? 'none')
+                                : (!shouldInterrupt ? (session.identity?.role ?? 'none') : undefined),
                             sessionKeyField: session.sessionKey,
                             selfAID, // ← 传递 selfAID，用于队列隔离
                             onPersisted: releaseIngress,
@@ -1704,7 +2014,7 @@ export class MessageBridge {
             ...(msg.peerDeviceId ? { toDeviceId: msg.peerDeviceId } : {}),
             metadata: {
                 ...(msg.replyContext?.metadata ?? {}),
-                ...evolMenuResponseTransportMetadata(msg.protectedHeaders?.sdk_version),
+                ...evolMenuResponseTransportMetadata(msg.protectedHeaders?.sdk_version, msg.protectedHeaders?.menu_volatile_v1),
                 ...(isAgentStorageMenuRequest(request) ? { encrypted: true } : {}),
             },
         };

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

@@ -345,6 +345,7 @@ export function buildInboundEntry(opts) {
         payloadSummary: opts.payloadSummary,
         groupAttention: opts.groupAttention,
         groupDelivery: opts.groupDelivery,
+        attentionDecision: opts.attentionDecision,
         content: opts.content,
         replyTo: opts.replyTo ?? null,
         agent: null,