evolclaw 3.2.0 → 3.4.0

package/dist/channels/aun.js

@@ -5,12 +5,13 @@ import path from 'path';
 import os from 'os';
 import { logger, localTimestamp } from '../utils/logger.js';
 import { LogWriter } from '../utils/log-writer.js';
-import { normalizeChannelInstances, getChannelShowActivities } from '../utils/channel-helpers.js';
+import { resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
 import { resolvePaths, getPackageRoot, agentMdPath as agentMdPathFn, agentDir as agentDirPath, resolveRoot } from '../paths.js';
 import { saveToUploads, sanitizeFileName, bufferToInboundImage } from '../utils/media-cache.js';
 import { appendAidEvent } from '../utils/instance-registry.js';
-import { appendMessageLog, buildOutboundEntry } from '../core/message/message-log.js';
+import { appendMessageLog, buildOutboundEntry, buildInboundEntry } from '../core/message/message-log.js';
 import { chatDirPath } from '../core/session/session-fs-store.js';
+import { appendHintAdd, appendHintRemove, parseInjectRequest } from '../core/message/pending-hints.js';
 import { appendAidLifecycle } from '../aun/aid/identity.js';
 import { getAidStore, loadClient, SLOT } from '../aun/aid/store.js';
 import { loadAgent, saveAgent } from '../config-store.js';
@@ -87,6 +88,7 @@ export function aunOptsToInbound(opts, channel, channelType) {
         replyContext: opts.replyContext,
         source: opts.source,
         images: opts.images,
+        dispatchMode: opts.dispatchMode,
     };
 }
 export class AUNChannel {
@@ -115,14 +117,16 @@ export class AUNChannel {
         // 便于 jq 过滤：`jq 'select(.task_id == "task-xxx")'`
         const d = (data && typeof data === 'object') ? data : {};
         const payload = d.payload ?? {};
+        // 入站事件（IN）路由字段在 d.envelope.*（SDK 0.5.*）；出站 params（OUT）字段在顶层。两者兼顾。
+        const env = (d.envelope && typeof d.envelope === 'object') ? d.envelope : {};
         const topContext = {
             self_aid: this._aid ?? this.config.aid,
         };
         // peer / group 识别
-        const peerAid = d.to ?? d.from ?? d.sender_aid ?? payload.to;
+        const peerAid = env.to ?? env.from ?? d.to ?? d.from ?? d.sender_aid ?? payload.to;
         if (peerAid)
             topContext.peer_aid = peerAid;
-        const groupId = d.group_id ?? payload.group_id;
+        const groupId = env.group_id ?? d.group_id ?? payload.group_id;
         if (groupId)
             topContext.group_id = groupId;
         // task_id / chatmode（message.send / thought.put / status 都可能有）
@@ -175,6 +179,7 @@ export class AUNChannel {
      *  - 数字群号：{group_no}.{issuer}（如 11117.agentid.pub）
      *  - 兼容旧格式：grp_xxx、g-xxx.agentid.pub
      */
+    /** 判断 channelId 是否群组 ID（public：plugin adapter 闭包需调用） */
     isGroupId(id) {
         return (id.startsWith('group.') && id.includes('/'))
             || /^\d+\./.test(id)
@@ -201,6 +206,20 @@ export class AUNChannel {
         const name = cached?.name;
         return name && name !== short ? `${short}(${name})` : short;
     }
+    notifyCardActionFailure(channelId, text, operatorId, threadId) {
+        if (!channelId) {
+            logger.warn(`${this.logPrefix()} Card action failure without channelId: ${text}`);
+            return;
+        }
+        const context = {};
+        if (threadId)
+            context.threadId = threadId;
+        if (operatorId && this.isGroupId(channelId))
+            context.peerId = operatorId;
+        void this.sendMessage(channelId, text, context).catch((err) => {
+            logger.error(`${this.logPrefix()} Failed to send card action error:`, err);
+        });
+    }
     extractTextPayload(payload, channelId, senderAid) {
         if (typeof payload === 'string')
             return payload;
@@ -215,27 +234,25 @@ export class AUNChannel {
                 if (cardInfo) {
                     const actionValue = typeof obj.value === 'string' ? obj.value
                         : typeof obj.action_value === 'string' ? obj.action_value : text;
+                    const threadId = typeof obj.thread_id === 'string' ? obj.thread_id : undefined;
+                    // 卡片点击者身份：只信认证信封（senderAid 参数，由调用方从 msg.from / msg.sender_aid 提取）。
+                    // payload 自报字段（from / sender_aid / user_id）不可信，可被客户端伪造，不读取。
+                    // 两类卡片共用：CommandCard → 伪入站消息的 peerId，ActionInteraction → operatorId。
+                    const cardClickerAid = senderAid || channelId || '';
                     if (cardInfo.isCommandCard) {
                         // CommandCard：action_value 是完整 slash 命令，构造伪入站消息
                         this.cardMessageIdMap.delete(cardMsgId);
                         if (this.messageHandler && actionValue.startsWith('/')) {
                             const chatType = channelId ? (this.isGroupId(channelId) ? 'group' : 'private') : 'private';
-                            // 卡片点击者身份：优先 payload.from / payload.sender_aid / payload.user_id，
-                            // 再 fallback 到外层 senderAid，最后用 cardInfo 中记录的原始命令发起者
-                            const cardClickerAid = (typeof obj.from === 'string' && obj.from)
-                                || (typeof obj.sender_aid === 'string' && obj.sender_aid)
-                                || (typeof obj.user_id === 'string' && obj.user_id)
-                                || senderAid
-                                || cardInfo.initiatorAid
-                                || channelId || '';
-                            // Initiator 校验：群聊中仅卡片发起者可操作（与飞书行为对齐）
-                            if (cardInfo.initiatorAid && cardClickerAid
-                                && cardClickerAid !== cardInfo.initiatorAid
-                                && !this.isGroupId(cardClickerAid)) {
+                            // Initiator 校验：仅群聊需要（私聊信道一对一，点击者恒为对端 = initiator）。
+                            // 身份只信认证信封提取的 cardClickerAid，非 payload 自报。
+                            if (chatType === 'group' && cardInfo.initiatorAid && cardClickerAid
+                                && cardClickerAid !== cardInfo.initiatorAid) {
                                 logger.info(`${this.logPrefix()} CommandCard rejected: clicker=${cardClickerAid} initiator=${cardInfo.initiatorAid} mid=${cardMsgId}`);
+                                this.notifyCardActionFailure(channelId, '⚠️ 仅卡片发起者可操作', cardClickerAid, threadId);
                                 return '';
                             }
-                            this.messageHandler({
+                            Promise.resolve(this.messageHandler({
                                 channelId: channelId || '',
                                 chatType,
                                 content: actionValue,
@@ -243,8 +260,18 @@ export class AUNChannel {
                                 peerName: typeof obj.label === 'string' ? obj.label : typeof obj.action_label === 'string' ? obj.action_label : undefined,
                                 messageId: `card-trigger-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
                                 source: 'card-trigger',
+                            })).catch((err) => {
+                                logger.error(`${this.logPrefix()} CommandCard handler failed: action=${actionValue} mid=${cardMsgId}`, err);
+                                const message = err instanceof Error && err.message ? err.message : String(err || '未知错误');
+                                this.notifyCardActionFailure(channelId, `❌ 操作失败: ${message}`, cardClickerAid, threadId);
                             });
                         }
+                        else if (!this.messageHandler) {
+                            this.notifyCardActionFailure(channelId, '❌ 操作失败：命令处理器未就绪', cardClickerAid, threadId);
+                        }
+                        else {
+                            this.notifyCardActionFailure(channelId, '❌ 操作失败：无效的卡片命令', cardClickerAid, threadId);
+                        }
                     }
                     else {
                         // ActionInteraction：走 interactionCallback → InteractionRouter
@@ -256,12 +283,22 @@ export class AUNChannel {
                                 id: cardInfo.requestId,
                                 action: actionValue,
                                 values: { text, action_label: obj.label ?? obj.action_label, behavior: obj.behavior },
+                                operatorId: cardClickerAid || undefined,
                             });
                         }
+                        else {
+                            this.notifyCardActionFailure(channelId, '❌ 操作失败：交互处理器未就绪', cardClickerAid, threadId);
+                        }
                     }
                 }
+                else if (this.ownedCardMsgIds.has(cardMsgId)) {
+                    // 本 agent 发出的卡片，但 entry 已过期（20min TTL）
+                    logger.debug(`${this.logPrefix()} action_card_reply expired: cardMsgId=${cardMsgId}`);
+                    this.notifyCardActionFailure(channelId, '⚠️ 卡片已失效，请重新发起');
+                }
                 else {
-                    logger.debug(`${this.logPrefix()} action_card_reply dropped: cardMsgId=${cardMsgId} hasCallback=${!!this.interactionCallback}`);
+                    // 非本 agent 发出的卡片（broadcast 模式下其他 agent 的卡）→ 静默忽略
+                    logger.debug(`${this.logPrefix()} action_card_reply ignored (not owned): cardMsgId=${cardMsgId}`);
                 }
                 // 始终返回空字符串，阻止消息分发给 agent
                 return '';
@@ -402,6 +439,13 @@ export class AUNChannel {
             .replace(/[ \t]+/g, ' ')
             .trim();
     }
+    /** 剥离正文中所有 @aid（用于命令判定 + 命令消息进 agent 前的清理）。 */
+    stripAllMentions(text) {
+        return text
+            .replace(/(^|\s)@[\w.-]+(?=$|\s|[.,!?;:，。！？；：]|[\u4e00-\u9fff])/g, '$1')
+            .replace(/[ \t]+/g, ' ')
+            .trim();
+    }
     extractMentionAids(mentions) {
         const aids = [];
         for (const m of mentions) {
@@ -468,6 +512,8 @@ export class AUNChannel {
     interactionCallback;
     // action_card message_id → { requestId, isCommandCard }（用于关联 action_card_reply）
     cardMessageIdMap = new Map();
+    /** 本 agent 曾发出过的卡片 msgId（只增不删，用于区分"过期失效"vs"他人发的卡"） */
+    ownedCardMsgIds = new Set();
     dispatchModeResolver;
     static PROACTIVE_ALLOW_TYPES = new Set([
         'text', 'quote', 'image', 'video', 'voice', 'file', 'json',
@@ -477,6 +523,8 @@ export class AUNChannel {
     static MENU_REQUEST_TYPES = new Set([
         'menu.list', 'menu.query', 'menu.options', 'menu.update', 'menu.action',
     ]);
+    /** 观察者插话请求类型（owner → agent.AID）。详见 docs/observer-insert-design.md。 */
+    static INJECT_REQUEST_TYPE = 'observer.inject';
     // Reconnect state
     // SDK 自己跑无限指数退避（1s → 5min）；TS 层只在 SDK 够不到的两类场景下接管：
     //  1. flap：短命 connected 反复出现（SDK 不记忆跨轮 base delay，会从 1s 重新开始）
@@ -504,6 +552,7 @@ export class AUNChannel {
     // AID 连接状态（供 status 命令聚合展示）
     aidState;
     aidStatsCollector;
+    outboxInFlight = new Set();
     constructor(config) {
         this.config = config;
         this.agentDir = agentDirPath(config.aid);
@@ -627,8 +676,9 @@ export class AUNChannel {
         if (!this.config.pureIdentity) {
             client.on('group.message_created', (data) => {
                 this.trace('IN', 'group.message_created', data);
-                const gid = (data && typeof data === 'object') ? data.group_id ?? '' : '';
-                const sender = (data && typeof data === 'object') ? data.sender_aid ?? '' : '';
+                const env = (data && typeof data === 'object') ? data.envelope ?? {} : {};
+                const gid = env.group_id ?? '';
+                const sender = env.from ?? '';
                 logger.debug(`${this.logPrefix()}[DIAG] group.message_created: group_id=${gid} sender=${sender}`);
                 this.handleIncomingGroupMessage(data);
             });
@@ -659,14 +709,34 @@ export class AUNChannel {
         client.on('message.undecryptable', (data) => {
             this.trace('IN', 'message.undecryptable', data);
             const d = data;
-            logger.warn(`${this.logPrefix()} Message undecryptable: from=${d.from} mid=${d.message_id} err=${d._decrypt_error}`);
+            const env = (d.envelope && typeof d.envelope === 'object') ? d.envelope : {};
+            logger.warn(`${this.logPrefix()} Message undecryptable: from=${env.from} mid=${d.message_id} err=${d._decrypt_error}`);
         });
         // pureIdentity（控制 AID）：不注册 group 解密失败监听
         if (!this.config.pureIdentity) {
             client.on('group.message_undecryptable', (data) => {
                 this.trace('IN', 'group.message_undecryptable', data);
                 const d = data;
-                logger.warn(`${this.logPrefix()} Group message undecryptable: group=${d.group_id} from=${d.from} mid=${d.message_id} err=${d._decrypt_error}`);
+                const env = (d.envelope && typeof d.envelope === 'object') ? d.envelope : {};
+                logger.warn(`${this.logPrefix()} Group message undecryptable: group=${env.group_id} from=${env.from} mid=${d.message_id} err=${d._decrypt_error}`);
+            });
+            // 群消息撤回（SDK 0.4.10 在线 push 通道）：与私聊 message.recalled 同构，
+            // 逐个 message_id 交给 recallHandler → msgBridge.cancel（排队中删除 / 处理中中断）。
+            client.on('group.message_recalled', (data) => {
+                this.trace('IN', 'group.message_recalled', data);
+                if (data && typeof data === 'object') {
+                    const d = data;
+                    const env = (d.envelope && typeof d.envelope === 'object') ? d.envelope : {};
+                    const ids = d.message_ids;
+                    if (Array.isArray(ids)) {
+                        for (const id of ids) {
+                            if (typeof id === 'string') {
+                                logger.info(`${this.logPrefix()} Group message recalled: group=${env.group_id ?? ''} mid=${id}`);
+                                this.recallHandler?.(id);
+                            }
+                        }
+                    }
+                }
             });
         }
         // Authenticate（拿权威 gateway 用于日志/状态；connect 内部也会复用 token）
@@ -1004,15 +1074,23 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         if (!data || typeof data !== 'object')
             return;
         const msg = data;
-        const fromAid = msg.from ?? '';
+        // SDK 0.5.* 移除了顶层 from/to/group_id/encrypted 等别名，统一从 msg.envelope.* 读取。
+        // message_id / seq / payload / same_* 等仍是顶层独立字段，不在 envelope 内。
+        const env = (msg.envelope && typeof msg.envelope === 'object') ? msg.envelope : {};
+        const fromAid = env.from ?? '';
         const payload = msg.payload ?? '';
-        const text = this.extractTextPayload(payload, fromAid);
+        const text = this.extractTextPayload(payload, fromAid, fromAid);
         const threadId = typeof payload === 'object' && payload !== null ? payload.thread_id : undefined;
         const messageId = msg.message_id ?? '';
         const seq = msg.seq;
         // Observer forward (inbound)：在所有过滤之前转发原始明文 payload。
         // forwardInbound 内部排除 self-echo 与 from-owner。
-        this.forwardInbound(fromAid, seq, payload);
+        // 显式排除 observer.inject：它是 owner 对本 agent 的控制消息，不应镜像给观察者
+        // （即便日后 from-owner 排除规则调整，也不会泄漏）。
+        const inboundType = (payload && typeof payload === 'object') ? payload.type : undefined;
+        if (inboundType !== AUNChannel.INJECT_REQUEST_TYPE) {
+            this.forwardInbound(msg);
+        }
         // 回声过滤：自己发出的消息会被 gateway fanout 回来，
         // 只有 from_aid == self 且 chat_id 不匹配时才丢弃（说明是其它实例发的）
         const msgChatId = typeof payload === 'object' && payload !== null && payload.chat_id;
@@ -1022,7 +1100,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             return;
         }
         // 记录入站消息加密状态，透传到出站 ReplyContext
-        const msgEncrypted = !!(msg.e2ee);
+        const msgEncrypted = !!env.encrypted;
         if (!msgEncrypted)
             this.plaintextRecv++;
         // Detect @mentions
@@ -1058,6 +1136,13 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             });
             return;
         }
+        // observer.inject：owner 插话。鉴权 from∈owners 后，以 target.channel_id 选 agent↔对端 会话，
+        // observer 插话（v0.3）：只落盘到 pending-hints，不进 Agent、不回 owner。详见 docs/observer-insert-design.md。
+        if (p2pPayloadType === AUNChannel.INJECT_REQUEST_TYPE) {
+            this.acknowledgeImmediately(messageId, seq);
+            this.handleObserverInject(fromAid, payload, displayName, peerIdentity.type);
+            return;
+        }
         // payload 类型白名单：信号类消息（status / event / thought 等）不进 Agent
         if (p2pPayloadType && !AUNChannel.PROACTIVE_ALLOW_TYPES.has(p2pPayloadType)) {
             this.acknowledgeImmediately(messageId, seq);
@@ -1068,10 +1153,13 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         logger.info(`${this.logPrefix()} P2P dispatched: from=${shortAid}(${displayName}) mid=${messageId} encrypt=${msgEncrypted} chatmode=${msgChatmode ?? 'none'} text=${finalText.slice(0, 60)}`);
         appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_in', aid: this.config.aid, from: fromAid, msgId: messageId, kind: 'text', len: finalText.length });
         const isSystemP2P = p2pPayloadType === 'event';
-        this.aidStatsCollector?.recordInbound(this.config.aid, fromAid, Buffer.byteLength(finalText, 'utf-8'), finalText, isSystemP2P, msgEncrypted, msgChatmode);
+        this.aidStatsCollector?.recordInbound(this.config.aid, fromAid, Buffer.byteLength(finalText, 'utf-8'), finalText, isSystemP2P, msgEncrypted, msgChatmode, isSystemP2P ? 'notify' : 'send');
         const replyContext = { metadata: { encrypted: msgEncrypted, chatmode: msgChatmode } };
         if (threadId)
             replyContext.threadId = threadId;
+        replyContext.peerId = fromAid;
+        if (messageId)
+            replyContext.replyToMessageId = messageId;
         this.dispatchMessage({
             channelId: chatId,
             userId: fromAid,
@@ -1094,8 +1182,11 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         if (!data || typeof data !== 'object')
             return;
         const msg = data;
-        const groupId = msg.group_id ?? '';
-        const senderAid = msg.sender_aid ?? '';
+        // SDK 0.5.* 移除了顶层 from/sender_aid/group_id/encrypted 等别名，统一从 msg.envelope.* 读取。
+        // message_id / seq / payload / same_* / dispatch_mode 等仍是顶层独立字段，不在 envelope 内。
+        const env = (msg.envelope && typeof msg.envelope === 'object') ? msg.envelope : {};
+        const groupId = env.group_id ?? '';
+        const senderAid = env.from ?? '';
         const payload = msg.payload ?? '';
         const text = this.extractTextPayload(payload, groupId, senderAid);
         const threadId = typeof payload === 'object' && payload !== null ? payload.thread_id : undefined;
@@ -1103,7 +1194,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const seq = msg.seq;
         // Observer forward (inbound)：群聊消息在所有过滤之前转发原始明文 payload。
         // forwardInbound 内部排除 self-echo 与 from-owner。
-        this.forwardInbound(senderAid, seq, payload);
+        this.forwardInbound(msg);
         // Extract structured mentions from payload (e.g. payload.mentions: ["evolai.agentid.pub"])
         const payloadMentions = Array.isArray(payload?.mentions)
             ? payload.mentions.filter((m) => typeof m === 'string')
@@ -1125,7 +1216,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             const hasEvolClawTrace = /\[EvolClaw\.(receive|reply|agent)\]/.test(text);
             if (/echo/i.test(firstLineFast) && firstLineFast.trim().length <= 10 && !hasEvolClawTrace) {
                 this.acknowledgeImmediately(messageId, seq);
-                const msgEncryptedFast = !!(msg.e2ee);
+                const msgEncryptedFast = !!env.encrypted;
                 const msgChatmodeFast = (payload && typeof payload === 'object') ? payload.chatmode : undefined;
                 const peerInfo = this.peerInfoCached(senderAid);
                 const shortAid = this.getShortAid(senderAid);
@@ -1176,7 +1267,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             }
         }
         // 记录入站消息加密状态，透传到出站 ReplyContext
-        const msgEncrypted = !!(msg.e2ee);
+        const msgEncrypted = !!env.encrypted;
         if (!msgEncrypted)
             this.plaintextRecv++;
         // dispatch_mode: 本地设置优先，fallback 到服务器参数
@@ -1194,7 +1285,11 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         // 包含 [EvolClaw.xxx] trace 说明已被本系统处理过，是回声的回声，丢弃防止链式爆炸
         const firstLineGroup = text.split('\n')[0] || '';
         const hasEvolClawTraceGroup = /\[EvolClaw\.(receive|reply|agent)\]/.test(text);
-        if (/echo/i.test(firstLineGroup) && !hasEvolClawTraceGroup) {
+        const isEchoMsg = /echo/i.test(firstLineGroup) && !hasEvolClawTraceGroup;
+        // 命令判定：剥离所有 @ 后看是否 / 开头（多 @ 场景如 @a @b /status 也能正确识别）。
+        // echo 消息走独立的 trace 流程，不参与命令语义判定。
+        const isCommandMsg = !isEchoMsg && this.stripAllMentions(text).startsWith('/');
+        if (isEchoMsg) {
             // 短 echo（≤10 字符）已在前面的快速通道命中并 return，这里只处理长 echo
             // >10 字符：追加 trace,存 pending echo,跳过 mention 过滤继续走 Agent 流程
             const echoTs = () => {
@@ -1219,14 +1314,21 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             return;
         }
         else {
-            // 非 echo 消息：正常 mention 过滤
-            if (dispatchMode === 'mention' && !mentionedSelf && !mentionedAll) {
+            // 非 echo 消息：mention 过滤
+            // 命令豁免 broadcast：slash 命令在任何 dispatchMode 下都强制走 mention 语义，
+            // 即必须 @ 本 agent（或 @all）才处理，避免广播群里一条命令被全部 agent 各自执行。
+            const enforceMention = dispatchMode === 'mention' || isCommandMsg;
+            if (enforceMention && !mentionedSelf && !mentionedAll) {
                 this.acknowledgeImmediately(messageId, seq);
-                logger.info(`${this.logPrefix()} Group dropped: unmentioned in mention-mode (group=${groupId} sender=${senderAid} mid=${messageId} textPreview=${JSON.stringify(text.slice(0, 80))})`);
+                logger.info(`${this.logPrefix()} Group dropped: unmentioned (group=${groupId} sender=${senderAid} mid=${messageId} mode=${dispatchMode} isCommand=${isCommandMsg} textPreview=${JSON.stringify(text.slice(0, 80))})`);
                 return;
             }
         }
-        const strippedText = this.stripSelfMentionIfOnly(text, this._aid);
+        // 命令消息：剥离所有 @（多 agent 被 @ 时各自拿到干净的 /status 各自执行）；
+        // 普通消息：仅在唯一 @ 是自己时剥离，保留其他 @ 供 agent 感知。
+        const strippedText = isCommandMsg
+            ? this.stripAllMentions(text)
+            : this.stripSelfMentionIfOnly(text, this._aid);
         // Detect attachments before the empty-text guard (顶层 + 嵌套)
         const rawAttachments = this.collectAllAttachments(payload);
         const hasAttachments = rawAttachments.length > 0;
@@ -1263,7 +1365,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const msgChatmode = (payload && typeof payload === 'object') ? payload.chatmode : undefined;
         logger.info(`${this.logPrefix()} Group dispatched: group=${groupId} sender=${shortAid}(${displayName}) mode=${dispatchMode} mid=${messageId} chatmode=${msgChatmode ?? 'none'} text=${finalText.slice(0, 60)}`);
         appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_in', aid: this.config.aid, from: senderAid, msgId: messageId, kind: 'text', len: finalText.length, groupId });
-        this.aidStatsCollector?.recordInbound(this.config.aid, senderAid, Buffer.byteLength(finalText, 'utf-8'), finalText, payloadType === 'event', msgEncrypted, msgChatmode);
+        this.aidStatsCollector?.recordInbound(this.config.aid, senderAid, Buffer.byteLength(finalText, 'utf-8'), finalText, payloadType === 'event', msgEncrypted, msgChatmode, payloadType === 'event' ? 'notify' : 'send');
         // 渲染用完整 @ 列表：结构化 payload.mentions + 正文 @aid 兜底，去重（含 self / "all"）。
         // 与上面用于过滤/回复的精简 mentions 独立——这份不丢任何被 @ 的 AID。
         const renderMentionAids = Array.from(new Set([
@@ -1287,6 +1389,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             mentions,
             mentionAids: renderMentionAids.length > 0 ? renderMentionAids : undefined,
             replyContext: this.buildGroupReplyContext(threadId, senderAid, msgEncrypted, messageId, msgChatmode),
+            dispatchMode: serverDispatchMode,
             images: inboundImages.length > 0 ? inboundImages : undefined,
         });
     }
@@ -1358,6 +1461,8 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             mentions: mentionObjects,
             mentionAids: event.mentionAids,
             replyContext,
+            source: event.source,
+            dispatchMode: event.dispatchMode,
             images: event.images,
         }).catch(err => {
             logger.error(`${this.logPrefix()} Message handler error:`, err);
@@ -1384,57 +1489,161 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
      * 若消息发送方本身是 owner，则不转发给该 owner，但仍转发给其他 owner。
      * 调用点须在所有过滤逻辑之前，payload 为 SDK 解密后的明文。
      */
-    forwardInbound(from, seq, payload) {
+    /**
+     * 入站转发：把对端发来的消息原样转发给 owner。
+     * data 为 SDK message.received / group.message_created 回调的整个对象，
+     * 不拆解、不重组——SDK 信封结构变化不影响此处。
+     */
+    forwardInbound(data) {
         if (!this.connected || !this.client)
             return;
         const { observable, owners } = this.getObserverConfig();
         if (!observable || owners.length === 0)
             return;
+        const env = (data?.envelope && typeof data.envelope === 'object') ? data.envelope : {};
+        const from = env.from ?? '';
         if (this._aid && from === this._aid)
             return; // self-echo：已在出站转过
         // 排除来源 owner（不把"owner A 发来的"再转回 A），但仍转给其他 owner。
         const recipientOwners = owners.filter(o => o !== from);
         if (recipientOwners.length === 0)
             return;
-        this.emitForward('inbound', { from, to: this.config.aid, seq, payload }, recipientOwners);
+        this.emitForward('inbound', data, recipientOwners);
     }
     /**
-     * 出站转发：Agent 经 AUN 真实发出的消息全部转发。
-     * to 为对端（私聊 AID / 群 ID），payload 为实际发送的明文 payload。
-     * 若 to 本身是 owner，排除该 owner（不把"回复 A"转发给 A 自己）。
+     * 出站转发：Agent 经 AUN 真实发出的消息原样转发给 owner。
+     * result 为 SDK message.send / group.send 的 SendResult（已 attach envelope + payload）。
+     * 若对端本身是 owner，排除该 owner（不把"回复 A"转发给 A 自己）。
      */
-    forwardOutbound(to, payload) {
+    forwardOutbound(result) {
         if (!this.connected || !this.client)
             return;
         const { observable, owners } = this.getObserverConfig();
         if (!observable || owners.length === 0)
             return;
-        // 过滤：若 to 本身是 owner，不转发给该 owner（避免"回复你"转给你自己）；
+        const env = (result?.envelope && typeof result.envelope === 'object') ? result.envelope : {};
+        const to = env.to ?? env.group_id ?? '';
+        // 过滤：若对端本身是 owner，不转发给该 owner（避免"回复你"转给你自己）；
         // 但仍转发给其他 owner。
         const recipientOwners = owners.filter(o => o !== to);
         if (recipientOwners.length === 0)
             return;
-        this.emitForward('outbound', { from: this.config.aid, to, payload }, recipientOwners);
+        this.emitForward('outbound', result, recipientOwners);
     }
-    /** 实际投递 observer.forward 给每个 owner，外层一律明文。 */
+    /**
+     * 实际投递 observer.forward 给每个 owner，外层一律明文。
+     * original 为 SDK 给到的原始对象（入站回调 data / 出站 SendResult），整体透传，
+     * 不挑字段、不改字段——SDK 加任何字段都会自动一并转发给 owner。
+     */
     emitForward(direction, original, owners) {
         const forwardPayload = {
             type: 'observer.forward',
             direction,
             agent_aid: this.config.aid,
-            original: {
-                from: original.from,
-                to: original.to,
-                ...(original.seq != null ? { seq: original.seq } : {}),
-                timestamp: Date.now(),
-                payload: original.payload,
-            },
+            original,
         };
         for (const ownerAid of owners) {
             this.callAndTrace('message.send', { to: ownerAid, payload: forwardPayload, encrypt: false })
                 .catch(e => logger.debug(`${this.logPrefix()} observer.forward to ${ownerAid} failed: ${e}`));
         }
     }
+    // ── 观察者插话（Observer Insert，v0.3 待用上下文提示） ──────────────
+    //
+    // owner 经 message.send 给 agent 自身 AID 发 observer.inject（payload 为对象）。
+    // 鉴权 from∈owners 后，把提示【只落盘】到 agent↔对端 会话的 pending-hints.jsonl
+    // （不 dispatch、不跑 LLM、不回 owner）；下一条对端消息到达时由 message-processor
+    // 回放消费、注入渲染层。action=add 加提示 / remove 撤销。
+    // 详见 docs/observer-insert-design.md 第一部分。
+    /** 回 observer.inject.ack 给 owner（明文）。accepted 在成功写盘之后发出。 */
+    emitInjectAck(ownerAid, injectId, data, error) {
+        if (!this.connected || !this.client)
+            return;
+        const ackPayload = { type: 'observer.inject.ack' };
+        if (injectId)
+            ackPayload.id = injectId;
+        if (data)
+            ackPayload.data = data;
+        if (error)
+            ackPayload.error = error;
+        this.callAndTrace('message.send', { to: ownerAid, payload: ackPayload, encrypt: false })
+            .catch(e => logger.debug(`${this.logPrefix()} observer.inject.ack to ${ownerAid} failed: ${e}`));
+    }
+    /** 处理 observer.inject：鉴权 + 校验 + 只落盘到 pending-hints（不触发处理、不回 owner）。 */
+    handleObserverInject(fromAid, payload, displayName, peerType) {
+        void peerType;
+        const { owners } = this.getObserverConfig();
+        const ts = Date.now();
+        const req = parseInjectRequest(payload, fromAid, owners, ts);
+        if (req.kind === 'reject') {
+            logger.warn(`${this.logPrefix()} observer.inject rejected: ${this.getShortAid(fromAid)} ${req.code}`);
+            this.emitInjectAck(fromAid, req.injectId, { status: 'rejected', action: req.action }, { code: req.code, message: req.message });
+            return;
+        }
+        const selfAID = this.config.aid;
+        const sessionsDir = resolvePaths().sessionsDir;
+        let ok;
+        if (req.kind === 'remove') {
+            ok = appendHintRemove(sessionsDir, 'aun', req.channelId, selfAID, { targetId: req.targetId, threadId: req.threadId, ts });
+        }
+        else {
+            ok = appendHintAdd(sessionsDir, 'aun', req.channelId, selfAID, { id: req.id, text: req.text, threadId: req.threadId, ownerAid: req.ownerAid, ts });
+        }
+        if (!ok) {
+            this.emitInjectAck(fromAid, req.injectId, { status: 'rejected', action: req.kind }, { code: 'STORE_FAILED', message: '提示落盘失败' });
+            return;
+        }
+        logger.info(`${this.logPrefix()} observer.inject ${req.kind} stored: from=${this.getShortAid(fromAid)}(${displayName}) target=${req.channelId} chatType=${req.chatType} thread=${req.threadId ?? 'main'}${req.kind === 'add' ? ` textLen=${req.text.length}` : `${req.targetId ? ` targetId=${req.targetId}` : ' (clear-all)'}`}`);
+        this.emitInjectAck(fromAid, req.injectId, { status: 'accepted', action: req.kind });
+        // 记录到 watch（被观察的 agent↔对端 会话），带 owner-inject 标记区分对端真实消息。
+        // v0.3：只记"提示已添加/已撤销"，不触发处理、不产生 agent→owner 回应。
+        const watchText = req.kind === 'remove' ? `[撤销提示]${req.targetId ? ` id=${req.targetId}` : '（全部）'}` : req.text;
+        const synthId = `inject-${req.injectId || ts}`;
+        this.recordInjectWatch('in', fromAid, req.channelId, req.chatType, synthId, watchText);
+    }
+    /**
+     * 把 observer 插话 / 对插话的回应记录到 watch（被观察的 agent↔对端 会话），
+     * 带 source='owner-inject' 标记，与对端真实消息区分。
+     * 写三处：messages.jsonl（watch msg）、appendAidEvent（watch aid 事件流）、aidStatsCollector（统计）。
+     * @param dir 'in'=owner→agent 插话；'out'=agent→owner 对插话的回应
+     * @param peerChannelId 被观察会话的对端（agent↔对端），日志落点 = sessions/aun/<self>/<peerChannelId>/
+     */
+    recordInjectWatch(dir, ownerAid, peerChannelId, chatType, msgId, text) {
+        try {
+            const selfAID = this.config.aid;
+            const isGroup = chatType === 'group';
+            const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', peerChannelId, selfAID);
+            const entry = dir === 'in'
+                ? buildInboundEntry({
+                    from: ownerAid, to: selfAID, chatType,
+                    groupId: isGroup ? peerChannelId : null, msgId, content: text,
+                    permMode: 'owner', source: 'owner-inject',
+                })
+                : buildOutboundEntry({
+                    from: selfAID, to: ownerAid, chatType,
+                    groupId: isGroup ? peerChannelId : null, msgId, content: text,
+                    source: 'owner-inject',
+                });
+            appendMessageLog(chatDir, entry);
+        }
+        catch (e) {
+            logger.debug(`${this.logPrefix()} recordInjectWatch(msg) failed: ${e}`);
+        }
+        // watch aid：事件流 + 统计（标 inject，便于过滤）
+        try {
+            const len = Buffer.byteLength(text, 'utf-8');
+            if (dir === 'in') {
+                appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_in', aid: this.config.aid, from: ownerAid, msgId, kind: 'text', len, inject: true });
+                this.aidStatsCollector?.recordInbound(this.config.aid, ownerAid, len, text, false, false, 'inject', 'inject');
+            }
+            else {
+                appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: ownerAid, msgId, kind: 'text', len, inject: true });
+                this.aidStatsCollector?.recordOutbound(this.config.aid, ownerAid, len, text, false, false, 'inject', 'inject');
+            }
+        }
+        catch (e) {
+            logger.debug(`${this.logPrefix()} recordInjectWatch(aid) failed: ${e}`);
+        }
+    }
     handleEcho(event) {
         const ts = () => {
             const d = new Date();
@@ -1785,6 +1994,219 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
     onRecall(handler) {
         this.recallHandler = handler;
     }
+    async withOutboxInFlight(entry, run, busyValue) {
+        if (this.outboxInFlight.has(entry.id))
+            return busyValue;
+        this.outboxInFlight.add(entry.id);
+        try {
+            return await run();
+        }
+        finally {
+            this.outboxInFlight.delete(entry.id);
+        }
+    }
+    messageIdFromSendResult(result) {
+        return result?.message?.message_id ?? result?.message_id ?? null;
+    }
+    payloadLogText(payload, contentKind) {
+        if (typeof payload.text === 'string' && payload.text)
+            return payload.text;
+        switch (contentKind ?? payload.type) {
+            case 'image':
+                return payload.alt ? `[image] ${payload.alt}` : '[image]';
+            case 'card':
+            case 'action_card':
+                return payload.title ? `[card] ${payload.title}` : '[card]';
+            case 'file':
+                return payload.filename ? `[file] ${payload.filename}` : '[file]';
+            default:
+                return `[${String(payload.type ?? contentKind ?? 'payload')}]`;
+        }
+    }
+    payloadByteLength(payload, logText) {
+        if (payload.type === 'image' && typeof payload.data_base64 === 'string') {
+            return Buffer.byteLength(payload.data_base64, 'utf-8');
+        }
+        return Buffer.byteLength(logText, 'utf-8');
+    }
+    applyReplyContextToPayload(payload, context) {
+        const finalPayload = { ...payload };
+        if (context?.threadId && !finalPayload.thread_id)
+            finalPayload.thread_id = context.threadId;
+        if (context?.metadata?.taskId && !finalPayload.task_id)
+            finalPayload.task_id = context.metadata.taskId;
+        if (context?.metadata?.chatmode && !finalPayload.chatmode)
+            finalPayload.chatmode = context.metadata.chatmode;
+        return finalPayload;
+    }
+    registerCardPostSend(messageId, action) {
+        if (action.type !== 'register_interaction_card')
+            return;
+        this.cardMessageIdMap.set(messageId, {
+            requestId: action.requestId,
+            isCommandCard: action.isCommandCard,
+            initiatorAid: action.initiatorAid,
+        });
+        this.ownedCardMsgIds.add(messageId);
+        const now = Date.now();
+        const mapTtl = action.expiresAt && action.expiresAt > now
+            ? action.expiresAt - now
+            : 20 * 60 * 1000;
+        setTimeout(() => this.cardMessageIdMap.delete(messageId), mapTtl);
+        setTimeout(() => this.ownedCardMsgIds.delete(messageId), 24 * 60 * 60 * 1000);
+    }
+    runPostSend(entry, messageId) {
+        if (!entry.postSend)
+            return;
+        if (entry.postSend.type === 'register_interaction_card') {
+            this.registerCardPostSend(messageId, entry.postSend);
+        }
+    }
+    async sendAunPayload(channelId, payload, context, label) {
+        if (!this.client || !this.connected)
+            return { ok: false };
+        const isGroup = this.isGroupId(channelId);
+        const targetAid = channelId;
+        const encryptTarget = isGroup ? channelId : targetAid;
+        const encrypt = context?.metadata?.encrypted != null
+            ? !!(context.metadata.encrypted)
+            : this.shouldEncrypt(encryptTarget);
+        const method = isGroup ? 'group.send' : 'message.send';
+        const params = { payload, encrypt };
+        if (isGroup)
+            params.group_id = channelId;
+        else
+            params.to = targetAid;
+        const callOnce = async (sendParams, fallback) => {
+            const result = fallback
+                ? await this.client.call(method, sendParams)
+                : await this.callAndTrace(method, sendParams);
+            const mid = this.messageIdFromSendResult(result);
+            if (!mid) {
+                logger.warn(`${this.logPrefix()} ${method}${fallback ? ' fallback' : ''} (${label}) returned no message_id: ${JSON.stringify(result)}`);
+                return { ok: false, result, encrypt: !!sendParams.encrypt };
+            }
+            return { ok: true, messageId: mid, result, encrypt: !!sendParams.encrypt };
+        };
+        try {
+            return await callOnce(params, false);
+        }
+        catch (e) {
+            if (encrypt && e instanceof E2EEError) {
+                this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
+                logger.warn(`${this.logPrefix()} E2EE ${label} send failed to ${channelId}, retrying plaintext: ${e}`);
+                const fallbackParams = { ...params, encrypt: false };
+                try {
+                    this.trace('OUT', `${method}.${label}.fallback`, fallbackParams);
+                    const sent = await callOnce(fallbackParams, true);
+                    this.trace('OUT', `${method}.${label}.fallback.${sent.ok ? 'ok' : 'missing_id'}`, { message_id: sent.messageId });
+                    return sent;
+                }
+                catch (e2) {
+                    this.trace('OUT', `${method}.${label}.fallback.error`, { channelId, error: String(e2) });
+                    logger.error(`${this.logPrefix()} Plaintext ${label} fallback also failed to ${channelId}: ${e2}`);
+                    return { ok: false };
+                }
+            }
+            this.trace('OUT', `${method}.${label}.error`, { channelId, error: String(e) });
+            logger.error(`${this.logPrefix()} ${label} send failed to ${channelId}: ${e}`);
+            return { ok: false };
+        }
+    }
+    recordDurableOutbound(channelId, payload, messageId, encrypt, context, isGroup, contentKind, logText, result) {
+        const kind = contentKind ?? payload.type ?? 'custom';
+        appendAidEvent({
+            ts: Date.now(),
+            iso: new Date().toISOString(),
+            event: 'message_out',
+            aid: this.config.aid,
+            to: channelId,
+            msgId: messageId,
+            kind,
+            len: Buffer.byteLength(logText, 'utf-8'),
+            ...(isGroup && { groupId: channelId }),
+        });
+        this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, this.payloadByteLength(payload, logText), logText, false, encrypt, context?.metadata?.chatmode);
+        const source = context?.metadata?.source ?? 'daemon';
+        this.appendOutboundJsonl(channelId, logText, messageId, encrypt, context, isGroup, 'text', source);
+        this.forwardOutbound(result);
+    }
+    async sendContentPayload(channelId, payload, opts) {
+        const finalPayload = this.applyReplyContextToPayload(payload, opts.context);
+        const logText = opts.logText ?? this.payloadLogText(finalPayload, opts.contentKind);
+        const entry = outbox.enqueue(this.config.aid, {
+            channelId,
+            type: 'payload',
+            contentKind: opts.contentKind,
+            payload: finalPayload,
+            context: opts.context,
+            logText,
+            ttl: opts.ttl,
+            postSend: opts.postSend,
+        });
+        logger.debug(`${this.logPrefix()} Outbox enqueued payload: id=${entry.id} kind=${opts.contentKind} channel=${channelId} text=${logText.slice(0, 40)}`);
+        if (!this.connected || !this.client) {
+            logger.warn(`${this.logPrefix()} Not connected, payload queued in outbox (id=${entry.id}, kind=${opts.contentKind}). Triggering reconnect.`);
+            if (!this.reconnectTimer && !this.client) {
+                this.initClient().catch(e => logger.error(`${this.logPrefix()} Reconnect from sendContentPayload failed: ${e}`));
+            }
+            return { queued: true };
+        }
+        const result = await this.withOutboxInFlight(entry, () => this.deliverPayloadEntry(entry), { ok: false });
+        if (result.ok) {
+            outbox.remove(this.config.aid, entry.id);
+            return { messageId: result.messageId };
+        }
+        return { queued: true };
+    }
+    buildTaskPayloadBase(envelope, context) {
+        const base = {};
+        if (envelope.taskId)
+            base.task_id = envelope.taskId;
+        if (envelope.sessionId)
+            base.session_id = envelope.sessionId;
+        if (envelope.agentName)
+            base.agent_name = envelope.agentName;
+        if (envelope.chatmode)
+            base.chatmode = envelope.chatmode;
+        if (context?.threadId)
+            base.thread_id = context.threadId;
+        if (context?.peerId)
+            base.initiator = context.peerId;
+        if (context?.replyToMessageId)
+            base.ref_message_id = context.replyToMessageId;
+        return base;
+    }
+    activityLogText(raw) {
+        // 兼容两种入参：原始 ThoughtItem（顶层字段），或已构建的 activity payload（字段收在 .item 里）
+        const item = raw?.item && typeof raw.item === 'object' ? raw.item : raw;
+        if (typeof item?.text === 'string' && item.text)
+            return item.text;
+        if (item?.kind === 'tool_call')
+            return `[tool_call] ${item.name ?? ''}`.trim();
+        if (item?.kind === 'tool_result')
+            return `[tool_result] ${item.name ?? ''} ${item.ok === false ? 'failed' : 'ok'}`.trim();
+        if (item?.kind)
+            return `[activity:${item.kind}]`;
+        return '[activity]';
+    }
+    buildActivityPayload(envelope, context, item) {
+        const activityItem = item && typeof item === 'object' && !Array.isArray(item)
+            ? { ...item }
+            : { kind: 'unknown', text: String(item ?? '') };
+        return {
+            ...this.buildTaskPayloadBase(envelope, context),
+            type: 'activity',
+            item: activityItem,
+        };
+    }
+    async sendReliableStructured(channelId, payload, context, logText) {
+        await this.sendContentPayload(channelId, payload, {
+            contentKind: 'custom',
+            context,
+            logText: logText ?? this.payloadLogText(payload, 'custom'),
+        });
+    }
     async sendMessage(channelId, text, context) {
         if (!text?.trim()) {
             logger.warn(`${this.logPrefix()} Attempted to send empty message, skipping`);
@@ -1817,7 +2239,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             return;
         }
         // Attempt immediate delivery
-        const ok = await this.deliverTextEntry(entry);
+        const ok = await this.withOutboxInFlight(entry, () => this.deliverTextEntry(entry), false);
         if (ok) {
             outbox.remove(this.config.aid, entry.id);
         }
@@ -1899,19 +2321,20 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 if (!mid) {
                     const dispatchStatus = result?.message_dispatch?.status;
                     if (dispatchStatus === 'debounced' || dispatchStatus === 'dispatched') {
-                        logger.info(`${this.logPrefix()} group.send ok (${dispatchStatus}): group=${channelId} encrypt=${encrypt} text=${finalText.slice(0, 60)}`);
+                        logger.warn(`${this.logPrefix()} group.send returned ${dispatchStatus} without message_id; keeping outbox entry: group=${channelId} encrypt=${encrypt} text=${finalText.slice(0, 60)}`);
                     }
                     else {
                         logger.warn(`${this.logPrefix()} group.send returned no message_id: ${JSON.stringify(result)}`);
                     }
+                    return false;
                 }
                 else {
                     logger.info(`${this.logPrefix()} group.send ok: group=${channelId} mid=${mid} encrypt=${encrypt} text=${finalText.slice(0, 60)}`);
                     appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: channelId, msgId: mid, kind: 'text', len: finalText.length, groupId: channelId });
-                    this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(finalText, 'utf-8'), finalText, false, encrypt, context?.metadata?.chatmode);
+                    this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(finalText, 'utf-8'), finalText, false, encrypt, context?.metadata?.chatmode, 'send');
                     this.appendOutboundJsonl(channelId, finalText, mid, encrypt, context, true, 'text', source);
-                    // Observer forward: outbound (group) — 转发实际发出的明文 payload
-                    this.forwardOutbound(channelId, payload);
+                    // Observer forward: outbound (group) — 原样转发 SDK SendResult（含 envelope + payload）
+                    this.forwardOutbound(result);
                 }
             }
             else {
@@ -1919,14 +2342,15 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 const result = await this.callAndTrace('message.send', params);
                 if (!result || !result.message_id) {
                     logger.warn(`${this.logPrefix()} message.send returned no message_id: ${JSON.stringify(result)}`);
+                    return false;
                 }
                 else {
                     logger.info(`${this.logPrefix()} message.send ok: to=${this.peerLabel(targetAid)} mid=${result.message_id} encrypt=${encrypt} text=${finalText.slice(0, 60)}`);
                     appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: targetAid, msgId: result.message_id, kind: 'text', len: finalText.length });
-                    this.aidStatsCollector?.recordOutbound(this.config.aid, targetAid, Buffer.byteLength(finalText, 'utf-8'), finalText, false, encrypt, context?.metadata?.chatmode);
+                    this.aidStatsCollector?.recordOutbound(this.config.aid, targetAid, Buffer.byteLength(finalText, 'utf-8'), finalText, false, encrypt, context?.metadata?.chatmode, 'send');
                     this.appendOutboundJsonl(targetAid, finalText, result.message_id, encrypt, context, false, 'text', source);
-                    // Observer forward: outbound (private) — 转发实际发出的明文 payload
-                    this.forwardOutbound(targetAid, payload);
+                    // Observer forward: outbound (private) — 原样转发 SDK SendResult（含 envelope + payload）
+                    this.forwardOutbound(result);
                 }
             }
             return true;
@@ -1940,20 +2364,30 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                     if (isGroup) {
                         this.trace('OUT', 'group.send.fallback', params);
                         const result = await this.client.call('group.send', params);
-                        this.trace('OUT', 'group.send.fallback.ok', { message_id: result?.message?.message_id ?? result?.message_id });
-                        if (!result || !result.message_id) {
+                        const mid = this.messageIdFromSendResult(result);
+                        this.trace('OUT', 'group.send.fallback.ok', { message_id: mid });
+                        if (!mid) {
                             logger.warn(`${this.logPrefix()} group.send fallback returned no message_id: ${JSON.stringify(result)}`);
+                            return false;
                         }
-                        this.forwardOutbound(channelId, payload);
+                        appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: channelId, msgId: mid, kind: 'text', len: finalText.length, groupId: channelId });
+                        this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(finalText, 'utf-8'), finalText, false, false, context?.metadata?.chatmode);
+                        this.appendOutboundJsonl(channelId, finalText, mid, false, context, true, 'text', source);
+                        this.forwardOutbound(result);
                     }
                     else {
                         this.trace('OUT', 'message.send.fallback', params);
                         const result = await this.client.call('message.send', params);
-                        this.trace('OUT', 'message.send.fallback.ok', { message_id: result?.message_id });
-                        if (!result || !result.message_id) {
+                        const mid = result?.message_id;
+                        this.trace('OUT', 'message.send.fallback.ok', { message_id: mid });
+                        if (!result || !mid) {
                             logger.warn(`${this.logPrefix()} message.send fallback returned no message_id: ${JSON.stringify(result)}`);
+                            return false;
                         }
-                        this.forwardOutbound(targetAid, payload);
+                        appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: targetAid, msgId: mid, kind: 'text', len: finalText.length });
+                        this.aidStatsCollector?.recordOutbound(this.config.aid, targetAid, Buffer.byteLength(finalText, 'utf-8'), finalText, false, false, context?.metadata?.chatmode);
+                        this.appendOutboundJsonl(targetAid, finalText, mid, false, context, false, 'text', source);
+                        this.forwardOutbound(result);
                     }
                     return true;
                 }
@@ -1970,6 +2404,26 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             }
         }
     }
+    async deliverPayloadEntry(entry) {
+        const channelId = entry.channelId;
+        const payload = entry.payload;
+        if (!payload) {
+            logger.warn(`${this.logPrefix()} deliverPayloadEntry: missing payload (outbox id=${entry.id})`);
+            return { ok: true };
+        }
+        const contentKind = entry.contentKind;
+        const logText = entry.logText ?? this.payloadLogText(payload, contentKind);
+        const context = entry.context;
+        logger.info(`${this.logPrefix()} deliverPayloadEntry: id=${entry.id} kind=${contentKind ?? payload.type ?? 'payload'} channelId=${channelId} thread_id=${payload.thread_id ?? 'none'} task_id=${payload.task_id ?? 'none'} textLen=${logText.length}`);
+        const sent = await this.sendAunPayload(channelId, payload, context, `${contentKind ?? payload.type ?? 'payload'}`);
+        if (!sent.ok || !sent.messageId)
+            return sent;
+        const isGroup = this.isGroupId(channelId);
+        logger.info(`${this.logPrefix()} durable payload sent: kind=${contentKind ?? payload.type ?? 'payload'} target=${isGroup ? channelId : this.peerLabel(channelId)} mid=${sent.messageId} encrypt=${sent.encrypt} text=${logText.slice(0, 60)}`);
+        this.recordDurableOutbound(channelId, payload, sent.messageId, !!sent.encrypt, context, isGroup, contentKind, logText, sent.result);
+        this.runPostSend(entry, sent.messageId);
+        return sent;
+    }
     /** 出站消息写入 messages.jsonl（message.send/group.send/thought.put 成功后调用） */
     appendOutboundJsonl(channelId, text, msgId, encrypt, context, isGroup, msgType = 'text', source = 'daemon') {
         try {
@@ -2022,10 +2476,10 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             encrypt,
         };
         try {
-            const itemCount = Array.isArray(payload?.items) ? payload.items.length : 0;
-            const stage = payload?.stage ?? `items=${itemCount}`;
-            // 提取 thought 文本（只对 kind=text 的 item 写 jsonl，过滤 tool_use/tool_result 等结构化项）
             const items = payload?.items;
+            const itemCount = Array.isArray(items) ? items.length : 1;
+            const stage = payload?.stage ?? (payload?.kind ? `kind=${payload.kind}` : `items=${itemCount}`);
+            // 提取 thought 文本：兼容旧 items[] 和新扁平 activity payload。
             let thoughtText;
             if (Array.isArray(items) && items.length > 0) {
                 const lastItem = items[items.length - 1];
@@ -2043,15 +2497,18 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                     thoughtText = lastItem;
                 }
             }
+            else {
+                thoughtText = this.activityLogText(payload);
+            }
             if (this.isGroupId(channelId)) {
                 params.group_id = targetId;
                 const putRes = await this.callAndTrace('group.thought.put', params);
                 const tid = putRes?.thought_id;
                 logger.info(`${this.logPrefix()} thought.put ok group=${targetId} task=${taskId} stage=${stage} encrypt=${encrypt} tid=${tid ?? '?'}`);
                 this.eventBus?.publish?.({ type: 'message:thought-put', agentName: this.config.aid, channelId, taskId, text: thoughtText });
-                this.forwardOutbound(channelId, payload);
+                this.forwardOutbound(putRes);
                 if (thoughtText) {
-                    this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(thoughtText, 'utf-8'), thoughtText, false, encrypt, context?.metadata?.chatmode ?? 'proactive');
+                    this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(thoughtText, 'utf-8'), thoughtText, false, encrypt, context?.metadata?.chatmode ?? 'proactive', 'thought');
                     this.appendOutboundJsonl(channelId, thoughtText, tid ?? `thought-${Date.now()}`, encrypt, context, true, 'thought', 'daemon');
                 }
             }
@@ -2061,9 +2518,9 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 const tid = putRes?.thought_id;
                 logger.info(`${this.logPrefix()} thought.put ok p2p=${this.peerLabel(targetId)} task=${taskId} stage=${stage} encrypt=${encrypt} tid=${tid ?? '?'}`);
                 this.eventBus?.publish?.({ type: 'message:thought-put', agentName: this.config.aid, channelId, taskId, text: thoughtText });
-                this.forwardOutbound(channelId, payload);
+                this.forwardOutbound(putRes);
                 if (thoughtText) {
-                    this.aidStatsCollector?.recordOutbound(this.config.aid, targetId, Buffer.byteLength(thoughtText, 'utf-8'), thoughtText, false, encrypt, context?.metadata?.chatmode ?? 'proactive');
+                    this.aidStatsCollector?.recordOutbound(this.config.aid, targetId, Buffer.byteLength(thoughtText, 'utf-8'), thoughtText, false, encrypt, context?.metadata?.chatmode ?? 'proactive', 'thought');
                     this.appendOutboundJsonl(channelId, thoughtText, tid ?? `thought-${Date.now()}`, encrypt, context, false, 'thought', 'daemon');
                 }
             }
@@ -2098,14 +2555,14 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 const result = await this.callAndTrace('group.send', params);
                 const mid = result?.message?.message_id ?? result?.message_id ?? null;
                 logger.info(`${this.logPrefix()} group.send (${payload.type}) ok: group=${channelId} mid=${mid} encrypt=${encrypt}`);
-                this.forwardOutbound(channelId, finalPayload);
+                this.forwardOutbound(result);
                 return mid;
             }
             else {
                 params.to = targetAid;
                 const result = await this.callAndTrace('message.send', params);
                 logger.info(`${this.logPrefix()} message.send (${payload.type}) ok: to=${this.peerLabel(targetAid)} mid=${result?.message_id} encrypt=${encrypt}`);
-                this.forwardOutbound(targetAid, finalPayload);
+                this.forwardOutbound(result);
                 return result?.message_id ?? null;
             }
         }
@@ -2145,7 +2602,7 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             }
             return;
         }
-        const ok = await this.deliverFileEntry(entry);
+        const ok = await this.withOutboxInFlight(entry, () => this.deliverFileEntry(entry), false);
         if (ok) {
             outbox.remove(this.config.aid, entry.id);
         }
@@ -2215,6 +2672,9 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 filePayload.task_id = context.metadata.taskId;
             if (context?.metadata?.chatmode)
                 filePayload.chatmode = context.metadata.chatmode;
+            // file-link-cache: 回带点击请求的 correlationId，客户端用它把异步到达的文件消息对回这次 fetch 点击
+            if (context?.metadata?.correlationId)
+                filePayload.correlation_id = context.metadata.correlationId;
             const isGroup = this.isGroupId(channelId);
             const fileTargetAid = channelId;
             const encryptTarget = isGroup ? channelId : fileTargetAid;
@@ -2222,24 +2682,32 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 ? !!(context.metadata.encrypted)
                 : this.shouldEncrypt(encryptTarget);
             const params = { payload: filePayload, encrypt };
+            let sendResult = null;
+            let sentMid = null;
             try {
                 if (isGroup) {
                     params.group_id = channelId;
                     this.trace('OUT', 'group.send.file', params);
                     const result = await this.client.call('group.send', params);
+                    sendResult = result;
                     const fileMid = result?.message?.message_id ?? result?.message_id;
+                    sentMid = fileMid ?? null;
                     this.trace('OUT', 'group.send.file.ok', { message_id: fileMid });
                     if (!fileMid) {
                         logger.warn(`${this.logPrefix()} group.send.file returned no message_id: ${JSON.stringify(result)}`);
+                        return false;
                     }
                 }
                 else {
                     params.to = fileTargetAid;
                     this.trace('OUT', 'message.send.file', params);
                     const result = await this.client.call('message.send', params);
-                    this.trace('OUT', 'message.send.file.ok', { message_id: result?.message_id });
-                    if (!result || !result.message_id) {
+                    sendResult = result;
+                    sentMid = result?.message_id ?? null;
+                    this.trace('OUT', 'message.send.file.ok', { message_id: sentMid });
+                    if (!result || !sentMid) {
                         logger.warn(`${this.logPrefix()} message.send.file returned no message_id: ${JSON.stringify(result)}`);
+                        return false;
                     }
                 }
             }
@@ -2255,18 +2723,24 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                     if (isGroup) {
                         this.trace('OUT', 'group.send.file.fallback', params);
                         const result = await this.client.call('group.send', params);
+                        sendResult = result;
                         const fbMid = result?.message?.message_id ?? result?.message_id;
+                        sentMid = fbMid ?? null;
                         this.trace('OUT', 'group.send.file.fallback.ok', { message_id: fbMid });
                         if (!fbMid) {
                             logger.warn(`${this.logPrefix()} group.send.file fallback returned no message_id: ${JSON.stringify(result)}`);
+                            return false;
                         }
                     }
                     else {
                         this.trace('OUT', 'message.send.file.fallback', params);
                         const result = await this.client.call('message.send', params);
-                        this.trace('OUT', 'message.send.file.fallback.ok', { message_id: result?.message_id });
-                        if (!result || !result.message_id) {
+                        sendResult = result;
+                        sentMid = result?.message_id ?? null;
+                        this.trace('OUT', 'message.send.file.fallback.ok', { message_id: sentMid });
+                        if (!result || !sentMid) {
                             logger.warn(`${this.logPrefix()} message.send.file fallback returned no message_id: ${JSON.stringify(result)}`);
+                            return false;
                         }
                     }
                 }
@@ -2275,7 +2749,15 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
                 }
             }
             logger.info(`${this.logPrefix()} File sent: ${filename} (${formatSize(stat.size)}) → ${channelId}`);
-            this.forwardOutbound(channelId, filePayload);
+            if (sentMid) {
+                const fileText = filePayload.text;
+                appendAidEvent({ ts: Date.now(), iso: new Date().toISOString(), event: 'message_out', aid: this.config.aid, to: channelId, msgId: sentMid, kind: 'file', len: fileText.length, ...(isGroup && { groupId: channelId }) });
+                this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, Buffer.byteLength(fileText, 'utf-8'), fileText, false, !!params.encrypt, context?.metadata?.chatmode);
+                const source = context?.metadata?.source ?? 'daemon';
+                this.appendOutboundJsonl(channelId, fileText, sentMid, !!params.encrypt, context, isGroup, 'text', source);
+            }
+            if (sendResult)
+                this.forwardOutbound(sendResult);
             return true;
         }
         catch (e) {
@@ -2309,10 +2791,14 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         logger.info(`${this.logPrefix()} Draining outbox...`);
         const result = await outbox.drain(this.config.aid, async (entry) => {
             if (entry.type === 'text') {
-                return this.deliverTextEntry(entry);
+                return this.withOutboxInFlight(entry, () => this.deliverTextEntry(entry), false);
             }
             else if (entry.type === 'file') {
-                return this.deliverFileEntry(entry);
+                return this.withOutboxInFlight(entry, () => this.deliverFileEntry(entry), false);
+            }
+            else if (entry.type === 'payload') {
+                const sent = await this.withOutboxInFlight(entry, () => this.deliverPayloadEntry(entry), { ok: false });
+                return sent.ok;
             }
             return true; // unknown type, discard
         });
@@ -2341,58 +2827,44 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             progress: 'progress',
         };
         const statusPayload = {
-            type: 'status',
-            state: stateMap[status] ?? status,
+            type: 'task.status',
+            status: stateMap[status] ?? status,
             task_id: taskId,
             session_id: sessionId,
             severity,
+            terminal: ['done', 'interrupted', 'error', 'timeout'].includes(status),
             ...(extraMeta && Object.keys(extraMeta).length > 0 && { metadata: extraMeta }),
         };
         if (context?.threadId)
             statusPayload.thread_id = context.threadId;
         if (context?.peerId)
             statusPayload.initiator = context.peerId;
+        if (context?.metadata?.chatmode)
+            statusPayload.chatmode = context.metadata.chatmode;
         if (context?.replyToMessageId)
             statusPayload.ref_message_id = context.replyToMessageId;
-        const isGroup = this.isGroupId(channelId);
-        // 私聊 channelId = 对端 AID（不含 device_id）
-        const statusTargetAid = channelId;
-        const encryptTarget = isGroup ? channelId : statusTargetAid;
-        const computeEncrypt = () => context?.metadata?.encrypted != null
-            ? !!(context.metadata.encrypted)
-            : this.shouldEncrypt(encryptTarget);
-        const sendOne = (method, payload, label) => {
-            const c = this.client;
-            if (!c) {
-                logger.debug(`${this.logPrefix()} ${label} skipped: client gone`);
-                return Promise.resolve();
-            }
-            const encrypt = computeEncrypt();
-            const params = { payload, encrypt };
-            if (isGroup)
-                params.group_id = channelId;
-            else
-                params.to = statusTargetAid;
-            this.trace('OUT', `${method}.task_${label}`, params);
-            return c.call(method, params).catch(e => {
-                if (encrypt && e instanceof E2EEError) {
-                    this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
-                    logger.warn(`${this.logPrefix()} E2EE task_${label} send failed to ${channelId}, retrying plaintext`);
-                    const c2 = this.client;
-                    if (!c2)
-                        return;
-                    const fallbackParams = { ...params, encrypt: false };
-                    return c2.call(method, fallbackParams).catch(e2 => {
-                        logger.debug(`${this.logPrefix()} task_${label} fallback failed: ${e2}`);
-                    });
-                }
-                logger.debug(`${this.logPrefix()} task_${label} failed: ${e}`);
-            });
-        };
-        const method = isGroup ? 'group.send' : 'message.send';
-        sendOne(method, statusPayload, 'status');
-        this.forwardOutbound(channelId, statusPayload);
-        this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, JSON.stringify(statusPayload).length, undefined, true);
+        const notifyOptions = { ttlMs: 60_000 };
+        if (this.isGroupId(channelId))
+            notifyOptions.groupId = channelId;
+        else
+            notifyOptions.to = channelId;
+        this.trace('OUT', 'notify.task_status', {
+            method: 'event/app.task.status',
+            params: statusPayload,
+            options: notifyOptions,
+        });
+        const notify = this.client.notify;
+        if (typeof notify !== 'function') {
+            logger.warn(`${this.logPrefix()} task.${status} notify skipped: client.notify unavailable`);
+            return;
+        }
+        Promise.resolve(notify.call(this.client, 'event/app.task.status', statusPayload, notifyOptions)).then(() => {
+            this.trace('OUT', 'notify.task_status.ok', { task_id: taskId, status: statusPayload.status });
+        }).catch((e) => {
+            this.trace('OUT', 'notify.task_status.error', { task_id: taskId, status: statusPayload.status, error: String(e) });
+            logger.debug(`${this.logPrefix()} task_status notify failed: ${e}`);
+        }).catch(() => { });
+        this.aidStatsCollector?.recordOutbound(this.config.aid, channelId, JSON.stringify(statusPayload).length, undefined, true, undefined, undefined, 'notify');
         // 群聊显示 group id 简称，P2P 显示 peer label；从 context.metadata 读取 chatmode
         const targetLabel = this.isGroupId(channelId) ? channelId : this.peerLabel(channelId);
         const chatmode = context?.metadata?.chatmode ?? '?';
@@ -2615,251 +3087,290 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             return undefined; // 不写缓存，下次仍可重试
         }
     }
+    /**
+     * 查询某成员在群里的角色（经 group.get_admins）。
+     * 仅用于话题创建权限校验（稀有事件），故不缓存：每次查权威源，结果天然最新。
+     * 命中 admins 列表（owner+admin）返回其 role；不在列表（含普通 member / observer）返回 'none'；
+     * 未连接 / 异常返回 undefined —— 绝不抛出，由调用方按 fail-closed 处理。
+     */
+    async getGroupMemberRole(groupId, aid) {
+        if (!groupId || !aid)
+            return undefined;
+        if (!this.client)
+            return undefined;
+        try {
+            const result = await this.callAndTrace('group.get_admins', { group_id: groupId });
+            const admins = Array.isArray(result?.admins) ? result.admins : [];
+            const hit = admins.find((m) => m?.aid === aid);
+            if (hit) {
+                const role = hit.role;
+                return role === 'owner' || role === 'admin' ? role : 'admin';
+            }
+            return 'none'; // 不在 owner/admin 列表 → 普通 member / observer / 非成员
+        }
+        catch {
+            return undefined; // 查询失败，调用方 fail-closed
+        }
+    }
 }
 // Plugin implementation
 export class AUNChannelPlugin {
     name = 'aun';
-    isEnabled(config) {
-        const raw = config.channels?.aun;
-        if (!raw)
-            return false;
-        if (Array.isArray(raw)) {
-            return raw.some(inst => inst.enabled !== false && !!inst.aid);
-        }
-        return raw.enabled !== false && !!raw.aid;
-    }
-    async createChannels(config) {
-        const instances = normalizeChannelInstances(config.channels?.aun, 'aun');
-        const result = [];
-        for (const inst of instances) {
-            if (inst.enabled === false || !inst.aid)
-                continue;
-            const channel = new AUNChannel({
-                aid: inst.aid,
-                keystorePath: inst.keystorePath,
-                gatewayUrl: inst.gatewayUrl,
-                accessToken: inst.accessToken,
-                flushDelay: inst.flushDelay,
-                owner: inst.owner,
-                agentName: inst.agentName,
-                channelName: inst.name,
-                aunTrace: config.debug?.aunTrace,
-                aunSdkLog: config.debug?.aunSdkLog,
-            });
-            const adapter = {
-                channelName: inst.name,
-                channelKey: inst.name, // channelName 实际上就是 channelKey
-                capabilities: { file: true, image: true, interaction: true, markdown: true, thought: true, status: true, thread: true },
-                send: async (envelope, payload) => {
-                    const ctx = envelope.replyContext;
-                    const channelId = envelope.channelId;
-                    switch (payload.kind) {
-                        case 'result.text':
-                        case 'command.result':
-                        case 'command.error':
-                        case 'system.notice':
-                        case 'system.error':
-                        case 'result.error': {
-                            const sendCtx = { ...(ctx ?? {}) };
-                            if (payload.kind === 'result.text' && payload.isFinal)
-                                sendCtx.title = '✅ 最终回复:';
-                            await channel.sendMessage(channelId, payload.text, sendCtx);
-                            return;
-                        }
-                        case 'result.file':
-                            await channel.sendFile(channelId, payload.filePath, ctx);
-                            return;
-                        case 'result.image': {
-                            // AUN 支持 image，走 sendStructured 发 type=image payload
-                            const buf = payload.data;
-                            const b64 = buf.toString('base64');
-                            await channel.sendStructured(channelId, {
-                                type: 'image',
-                                alt: payload.alt,
-                                data_base64: b64,
-                                mime_type: payload.mimeType,
-                            }, ctx);
-                            return;
-                        }
-                        case 'activity.batch': {
-                            const aunPayload = {
-                                type: 'thought',
-                                items: payload.items,
-                                client_context: { task_id: envelope.taskId, chatmode: envelope.chatmode, agent_name: envelope.agentName },
-                            };
-                            if (ctx?.threadId)
-                                aunPayload.thread_id = ctx.threadId;
+    async createInstance(inst, ctx) {
+        // AUN aid is the agent's own AID; loader injects it as inst.aid, ctx.agentName is the source of truth.
+        const aid = inst.aid ?? ctx.agentName;
+        if (inst.enabled === false || !aid)
+            return null;
+        const channel = new AUNChannel({
+            aid,
+            keystorePath: inst.keystorePath,
+            gatewayUrl: inst.gatewayUrl,
+            accessToken: inst.accessToken,
+            flushDelay: inst.flushDelay,
+            owner: inst.owner ?? inst.owners?.[0],
+            agentName: ctx.agentName,
+            channelName: inst.name,
+            aunTrace: ctx.debug?.aunTrace,
+            aunSdkLog: ctx.debug?.aunSdkLog,
+        });
+        const mode = resolveShowActivities(inst);
+        const adapter = {
+            channelName: inst.name,
+            channelKey: inst.name, // channelName 实际上就是 channelKey
+            capabilities: { file: true, image: true, interaction: true, markdown: true, thought: true, status: true, thread: true },
+            send: async (envelope, payload) => {
+                const replyCtx = envelope.replyContext;
+                const channelId = envelope.channelId;
+                const taskBase = () => channel.buildTaskPayloadBase(envelope, replyCtx);
+                switch (payload.kind) {
+                    case 'result.text':
+                    case 'command.result':
+                    case 'command.error': {
+                        const sendCtx = { ...(replyCtx ?? {}) };
+                        if (payload.kind === 'result.text' && payload.isFinal)
+                            sendCtx.title = '✅ 最终回复:';
+                        await channel.sendMessage(channelId, payload.text, sendCtx);
+                        return;
+                    }
+                    case 'system.notice': {
+                        await channel.sendReliableStructured(channelId, {
+                            type: 'notice',
+                            ...taskBase(),
+                            subtype: payload.subtype,
+                            text: payload.text,
+                            severity: 'info',
+                        }, replyCtx, payload.text);
+                        return;
+                    }
+                    case 'system.error': {
+                        await channel.sendReliableStructured(channelId, {
+                            type: 'error',
+                            ...taskBase(),
+                            subtype: payload.subtype,
+                            message: payload.text,
+                            user_message: payload.text,
+                            recoverable: payload.recoverable,
+                            terminal: !payload.recoverable,
+                        }, replyCtx, payload.text);
+                        return;
+                    }
+                    case 'result.error': {
+                        await channel.sendReliableStructured(channelId, {
+                            type: 'error',
+                            ...taskBase(),
+                            reason: payload.reason,
+                            message: payload.text,
+                            user_message: payload.text,
+                            terminal: true,
+                        }, replyCtx, payload.text);
+                        return;
+                    }
+                    case 'result.file': {
+                        const fileCtx = payload.correlationId
+                            ? { ...(replyCtx ?? {}), metadata: { ...(replyCtx?.metadata ?? {}), correlationId: payload.correlationId } }
+                            : replyCtx;
+                        await channel.sendFile(channelId, payload.filePath, fileCtx);
+                        return;
+                    }
+                    case 'result.image': {
+                        const buf = payload.data;
+                        const b64 = buf.toString('base64');
+                        await channel.sendContentPayload(channelId, {
+                            type: 'image', alt: payload.alt, data_base64: b64, mime_type: payload.mimeType,
+                        }, {
+                            contentKind: 'image',
+                            context: replyCtx,
+                            logText: payload.alt ? `[image] ${payload.alt}` : '[image]',
+                        });
+                        return;
+                    }
+                    case 'activity.batch': {
+                        const items = Array.isArray(payload.items) ? payload.items : [];
+                        for (const item of items) {
+                            if (item?.kind === 'progress') {
+                                channel.sendProcessingStatus(channelId, 'progress', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, {
+                                    activityType: 'progress',
+                                    text: item.text,
+                                    state: item.state,
+                                    toolUses: item.tool_uses,
+                                    durationMs: item.duration_ms,
+                                });
+                                continue;
+                            }
+                            const aunPayload = channel.buildActivityPayload(envelope, replyCtx, item);
                             if (envelope.chatmode === 'proactive') {
-                                await channel.sendThought(channelId, envelope.taskId, aunPayload, ctx);
+                                await channel.sendThought(channelId, envelope.taskId, aunPayload, replyCtx);
                             }
                             else {
-                                // interactive 模式不发 thought.put，只写入消息历史
-                                await channel.sendStructured(channelId, aunPayload, ctx);
+                                await channel.sendReliableStructured(channelId, aunPayload, replyCtx, channel.activityLogText(item));
                             }
-                            return;
                         }
-                        case 'status.progress':
-                            channel.sendProcessingStatus(channelId, 'progress', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.started':
-                            channel.sendProcessingStatus(channelId, 'start', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.queued':
-                            channel.sendProcessingStatus(channelId, 'queued', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.completed':
-                            channel.sendProcessingStatus(channelId, 'done', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.interrupted':
-                            channel.sendProcessingStatus(channelId, 'interrupted', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.error':
-                            channel.sendProcessingStatus(channelId, 'error', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'status.timeout':
-                            channel.sendProcessingStatus(channelId, 'timeout', envelope.sessionId ?? envelope.taskId, envelope.taskId, ctx, payload.metadata);
-                            return;
-                        case 'interaction': {
-                            const req = payload.interaction;
-                            if (req.kind.kind === 'action') {
-                                const action = req.kind;
-                                const aunCard = {
-                                    type: 'action_card',
-                                    title: action.title,
-                                    actions: action.buttons.map(btn => ({
-                                        label: btn.label,
-                                        value: btn.key,
-                                        style: btn.style ?? 'default',
-                                        behavior: 'reply',
-                                    })),
-                                };
-                                if (action.body)
-                                    aunCard.description = action.body;
-                                if (ctx?.threadId)
-                                    aunCard.thread_id = ctx.threadId;
-                                const msgId = await channel.sendStructured(channelId, aunCard, ctx);
-                                if (msgId) {
-                                    channel.cardMessageIdMap.set(msgId, { requestId: req.id, isCommandCard: false });
-                                    setTimeout(() => channel.cardMessageIdMap.delete(msgId), 20 * 60 * 1000);
-                                }
-                            }
-                            else if (req.kind.kind === 'command-card') {
-                                const card = req.kind;
-                                const aunCard = {
-                                    type: 'action_card',
-                                    title: card.title,
-                                    actions: card.buttons.map(btn => ({
-                                        label: btn.label,
-                                        value: btn.command,
-                                        style: btn.style ?? 'default',
-                                        behavior: 'reply',
-                                    })),
-                                };
-                                if (card.body)
-                                    aunCard.description = card.body;
-                                if (ctx?.threadId)
-                                    aunCard.thread_id = ctx.threadId;
-                                const msgId = await channel.sendStructured(channelId, aunCard, ctx);
-                                if (msgId) {
-                                    channel.cardMessageIdMap.set(msgId, { requestId: req.id, isCommandCard: true, initiatorAid: req.initiatorId });
-                                    setTimeout(() => channel.cardMessageIdMap.delete(msgId), 20 * 60 * 1000);
-                                }
-                            }
-                            else if (payload.fallbackText) {
-                                await channel.sendMessage(channelId, payload.fallbackText, ctx);
-                            }
-                            return;
+                        return;
+                    }
+                    case 'status.progress':
+                        channel.sendProcessingStatus(channelId, 'progress', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.started':
+                        channel.sendProcessingStatus(channelId, 'start', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.queued':
+                        channel.sendProcessingStatus(channelId, 'queued', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.completed':
+                        channel.sendProcessingStatus(channelId, 'done', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.interrupted':
+                        channel.sendProcessingStatus(channelId, 'interrupted', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.error':
+                        channel.sendProcessingStatus(channelId, 'error', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'status.timeout':
+                        channel.sendProcessingStatus(channelId, 'timeout', envelope.sessionId ?? envelope.taskId, envelope.taskId, replyCtx, payload.metadata);
+                        return;
+                    case 'interaction': {
+                        const req = payload.interaction;
+                        if (req.kind.kind === 'action') {
+                            const action = req.kind;
+                            const aunCard = {
+                                type: 'action_card',
+                                title: action.title,
+                                actions: action.buttons.map(btn => ({
+                                    label: btn.label, value: btn.key, style: btn.style ?? 'default', behavior: 'reply',
+                                })),
+                            };
+                            if (action.body)
+                                aunCard.description = action.body;
+                            if (req.initiatorId && channel.isGroupId(channelId))
+                                aunCard.initiator = req.initiatorId;
+                            if (replyCtx?.threadId)
+                                aunCard.thread_id = replyCtx.threadId;
+                            await channel.sendContentPayload(channelId, aunCard, {
+                                contentKind: 'card',
+                                context: replyCtx,
+                                logText: action.title ? `[card] ${action.title}` : '[card]',
+                                postSend: {
+                                    type: 'register_interaction_card',
+                                    requestId: req.id,
+                                    isCommandCard: false,
+                                    initiatorAid: req.initiatorId,
+                                    expiresAt: Date.now() + 20 * 60 * 1000,
+                                },
+                            });
                         }
-                        case 'custom': {
-                            const text = typeof payload.payload === 'string' ? payload.payload : JSON.stringify(payload.payload);
-                            channel.sendCustomPayload(channelId, text);
-                            return;
+                        else if (req.kind.kind === 'command-card') {
+                            const card = req.kind;
+                            const aunCard = {
+                                type: 'action_card',
+                                title: card.title,
+                                actions: card.buttons.map(btn => ({
+                                    label: btn.label, value: btn.command, style: btn.style ?? 'default', behavior: 'reply', disabled: btn.disabled || undefined,
+                                })),
+                            };
+                            if (card.body)
+                                aunCard.description = card.body;
+                            if (replyCtx?.threadId)
+                                aunCard.thread_id = replyCtx.threadId;
+                            await channel.sendContentPayload(channelId, aunCard, {
+                                contentKind: 'card',
+                                context: replyCtx,
+                                logText: card.title ? `[card] ${card.title}` : '[card]',
+                                postSend: {
+                                    type: 'register_interaction_card',
+                                    requestId: req.id,
+                                    isCommandCard: true,
+                                    initiatorAid: req.initiatorId,
+                                    expiresAt: Date.now() + 20 * 60 * 1000,
+                                },
+                            });
+                        }
+                        else if (payload.fallbackText) {
+                            await channel.sendMessage(channelId, payload.fallbackText, replyCtx);
                         }
-                        default:
-                            logger.warn(`[AUN] Unhandled payload kind: ${payload.kind}`);
+                        return;
                     }
-                }, acknowledge: (messageId) => { channel.acknowledge(messageId); return Promise.resolve(); }, onInteraction: (cb) => { channel.interactionCallback = cb; }, uploadAgentMd: (content) => channel.uploadAgentMd(content),
-                downloadAgentMd: (aid) => channel.downloadAgentMd(aid),
-                getGroupName: (groupId) => channel.getGroupName(groupId), _selfAid: () => channel.getStatus().aid,
-                _selfName: () => channel.getSelfName(),
-            };
-            const policy = {
-                canSwitchProject: (chatType, identity) => identity === 'owner' || identity === 'admin',
-                canListProjects: (chatType, identity) => identity === 'owner' || identity === 'admin',
-                canCreateSession: (chatType, identity) => true,
-                canDeleteSession: (chatType, identity) => true,
-                canImportCliSession: (chatType, identity) => identity === 'owner' || identity === 'admin',
-                messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
-                showMiddleResult: (chatType, identity) => {
-                    const mode = getChannelShowActivities(config, inst.name);
-                    if (mode === 'none')
-                        return false;
-                    if (mode === 'dm-only')
-                        return chatType === 'private';
-                    if (mode === 'owner-dm-only')
-                        return chatType === 'private' && identity === 'owner';
-                    return true;
-                },
-                showIdleMonitor: (chatType, identity) => {
-                    const mode = getChannelShowActivities(config, inst.name);
-                    if (mode === 'none')
-                        return false;
-                    if (mode === 'dm-only')
-                        return chatType === 'private';
-                    if (mode === 'owner-dm-only')
-                        return chatType === 'private' && identity === 'owner';
-                    return true;
-                },
-                accumulateErrors: (chatType, identity) => true,
-            };
-            const options = {
-                flushDelay: inst.flushDelay ?? 3,
-                fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g,
-            };
-            result.push({
-                channelType: 'aun',
-                adapter,
-                channel,
-                policy,
-                options,
-                connect: () => channel.connect(),
-                disconnect: () => channel.disconnect(),
-                onProjectPathRequest: (channelId) => Promise.resolve(config.projects?.defaultPath || process.cwd()),
-                registerBridge(bridge, channelType) {
-                    bridge.register(adapter.channelName, (handler) => channel.onMessage(async (opts) => {
-                        handler(aunOptsToInbound(opts, adapter.channelName, channelType));
-                    }), (channelId, text, replyContext) => channel.sendMessage(channelId, text, replyContext), adapter, channelType);
-                },
-                registerHooks(ctx) {
-                    channel.setEventBus(ctx.eventBus);
-                    if (channel.setOnChannelDown) {
-                        channel.setOnChannelDown(() => {
-                            ctx.eventBus.publish({
-                                type: 'channel:error',
-                                channel: 'aun',
-                                channelName: adapter.channelName,
-                                status: 'auth_error',
-                                message: `⚠️ AUN 渠道 ${adapter.channelName} 断连，自动重试已用尽。\n使用 /check rty aun 手动重连`,
-                                timestamp: Date.now(),
-                            });
-                        });
+                    case 'custom': {
+                        const text = typeof payload.payload === 'string' ? payload.payload : JSON.stringify(payload.payload);
+                        channel.sendCustomPayload(channelId, text);
+                        return;
                     }
-                    if (typeof channel.setDispatchModeResolver === 'function') {
-                        channel.setDispatchModeResolver(async (channelId) => {
-                            const session = await ctx.sessionManager.getActiveSession(adapter.channelName, channelId);
-                            return session?.metadata?.dispatchMode;
+                    default:
+                        logger.warn(`[AUN] Unhandled payload kind: ${payload.kind}`);
+                }
+            },
+            acknowledge: (messageId) => { channel.acknowledge(messageId); return Promise.resolve(); },
+            onInteraction: (cb) => { channel.interactionCallback = cb; },
+            uploadAgentMd: (content) => channel.uploadAgentMd(content),
+            downloadAgentMd: (aid) => channel.downloadAgentMd(aid),
+            getGroupName: (groupId) => channel.getGroupName(groupId),
+            getGroupMemberRole: (groupId, aid) => channel.getGroupMemberRole(groupId, aid),
+            _selfAid: () => channel.getStatus().aid,
+            _selfName: () => channel.getSelfName(),
+        };
+        const policy = {
+            canSwitchProject: (_, identity) => identity === 'owner' || identity === 'admin',
+            canListProjects: (_, identity) => identity === 'owner' || identity === 'admin',
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: (_, identity) => identity === 'owner' || identity === 'admin',
+            messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+            showMiddleResult: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            showIdleMonitor: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            accumulateErrors: () => true,
+        };
+        return {
+            channelType: 'aun', adapter, channel,
+            policy,
+            options: { flushDelay: inst.flushDelay ?? 3, fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g },
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+            onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
+            registerBridge(bridge, channelType) {
+                bridge.register(adapter.channelName, (handler) => channel.onMessage(async (opts) => {
+                    handler(aunOptsToInbound(opts, adapter.channelName, channelType));
+                }), (channelId, text, replyContext) => channel.sendMessage(channelId, text, replyContext), adapter, channelType);
+            },
+            registerHooks(hookCtx) {
+                channel.setEventBus(hookCtx.eventBus);
+                if (channel.setOnChannelDown) {
+                    channel.setOnChannelDown(() => {
+                        hookCtx.eventBus.publish({
+                            type: 'channel:error',
+                            channel: 'aun',
+                            channelName: adapter.channelName,
+                            status: 'auth_error',
+                            message: `⚠️ AUN 渠道 ${adapter.channelName} 断连，自动重试已用尽。\n使用 /check rty aun 手动重连`,
+                            timestamp: Date.now(),
                         });
-                    }
-                },
-            });
-        }
-        return result;
-    }
-    async createChannel(config) {
-        const instances = await this.createChannels(config);
-        if (instances.length === 0) {
-            throw new Error('AUN config missing (aid required, e.g. "mybot.agentid.pub")');
-        }
-        return instances[0];
+                    });
+                }
+                if (typeof channel.setDispatchModeResolver === 'function') {
+                    channel.setDispatchModeResolver(async (channelId) => {
+                        const session = await hookCtx.sessionManager.getActiveSession(adapter.channelName, channelId);
+                        return session?.metadata?.dispatchModeOverride;
+                    });
+                }
+            },
+        };
     }
 }