evolclaw 2.6.1 → 2.6.3

package/dist/channels/aun.js

@@ -1,4 +1,4 @@
-import { AUNClient, GatewayDiscovery } from '@agentunion/fastaun';
+import { AUNClient, GatewayDiscovery, E2EEError } from '@agentunion/fastaun';
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
@@ -58,9 +58,16 @@ export class AUNChannel {
         const logPath = path.join(resolvePaths().logs, `aun-${today}.log`);
         this.traceStream = fs.createWriteStream(logPath, { flags: 'a' });
     }
-    /** 判断 channelId 是否为群组 ID（g-xxx.agentid.pub 或 grp_ 前缀） */
+    /** 判断 channelId 是否为群组 ID
+     *  - 新格式：group.{issuer}/{group_no|group_name}
+     *  - 数字群号：{group_no}.{issuer}（如 11117.agentid.pub）
+     *  - 兼容旧格式：grp_xxx、g-xxx.agentid.pub
+     */
     isGroupId(id) {
-        return id.startsWith('grp_') || (id.startsWith('g-') && id.includes('.'));
+        return (id.startsWith('group.') && id.includes('/'))
+            || /^\d+\./.test(id)
+            || id.startsWith('grp_')
+            || (id.startsWith('g-') && id.includes('.'));
     }
     getShortAid(aid) {
         if (!aid)
@@ -113,12 +120,26 @@ export class AUNChannel {
         if (messageId)
             this.messageSeqMap.delete(messageId);
     }
+    shouldEncrypt(peerId) {
+        const cached = this.peerE2ee.get(peerId);
+        if (!cached)
+            return true;
+        if (Date.now() - cached.ts > AUNChannel.E2EE_PROBE_TTL) {
+            this.peerE2ee.delete(peerId);
+            return true;
+        }
+        return cached.ok;
+    }
     _aid;
+    _selfName; // 本地 agent.md 中的 name，首次 connect 时读取
     _chatId = ''; // aid:device_id:slot_id — 多实例回声过滤
     seenMessages = new Map();
     peerInfoCache = new Map();
     messageSeqMap = new Map(); // messageId → seq (for ack)
     sentCount = new Map(); // channelId → 已发消息计数（用于判断最终回复）
+    peerE2ee = new Map();
+    static E2EE_PROBE_TTL = 10 * 60 * 1000; // 10min
+    plaintextRecv = 0;
     // Reconnect state (TS-layer fallback, on top of SDK auto_reconnect)
     intentionalDisconnect = false;
     reconnectAttempt = 0;
@@ -153,7 +174,7 @@ export class AUNChannel {
             this.client = null;
         }
         this.connected = false;
-        const aunPath = this.config.keystorePath || `${process.env.HOME || '~'}/.aun`;
+        const aunPath = this.config.keystorePath || path.join(os.homedir(), '.aun');
         const aidName = this.config.aid;
         const encryptionSeed = this.config.encryptionSeed || process.env.AUN_ENCRYPTION_SEED || undefined;
         // Gateway URL 解析：优先用配置的 gatewayUrl，否则通过 well-known 自动发现
@@ -177,12 +198,12 @@ export class AUNChannel {
         logger.info(`[AUN] Initializing: aid=${aidName}, gateway=${gateway}, aun_path=${aunPath}`);
         // Create client with FileSecretStore (AES-256-GCM)
         // 不传 encryption_seed 时，SDK 自动从 {aun_path}/.seed 文件派生密钥（与 aun_cli.py 对齐）
-        const rootCaPath = `${aunPath}/CA/root/root.crt`;
+        const rootCaPath = path.join(aunPath, 'CA', 'root', 'root.crt');
         this.client = new AUNClient({
             aun_path: aunPath,
             root_ca_path: rootCaPath,
             ...(encryptionSeed && { encryption_seed: encryptionSeed }),
-        });
+        }, this.config.aunSdkLog ?? true);
         // Set gateway URL (internal property, same as Python SDK)
         this.client._gatewayUrl = gateway;
         // Register event handlers before connecting
@@ -218,6 +239,16 @@ export class AUNChannel {
                 }
             }
         });
+        this.client.on('message.undecryptable', (data) => {
+            this.trace('IN', 'message.undecryptable', data);
+            const d = data;
+            logger.warn(`[AUN] Message undecryptable: from=${d.from} mid=${d.message_id} err=${d._decrypt_error}`);
+        });
+        this.client.on('group.message_undecryptable', (data) => {
+            this.trace('IN', 'group.message_undecryptable', data);
+            const d = data;
+            logger.warn(`[AUN] Group message undecryptable: group=${d.group_id} from=${d.from} mid=${d.message_id} err=${d._decrypt_error}`);
+        });
         // Authenticate
         // Workaround: SDK 0.3.x _loadIdentityOrRaise doesn't set identity.aid from requested aid,
         // causing gateway "missing aid" error. Patch to backfill aid on loaded identity.
@@ -262,6 +293,7 @@ export class AUNChannel {
             this._aid = this.client.aid ?? undefined;
             const deviceId = this.client._device_id ?? '';
             this._chatId = this._aid ? `${this._aid}:${deviceId}:` : '';
+            this._selfName = this.loadSelfName(aidName);
             this.connected = true;
             this.reconnectAttempt = 0;
             // Workaround: SDK e2ee uses _identity.cert for sender_cert_fingerprint;
@@ -388,7 +420,21 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
 - 所有命令以 \`/\` 开头
 
 现在，请先使用 \`/bind\` 命令绑定您的项目目录，然后就可以开始工作了！`;
-            await this.sendMessage(owner, welcomeText);
+            // First contact with Owner races against Owner's async cert fetch from
+            // gateway PKI; a 3s pause lets the cert propagate. persist_required asks
+            // the gateway to durably store the message so Owner can recover it via
+            // pull if the initial E2EE push still arrives before the cert resolves.
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            if (!this.client) {
+                logger.warn('[AUN] Client disconnected before welcome message could be sent');
+                return;
+            }
+            await this.client.call('message.send', {
+                to: owner,
+                payload: { type: 'text', text: welcomeText },
+                encrypt: true,
+                persist_required: true,
+            });
             logger.info(`[AUN] Welcome message sent to owner: ${owner}`);
         }
         catch (e) {
@@ -471,6 +517,16 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             this.acknowledgeImmediately(messageId, seq);
             return;
         }
+        // E2EE 能力探测：收到加密消息则标记对端支持，明文则计数审计
+        const msgEncrypted = !!(msg.e2ee);
+        if (fromAid) {
+            if (msgEncrypted) {
+                this.peerE2ee.set(fromAid, { ok: true, ts: Date.now() });
+            }
+            else {
+                this.plaintextRecv++;
+            }
+        }
         // Detect @mentions
         const mentions = [];
         if (this._aid && text.includes(`@${this._aid}`)) {
@@ -543,6 +599,16 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             this.acknowledgeImmediately(messageId, seq);
             return;
         }
+        // E2EE 能力探测：收到加密群消息则标记发送者支持
+        const msgEncrypted = !!(msg.e2ee);
+        if (senderAid) {
+            if (msgEncrypted) {
+                this.peerE2ee.set(senderAid, { ok: true, ts: Date.now() });
+            }
+            else {
+                this.plaintextRecv++;
+            }
+        }
         // dispatch_mode from server tells agent how to work in this group
         const dispatchMode = msg.dispatch_mode ?? payload?.dispatch_mode ?? 'mention';
         const mentionedSelf = this._aid
@@ -725,28 +791,68 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const payload = { type: 'text', text: finalText };
         if (context?.threadId)
             payload.thread_id = context.threadId;
-        const params = { payload, encrypt: true };
+        if (context?.metadata?.taskId)
+            payload.task_id = context.metadata.taskId;
+        if (context?.metadata?.chatmode)
+            payload.chatmode = context.metadata.chatmode;
+        const isGroup = this.isGroupId(channelId);
         // Multi-instance routing: channelId may be "aid:device_id:slot_id"
         const colonIdx = channelId.indexOf(':');
         const targetAid = colonIdx > 0 ? channelId.substring(0, colonIdx) : channelId;
         if (colonIdx > 0) {
-            params.payload.chat_id = channelId;
+            payload.chat_id = channelId;
         }
+        const encryptTarget = isGroup ? channelId : targetAid;
+        const encrypt = this.shouldEncrypt(encryptTarget);
+        const params = { payload, encrypt };
         try {
-            if (this.isGroupId(channelId)) {
+            if (isGroup) {
                 params.group_id = channelId;
                 this.trace('OUT', 'group.send', params);
-                await this.client.call('group.send', params);
+                const result = await this.client.call('group.send', params);
+                if (!result || !result.message_id) {
+                    logger.warn(`[AUN] group.send returned no message_id: ${JSON.stringify(result)}`);
+                }
             }
             else {
                 params.to = targetAid;
                 this.trace('OUT', 'message.send', params);
-                await this.client.call('message.send', params);
+                const result = await this.client.call('message.send', params);
+                if (!result || !result.message_id) {
+                    logger.warn(`[AUN] message.send returned no message_id: ${JSON.stringify(result)}`);
+                }
             }
         }
         catch (e) {
-            this.trace('OUT', 'send.error', { channelId, error: String(e) });
-            logger.error(`[AUN] Send failed to ${channelId}: ${e}`);
+            if (encrypt && e instanceof E2EEError) {
+                this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
+                logger.warn(`[AUN] E2EE send failed to ${channelId}, retrying plaintext: ${e}`);
+                params.encrypt = false;
+                try {
+                    if (isGroup) {
+                        this.trace('OUT', 'group.send.fallback', params);
+                        const result = await this.client.call('group.send', params);
+                        if (!result || !result.message_id) {
+                            logger.warn(`[AUN] group.send fallback returned no message_id: ${JSON.stringify(result)}`);
+                        }
+                    }
+                    else {
+                        this.trace('OUT', 'message.send.fallback', params);
+                        const result = await this.client.call('message.send', params);
+                        if (!result || !result.message_id) {
+                            logger.warn(`[AUN] message.send fallback returned no message_id: ${JSON.stringify(result)}`);
+                        }
+                    }
+                }
+                catch (e2) {
+                    this.trace('OUT', 'send.fallback.error', { channelId, error: String(e2) });
+                    logger.error(`[AUN] Plaintext fallback also failed to ${channelId}: ${e2}`);
+                }
+            }
+            else {
+                this.trace('OUT', 'send.error', { channelId, error: String(e) });
+                logger.error(`[AUN] Send failed to ${channelId}: ${e}`);
+            }
         }
     }
     /**
@@ -783,8 +889,14 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             }
         }
         catch (e) {
-            this.trace('OUT', 'thought.put.error', { channelId, error: String(e) });
-            logger.debug(`[AUN] thought.put failed to ${channelId}: ${e}`);
+            const err = e;
+            this.trace('OUT', 'thought.put.error', {
+                channelId,
+                errorName: err?.name,
+                errorCode: err?.code,
+                errorMessage: err?.message,
+            });
+            logger.debug(`[AUN] thought.put failed to ${channelId}: ${err?.name}(${err?.code})=${err?.message}`);
         }
     }
     async sendFile(channelId, filePath, context) {
@@ -860,22 +972,61 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             };
             if (context?.threadId)
                 filePayload.thread_id = context.threadId;
-            const params = { payload: filePayload, encrypt: true };
+            if (context?.metadata?.taskId)
+                filePayload.task_id = context.metadata.taskId;
+            if (context?.metadata?.chatmode)
+                filePayload.chatmode = context.metadata.chatmode;
+            const isGroup = this.isGroupId(channelId);
             // Multi-instance routing
             const fileColonIdx = channelId.indexOf(':');
             const fileTargetAid = fileColonIdx > 0 ? channelId.substring(0, fileColonIdx) : channelId;
             if (fileColonIdx > 0) {
-                params.payload.chat_id = channelId;
+                filePayload.chat_id = channelId;
             }
-            if (this.isGroupId(channelId)) {
-                params.group_id = channelId;
-                this.trace('OUT', 'group.send.file', params);
-                await this.client.call('group.send', params);
+            const encryptTarget = isGroup ? channelId : fileTargetAid;
+            const encrypt = this.shouldEncrypt(encryptTarget);
+            const params = { payload: filePayload, encrypt };
+            try {
+                if (isGroup) {
+                    params.group_id = channelId;
+                    this.trace('OUT', 'group.send.file', params);
+                    const result = await this.client.call('group.send', params);
+                    if (!result || !result.message_id) {
+                        logger.warn(`[AUN] group.send.file returned no message_id: ${JSON.stringify(result)}`);
+                    }
+                }
+                else {
+                    params.to = fileTargetAid;
+                    this.trace('OUT', 'message.send.file', params);
+                    const result = await this.client.call('message.send', params);
+                    if (!result || !result.message_id) {
+                        logger.warn(`[AUN] message.send.file returned no message_id: ${JSON.stringify(result)}`);
+                    }
+                }
             }
-            else {
-                params.to = fileTargetAid;
-                this.trace('OUT', 'message.send.file', params);
-                await this.client.call('message.send', params);
+            catch (sendErr) {
+                if (encrypt && sendErr instanceof E2EEError) {
+                    this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
+                    logger.warn(`[AUN] E2EE sendFile failed to ${channelId}, retrying plaintext: ${sendErr}`);
+                    params.encrypt = false;
+                    if (isGroup) {
+                        this.trace('OUT', 'group.send.file.fallback', params);
+                        const result = await this.client.call('group.send', params);
+                        if (!result || !result.message_id) {
+                            logger.warn(`[AUN] group.send.file fallback returned no message_id: ${JSON.stringify(result)}`);
+                        }
+                    }
+                    else {
+                        this.trace('OUT', 'message.send.file.fallback', params);
+                        const result = await this.client.call('message.send', params);
+                        if (!result || !result.message_id) {
+                            logger.warn(`[AUN] message.send.file fallback returned no message_id: ${JSON.stringify(result)}`);
+                        }
+                    }
+                }
+                else {
+                    throw sendErr;
+                }
             }
             logger.info(`[AUN] File sent: ${filename} (${formatSize(stat.size)}) → ${channelId}`);
         }
@@ -909,26 +1060,40 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         };
         if (context?.threadId)
             payload.thread_id = context.threadId;
-        const params = { payload, encrypt: true };
+        const isGroup = this.isGroupId(channelId);
         // Multi-instance routing
         const statusColonIdx = channelId.indexOf(':');
         const statusTargetAid = statusColonIdx > 0 ? channelId.substring(0, statusColonIdx) : channelId;
         if (statusColonIdx > 0) {
             payload.chat_id = channelId;
         }
-        if (this.isGroupId(channelId)) {
+        const encryptTarget = isGroup ? channelId : statusTargetAid;
+        const encrypt = this.shouldEncrypt(encryptTarget);
+        const params = { payload, encrypt };
+        const sendWithFallback = (method) => {
+            this.client.call(method, params).catch(e => {
+                if (encrypt && e instanceof E2EEError) {
+                    this.peerE2ee.set(encryptTarget, { ok: false, ts: Date.now() });
+                    logger.warn(`[AUN] E2EE status send failed to ${channelId}, retrying plaintext`);
+                    params.encrypt = false;
+                    this.client.call(method, params).catch(e2 => {
+                        logger.debug(`[AUN] Processing status fallback failed: ${e2}`);
+                    });
+                }
+                else {
+                    logger.debug(`[AUN] Processing status failed: ${e}`);
+                }
+            });
+        };
+        if (isGroup) {
             params.group_id = channelId;
             this.trace('OUT', 'group.send.status', params);
-            this.client.call('group.send', params).catch(e => {
-                logger.debug(`[AUN] Processing status failed: ${e}`);
-            });
+            sendWithFallback('group.send');
         }
         else {
             params.to = statusTargetAid;
             this.trace('OUT', 'message.send.status', params);
-            this.client.call('message.send', params).catch(e => {
-                logger.debug(`[AUN] Processing status failed: ${e}`);
-            });
+            sendWithFallback('message.send');
         }
     }
     sendCustomPayload(channelId, payload) {
@@ -1036,8 +1201,30 @@ EvolClaw AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             aid: this._aid,
             reconnectAttempt: this.reconnectAttempt,
             maxAttempts: AUNChannel.RECONNECT_DELAYS.length,
+            plaintextRecv: this.plaintextRecv,
         };
     }
+    /** 读取本地 agent.md 中的 name（用于身份上下文展示） */
+    loadSelfName(aid) {
+        try {
+            const aidName = aid.startsWith('@') ? aid.slice(1) : aid;
+            const agentMdPath = path.join(os.homedir(), '.aun', 'AIDs', aidName, 'agent.md');
+            if (!fs.existsSync(agentMdPath))
+                return undefined;
+            const content = fs.readFileSync(agentMdPath, 'utf-8');
+            const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            if (!fmMatch)
+                return undefined;
+            const nameMatch = fmMatch[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
+            return nameMatch?.[1]?.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getSelfName() {
+        return this._selfName;
+    }
     async fetchPeerInfo(aid) {
         const cached = this.peerInfoCache.get(aid);
         if (cached !== undefined)
@@ -1097,6 +1284,7 @@ export class AUNChannelPlugin {
                 encryptionSeed: inst.encryptionSeed,
                 owner: inst.owner,
                 aunTrace: config.debug?.aunTrace,
+                aunSdkLog: config.debug?.aunSdkLog,
             });
             const adapter = {
                 channelName: inst.name,
@@ -1109,6 +1297,7 @@ export class AUNChannelPlugin {
                 downloadAgentMd: (aid) => channel.downloadAgentMd(aid),
                 putThought: (id, taskId, payload) => channel.sendThought(id, taskId, payload),
                 _selfAid: () => channel.getStatus().aid,
+                _selfName: () => channel.getSelfName(),
             };
             const policy = {
                 canSwitchProject: (chatType, identity) => identity === 'owner' || identity === 'admin',

package/dist/core/command-handler.js

@@ -233,11 +233,23 @@ export class CommandHandler {
     async sendInteractionCard(opts) {
         if (!this.interactionRouter)
             return false;
+        // 无写权限 → 走文本降级（由调用点 fall through 输出只读信息）
+        if (opts.canWrite === false)
+            return false;
+        // 有写权限但此刻忙碌 → 也走文本降级（避免诱导用户在忙碌状态下触发带参写操作）
+        if (this.isSessionBusy(opts.sessionId))
+            return false;
         await this.invalidateOldCards(opts.channel, opts.sessionId);
         const messageId = await this.trySendInteraction(opts.channel, opts.channelId, opts.interaction, opts.replyCtx);
         if (!messageId)
             return false;
         const wrappedCallback = async (action, values, operatorId) => {
+            // 点击回调时二次校验：若会话此刻忙碌，忽略本次点击（防止已弹卡片被用于带参切换）
+            if (this.isSessionBusy(opts.sessionId)) {
+                const adapter = this.adapters.get(opts.channel);
+                adapter?.sendText(opts.channelId, '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试', opts.replyCtx);
+                return;
+            }
             await opts.callback(action, values, operatorId);
             // 已完成交互的卡片：保留原始内容，仅禁用按钮（不标记为"已过期"）
             // "已过期"仅用于被新卡片替代的旧卡片（invalidateOldCards）
@@ -245,6 +257,14 @@ export class CommandHandler {
         this.interactionRouter.register(opts.requestId, opts.sessionId, wrappedCallback, { timeoutMs: 120_000, messageId });
         return true;
     }
+    /** 判断指定 session 是否有活跃流（用于 idle 守卫和卡片降级） */
+    isSessionBusy(sessionId) {
+        for (const agent of this.agentMap.values()) {
+            if (agent.hasActiveStream(sessionId))
+                return true;
+        }
+        return false;
+    }
     /** 获取活跃会话，无会话时返回统一错误提示 */
     async ensureSession(channel, channelId, threadId) {
         if (threadId) {
@@ -525,10 +545,18 @@ export class CommandHandler {
         const isAdmin = identity.role === 'owner' || identity.role === 'admin';
         const activeChatType = activeSession?.chatType || 'private';
         if (normalizedContent.startsWith('/')) {
-            const guestGroupCommands = ['/status', '/help', '/check'];
+            // guest 在群聊和私聊中均可访问的只读命令：纯查询形态（带参写操作由各 handler 内部守卫拦截）
+            const guestGroupCommands = [
+                '/status', '/help', '/check', '/chatmode',
+                '/model', '/effort', '/agent', '/perm', '/activity', '/safe',
+            ];
             const userCommands = activeChatType === 'group' && !isAdmin
                 ? guestGroupCommands
-                : ['/slist', '/new', '/session', '/rename', '/name', '/status', '/help', '/del', '/s ', '/check'];
+                : [
+                    ...guestGroupCommands,
+                    // 私聊 guest 额外可用：会话自管理 + 私聊专属的 /rewind 历史查看
+                    '/slist', '/new', '/session', '/rename', '/name', '/del', '/s ', '/rewind',
+                ];
             const isUserCommand = userCommands.some(cmd => normalizedContent === cmd.trimEnd() || normalizedContent.startsWith(cmd));
             if (!isUserCommand && !isAdmin) {
                 return activeChatType === 'group'
@@ -537,8 +565,16 @@ export class CommandHandler {
             }
         }
         // 空闲检查：某些命令需要等待当前会话空闲
-        const requiresIdle = ['/new', '/session', '/clear', '/compact', '/safe', '/repair', '/fork', '/bind', '/project', '/agent', '/rewind', '/chatmode'];
-        if (requiresIdle.some(cmd => normalizedContent === cmd || normalizedContent.startsWith(cmd + ' '))) {
+        // 原则：仅对"写/破坏性"形态拦截，纯读/用法提示的无参形态始终放行
+        // - 始终需要 idle（无参即写）：/new /clear /compact /repair /fork
+        // - 仅带参时需要 idle（无参是列表/用法）：/session /bind /project /agent /rewind
+        // - /chatmode：在 handler 内部自行做写操作的 idle 检查
+        // - /safe：已禁用 no-op，不再要求 idle
+        const idleAlways = ['/new', '/clear', '/compact', '/repair', '/fork'];
+        const idleWhenArg = ['/session', '/bind', '/project', '/agent', '/rewind'];
+        const needsIdle = idleAlways.some(cmd => normalizedContent === cmd || normalizedContent.startsWith(cmd + ' ')) ||
+            idleWhenArg.some(cmd => normalizedContent.startsWith(cmd + ' '));
+        if (needsIdle) {
             if (threadId) {
                 // 话题中：检查话题 session 是否在处理（不创建）
                 const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
@@ -691,6 +727,7 @@ export class CommandHandler {
                     const replyCtx = this.getReplyContext(permSession);
                     const cardSent = await this.sendInteractionCard({
                         channel, channelId, sessionId: permSession.id, requestId, interaction, replyCtx,
+                        canWrite: isOwner,
                         callback: async (action, _values, operatorId) => {
                             if (action !== currentMode) {
                                 if (userId && operatorId && operatorId !== userId)
@@ -712,7 +749,10 @@ export class CommandHandler {
                     const suffix = m.available ? '' : ' ⚠️ 不可用';
                     return `  ${prefix} ${m.key} (${m.nameZh}) - ${m.description}${suffix}`;
                 }).join('\n');
-                return `🔐 当前权限模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /perm <模式>              切换权限模式\n  /perm allow|always|deny   审批权限请求`;
+                if (isOwner) {
+                    return `🔐 当前权限模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /perm <模式>              切换权限模式\n  /perm allow|always|deny   审批权限请求`;
+                }
+                return `🔐 当前权限模式: ${currentMode}`;
             }
             const parts = args.split(/\s+/);
             // /perm <mode> 或 /perm allow|always|deny：切换模式 / 快捷审批
@@ -768,10 +808,11 @@ export class CommandHandler {
         }
         // /agent 命令：查看或切换 Agent 后端
         if (normalizedContent === '/agent' || normalizedContent.startsWith('/agent ')) {
-            // 群聊中 owner only，私聊中 admin+
-            if (activeChatType === 'group' ? !isOwner : !isAdmin)
-                return '❌ 无权限：此命令仅限管理员使用';
             const args = normalizedContent.slice(6).trim();
+            // 切换（带参）需权限：群聊 owner only，私聊 admin+；无参查询对所有人放开
+            if (args && (activeChatType === 'group' ? !isOwner : !isAdmin)) {
+                return '❌ 无权限：此命令仅限管理员使用';
+            }
             const available = [...this.agentMap.keys()];
             if (!args) {
                 const currentAgent = activeSession?.agentId || this.defaultAgentId;
@@ -796,6 +837,7 @@ export class CommandHandler {
                     const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
                     const cardSent = await this.sendInteractionCard({
                         channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
+                        canWrite: activeChatType === 'group' ? isOwner : isAdmin,
                         callback: async (action, _values, operatorId) => {
                             if (action !== currentAgent) {
                                 if (userId && operatorId && operatorId !== userId)
@@ -813,7 +855,11 @@ export class CommandHandler {
                 }
                 // 降级：文本
                 const list = available.map(a => `${a === currentAgent ? ' ✓' : '  '} ${a}`).join('\n');
-                return `当前 Agent: ${currentAgent}\n\n可用:\n${list}\n\n用法: /agent <name>`;
+                const canSwitchAgent = activeChatType === 'group' ? isOwner : isAdmin;
+                if (canSwitchAgent) {
+                    return `当前 Agent: ${currentAgent}\n\n可用:\n${list}\n\n用法: /agent <name>`;
+                }
+                return `当前 Agent: ${currentAgent}`;
             }
             if (!this.agentMap.has(args)) {
                 return `❌ 未知 Agent: ${args}\n可用: ${available.join(', ')}`;
@@ -871,6 +917,7 @@ export class CommandHandler {
                     const replyCtx = this.getReplyContext(modelSession);
                     const cardSent = await this.sendInteractionCard({
                         channel, channelId, sessionId: modelSession.id, requestId, interaction, replyCtx,
+                        canWrite: isAdmin,
                         callback: async (action, _values, operatorId) => {
                             if (action !== currentModel) {
                                 if (userId && operatorId && operatorId !== userId)
@@ -891,8 +938,14 @@ export class CommandHandler {
                 const effortHint = efforts.length > 0
                     ? `\n推理强度: ${currentEffort === 'auto' ? 'auto (SDK默认)' : currentEffort}  (使用 /effort 调整)`
                     : '';
-                return `当前模型: ${currentModel}${effortHint}\n\n可用模型：\n${modelList}\n\n${formatModelUsage(modelAgent, currentModel)}`;
+                if (isAdmin) {
+                    return `当前模型: ${currentModel}${effortHint}\n\n可用模型：\n${modelList}\n\n${formatModelUsage(modelAgent, currentModel)}`;
+                }
+                return `当前模型: ${currentModel}${effortHint}`;
             }
+            // 带参（切换/调整）需 admin+；无参查询已在上方返回
+            if (!isAdmin)
+                return '❌ 无权限：切换模型仅限管理员使用';
             const parts = args.split(/\s+/);
             let newModel;
             let newEffort;
@@ -1060,6 +1113,7 @@ export class CommandHandler {
                     const replyCtx = this.getReplyContext(effortSession);
                     const cardSent = await this.sendInteractionCard({
                         channel, channelId, sessionId: effortSession.id, requestId, interaction, replyCtx,
+                        canWrite: isAdmin,
                         callback: async (action, _values, operatorId) => {
                             if (action !== currentEffort) {
                                 if (userId && operatorId && operatorId !== userId)
@@ -1079,8 +1133,14 @@ export class CommandHandler {
                 const effortDisplay = currentEffort === 'auto' ? 'auto (SDK默认)' : currentEffort;
                 const allItems = [...efforts, 'auto'];
                 const effortList = allItems.map(e => `  ${e === currentEffort ? '✓' : ' '} ${e}${e === 'auto' ? ' (SDK默认)' : ''}`).join('\n');
-                return `⚡ 推理强度: ${effortDisplay}\n\n可选:\n${effortList}\n\n用法: /effort <level>`;
+                if (isAdmin) {
+                    return `⚡ 推理强度: ${effortDisplay}\n\n可选:\n${effortList}\n\n用法: /effort <level>`;
+                }
+                return `⚡ 推理强度: ${effortDisplay}`;
             }
+            // 带参（切换）需 admin+；无参查询已在上方返回
+            if (!isAdmin)
+                return '❌ 无权限：切换推理强度仅限管理员使用';
             // /effort auto：恢复 SDK 默认
             if (args === 'auto') {
                 effortAgent.setEffort?.(undefined);
@@ -1302,13 +1362,14 @@ export class CommandHandler {
             }
         }
         if (normalizedContent === '/activity' || normalizedContent.startsWith('/activity ')) {
-            if (!isAdmin)
+            const activityArg = normalizedContent.slice(9).trim();
+            // 带参（写操作）需 admin+；无参查询对所有人开放（owner 门在具体切换点还有一道）
+            if (activityArg && !isAdmin)
                 return '❌ 无权限：此命令仅限管理员使用';
             // proactive 模式下流式输出全部静默，activity 配置无意义
             if (activeSession?.sessionMode === 'proactive') {
                 return '❌ 当前会话为 proactive 模式，不支持 activity 配置（流式输出已全部静默）';
             }
-            const activityArg = normalizedContent.slice(9).trim();
             const modeMap = {
                 all: 'all',
                 dm: 'dm-only',
@@ -1348,6 +1409,7 @@ export class CommandHandler {
                     const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
                     const cardSent = await this.sendInteractionCard({
                         channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
+                        canWrite: isOwner,
                         callback: async (action, _values, operatorId) => {
                             const newMode = modeMap[action];
                             if (newMode && newMode !== currentMode) {
@@ -1369,7 +1431,10 @@ export class CommandHandler {
                     const prefix = m.configVal === currentMode ? '✓' : ' ';
                     return `  ${prefix} ${m.key} (${m.label})`;
                 }).join('\n');
-                return `📋 中间输出模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /activity <模式>    切换中间输出显示模式`;
+                if (isOwner) {
+                    return `📋 中间输出模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /activity <模式>    切换中间输出显示模式`;
+                }
+                return `📋 中间输出模式: ${currentMode}`;
             }
             const newMode = modeMap[activityArg];
             if (!newMode) {
@@ -1386,9 +1451,9 @@ export class CommandHandler {
             return `✅ 中间输出模式: ${activityArg}（${label}）`;
         }
         // /chatmode 命令：查看/切换 session 会话模式（interactive | proactive）
+        // - 查看：所有人可用
+        // - 设置：单聊任何角色可设置；群聊仅管理员可设置
         if (normalizedContent === '/chatmode' || normalizedContent.startsWith('/chatmode ')) {
-            if (!isAdmin)
-                return '❌ 无权限：此命令仅限管理员使用';
             if (!activeSession)
                 return '❌ 当前无活跃会话';
             const lockedMode = getChannelSessionMode(this.config, channel);
@@ -1396,17 +1461,37 @@ export class CommandHandler {
             const currentMode = activeSession.sessionMode || 'interactive';
             if (!arg) {
                 const lockHint = lockedMode ? `（由通道配置锁定为 ${lockedMode}）` : '';
-                return `📋 当前会话模式: ${currentMode}${lockHint}\n可选: interactive / proactive\n用法: /chatmode <模式>`;
+                const canSwitch = activeChatType !== 'group' || isAdmin;
+                if (canSwitch && !lockedMode) {
+                    return `📋 当前会话模式: ${currentMode}${lockHint}\n可选: interactive / proactive\n用法: /chatmode <模式>`;
+                }
+                return `📋 当前会话模式: ${currentMode}${lockHint}`;
             }
             if (arg !== 'interactive' && arg !== 'proactive') {
                 return `❌ 无效模式: ${arg}\n可选: interactive / proactive`;
             }
+            if (activeChatType === 'group' && !isAdmin) {
+                return '❌ 无权限：群聊中切换会话模式仅限管理员使用';
+            }
             if (lockedMode) {
                 return `❌ 会话模式由通道配置锁定为 ${lockedMode}，无法切换`;
             }
             if (arg === currentMode) {
                 return `📋 当前会话模式已是 ${arg}`;
             }
+            // 仅在真正需要切换时才要求会话空闲
+            if (threadId) {
+                const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+                if (threadSession) {
+                    const threadAgent = this.getAgent(threadSession.agentId);
+                    if (threadAgent.hasActiveStream(threadSession.id)) {
+                        return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+                    }
+                }
+            }
+            else if (agent.hasActiveStream(activeSession.id)) {
+                return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+            }
             await this.sessionManager.updateSession(activeSession.id, { sessionMode: arg });
             return `✅ 会话模式已切换: ${arg}`;
         }
@@ -1551,15 +1636,18 @@ export class CommandHandler {
                 }
             }
             const lines = [];
+            const sessionMode = session.sessionMode || 'interactive';
+            const lockedMode = getChannelSessionMode(this.config, channel);
+            const chatModeLine = `会话模式: ${sessionMode}${lockedMode ? '（通道锁定）' : ''}`;
             if (isAdmin) {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${this.resolveChannelType(channel)} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${this.resolveChannelType(channel)} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, chatModeLine, `会话轮数: ${sessionTurns}`);
                 if (health.consecutiveErrors > 0) {
                     lines.push(`异常计数: ${health.consecutiveErrors}`);
                 }
                 lines.push(`最后成功: ${timeStr}`, `${session.agentId}会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
             }
             else {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / ${session.agentId}会话`, `状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / ${session.agentId}会话`, `状态: ${sessionStatus}`, chatModeLine, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
             }
             if (health.lastError) {
                 lines.push('');
@@ -1952,6 +2040,7 @@ export class CommandHandler {
                 const replyCtx = activeSession ? this.getReplyContext(activeSession) : undefined;
                 const cardSent = await this.sendInteractionCard({
                     channel, channelId, sessionId: activeSession?.id || requestId, requestId, interaction, replyCtx,
+                    canWrite: isAdmin,
                     callback: async (action, _values, operatorId) => {
                         if (userId && operatorId && operatorId !== userId)
                             return;
@@ -2520,6 +2609,9 @@ export class CommandHandler {
             if (!args) {
                 return await this.handleRewindList(session, rewindAgent);
             }
+            // 带参（执行回退，会删除文件/改对话）需 admin+
+            if (!isAdmin)
+                return '❌ 无权限：回退操作仅限管理员使用';
             const parts = args.split(/\s+/);
             const turnNum = parseInt(parts[0], 10);
             if (isNaN(turnNum) || turnNum < 1) {
@@ -2696,10 +2788,13 @@ export class CommandHandler {
     }
     // ── Agent Ctl ──
     static CTL_COMMANDS = [
-        '/help', '/status', '/check',
-        '/model', '/effort', '/perm',
+        '/help', '/status', '/check', '/pwd',
+        '/model', '/effort', '/perm', '/agent',
         '/compact', '/activity', '/file', '/send', '/chatmode', '/restart', '/agentmd', '/bind', '/aid',
+        '/rename', '/name',
     ];
+    /** ctl 中仅允许查询形态的指令；写形态（带参）一律拒绝 */
+    static CTL_READONLY = new Set(['/agent']);
     /**
      * 从 session 恢复 ReplyContext，用于 ctl send 主动发送文本时的路由
      * - 群聊话题：metadata.replyContext.{threadId,peerId}
@@ -2726,6 +2821,10 @@ export class CommandHandler {
         if (!CommandHandler.CTL_COMMANDS.includes(inputCmd)) {
             return { ok: false, error: `不允许的指令: ${inputCmd}` };
         }
+        // 1.1 只读守卫：带参形态（写操作）在 ctl 中禁止
+        if (CommandHandler.CTL_READONLY.has(inputCmd) && cmd.trimEnd().length > inputCmd.length) {
+            return { ok: false, error: `${inputCmd} 在 ctl 中仅支持查询形态，不支持带参切换` };
+        }
         // 2. 通过 sessionId 查 session
         const session = await this.sessionManager.getSessionById(sessionId);
         if (!session) {

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

@@ -282,6 +282,17 @@ export class MessageProcessor {
         const streamKey = session.id;
         // 为本次任务处理生成唯一 task_id（客户端生成，格式 task-{10hex}）
         const taskId = `task-${crypto.randomUUID().replace(/-/g, '').slice(0, 10)}`;
+        const chatmode = session.sessionMode ?? 'interactive';
+        // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
+        const taskReplyContext = () => {
+            const base = this.getReplyContext(message);
+            return {
+                ...(base ?? {}),
+                metadata: { ...(base?.metadata ?? {}), taskId, chatmode },
+            };
+        };
+        // Proactive 模式可观测：ThoughtEmitter 声明在 try 外，catch 块也能透传错误为 thought
+        let thoughtEmitter = null;
         try {
             const isBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             // 记录收到消息
@@ -335,7 +346,8 @@ export class MessageProcessor {
                             firstReply = false;
                         }
                     }
-                    await adapter.sendText(message.channelId, text, Object.keys(opts).length ? opts : undefined);
+                    opts.metadata = { ...(opts.metadata ?? {}), taskId, chatmode };
+                    await adapter.sendText(message.channelId, text, opts);
                 }
                 // 后台任务：静默，不发送输出
             }, (options?.flushDelay ?? this.config.flushDelay ?? 3) * 1000, options?.fileMarkerPattern, this.config.debug?.flusherDiag, isProactive);
@@ -343,14 +355,13 @@ export class MessageProcessor {
             this.currentFlusher = flusher;
             // Proactive 模式可观测：创建 ThoughtEmitter，将静默的流式事件转发为 thought
             // selector: context = { type: 'task', id: taskId }
-            let thoughtEmitter = null;
             if (isProactive && adapter.putThought) {
-                thoughtEmitter = new ThoughtEmitter(adapter, message.channelId, taskId);
+                thoughtEmitter = new ThoughtEmitter(adapter, message.channelId, taskId, chatmode);
             }
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
             // 捕获当前消息的上下文（闭包），避免后续消息处理时串台
             const capturedChannelId = message.channelId;
-            const capturedReplyContext = this.getReplyContext(message);
+            const capturedReplyContext = taskReplyContext();
             // 设置权限审批的消息发送回调（指向当前渠道）
             agent.setSendPrompt(async (text) => {
                 await adapter.sendText(capturedChannelId, text, capturedReplyContext);
@@ -389,15 +400,28 @@ export class MessageProcessor {
                 const peerLabel = session.identity?.role || 'unknown';
                 const peerName = message.peerName || session.metadata?.peerName;
                 const peerType = message.peerType;
+                const peerId = message.peerId;
+                const adapterAny = channelInfo.adapter;
+                const selfAid = typeof adapterAny._selfAid === 'function' ? adapterAny._selfAid() : undefined;
+                const selfName = typeof adapterAny._selfName === 'function' ? adapterAny._selfName() : undefined;
+                const formatIdentity = (name, id) => {
+                    if (name && id)
+                        return `${name} (${id})`;
+                    return name || id || undefined;
+                };
+                const selfIdentity = formatIdentity(selfName, selfAid);
+                const peerIdentity = formatIdentity(peerName, peerId);
                 const envParts = [
                     `会话通道: ${currentChannelType}`,
                     `当前项目: ${path.basename(absoluteProjectPath)}`,
                 ];
                 if (session.name)
                     envParts.push(`会话名称: ${session.name}`);
+                if (selfIdentity)
+                    envParts.push(`当前名称: ${selfIdentity}`);
                 envParts.push(`对端身份: ${peerLabel}`);
-                if (peerName)
-                    envParts.push(`对端名称: ${peerName}`);
+                if (peerIdentity)
+                    envParts.push(`对端名称: ${peerIdentity}`);
                 if (peerType && peerType !== 'unknown')
                     envParts.push(`对端类型: ${peerType}`);
                 if (session.chatType)
@@ -547,22 +571,22 @@ export class MessageProcessor {
                         && targetSpec !== currentChannelType;
                     // 跨通道仅限 owner
                     if (isCrossChannel && session.identity?.role !== 'owner') {
-                        await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, this.getReplyContext(message));
+                        await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, taskReplyContext());
                         continue;
                     }
                     const resolvedPath = this.resolveFilePath(filePath, absoluteProjectPath);
                     if (!fs.existsSync(resolvedPath)) {
                         logger.warn(`[${adapter.channelName}] File not found: ${resolvedPath}`);
-                        await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, this.getReplyContext(message));
+                        await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, taskReplyContext());
                         continue;
                     }
                     // 找目标 adapter
                     if (!targetInfo) {
-                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, this.getReplyContext(message));
+                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, taskReplyContext());
                         continue;
                     }
                     if (!targetInfo.adapter.sendFile) {
-                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, this.getReplyContext(message));
+                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, taskReplyContext());
                         continue;
                     }
                     // 找目标 channelId
@@ -573,21 +597,21 @@ export class MessageProcessor {
                         const ownerPeerId = getOwner(this.config, targetAdapterName);
                         targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelType, ownerPeerId) ?? '') : '';
                         if (!targetChannelId) {
-                            await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, this.getReplyContext(message));
+                            await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, taskReplyContext());
                             continue;
                         }
                     }
                     logger.info(`[${adapter.channelName}] Sending file via ${targetInfo.adapter.channelName}: ${resolvedPath}`);
                     try {
-                        await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, this.getReplyContext(message));
+                        await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, taskReplyContext());
                         this.eventBus.publish({ type: 'agent:file-sent', sessionId: session.id, filePath: resolvedPath, channel: targetInfo.adapter.channelName });
                         if (isCrossChannel) {
-                            await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, this.getReplyContext(message));
+                            await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, taskReplyContext());
                         }
                     }
                     catch (error) {
                         logger.error(`[${adapter.channelName}] Failed to send file: ${resolvedPath}`, error);
-                        await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, this.getReplyContext(message));
+                        await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, taskReplyContext());
                     }
                 }
             } // end of !isProactive
@@ -671,7 +695,7 @@ export class MessageProcessor {
             if (isFinallyBackground) {
                 const projectName = path.basename(session.projectPath);
                 const count = this.messageCache.getCount(session.id);
-                await adapter.sendText(message.channelId, `[\u540e\u53f0-${projectName}] \u2713 任务完成 (${count}条消息已缓存)`);
+                await adapter.sendText(message.channelId, `[\u540e\u53f0-${projectName}] \u2713 任务完成 (${count}条消息已缓存)`, taskReplyContext());
             }
             // 记录发送响应
             logger.message({
@@ -746,11 +770,24 @@ export class MessageProcessor {
                 // 获取 session 用于话题回复（如果 resolveSession 已执行）
                 let sendOpts;
                 try {
-                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
+                    await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
                     sendOpts = this.getReplyContext(message);
                 }
                 catch { }
+                // 注入 taskId / chatmode（与任务主流程保持一致）
+                sendOpts = {
+                    ...(sendOpts ?? {}),
+                    metadata: { ...(sendOpts?.metadata ?? {}), taskId, chatmode },
+                };
                 await adapter.sendText(message.channelId, userMessage, sendOpts);
+                // Proactive 可观测：catch 块的基础设施错误也透传为 thought，保证按 task_id 聚合完整
+                if (thoughtEmitter) {
+                    const thoughtErrorType = errType === ErrorType.CONTEXT_TOO_LONG ? 'context_too_long' :
+                        errType === ErrorType.AUTH_ERROR ? 'auth' :
+                            (errType === ErrorType.SDK_TIMEOUT || errType === ErrorType.STREAM_ERROR) ? 'network' :
+                                'unknown';
+                    thoughtEmitter.emit({ type: 'error', error: userMessage, errorType: thoughtErrorType }).catch(() => { });
+                }
             }
         }
     }

package/dist/core/message/thought-emitter.js

@@ -6,20 +6,23 @@ import { logger } from '../../utils/logger.js';
  * - 不做聚合/batching，逐事件调用 adapter.putThought()
  * - 不感知 group vs P2P，通道差异由 adapter 内部处理
  * - taskId 映射为 context: { type: 'task', id: taskId }（协议 selector）
+ *   同时写入 payload.task_id / payload.chatmode，与 message.send/group.send 保持一致
  * - fire-and-forget：调用方不 await emit()，错误被内部捕获
  */
 export class ThoughtEmitter {
     adapter;
     channelId;
     taskId;
+    chatmode;
     hasEmittedText = false;
-    constructor(adapter, channelId, taskId) {
+    constructor(adapter, channelId, taskId, chatmode = 'proactive') {
         if (!taskId) {
             throw new Error('[ThoughtEmitter] taskId is required at construction');
         }
         this.adapter = adapter;
         this.channelId = channelId;
         this.taskId = taskId;
+        this.chatmode = chatmode;
     }
     async emit(event) {
         // 对齐 interactive 的 dedup：流式 text 已推过时，complete.result 不再重复发 summary
@@ -37,6 +40,9 @@ export class ThoughtEmitter {
         if (payload.stage === 'thinking') {
             this.hasEmittedText = true;
         }
+        // payload 也带上 task_id / chatmode（与 message.send/group.send 对齐）
+        payload.task_id = this.taskId;
+        payload.chatmode = this.chatmode;
         try {
             await this.adapter.putThought(this.channelId, this.taskId, payload);
         }
@@ -51,7 +57,7 @@ export class ThoughtEmitter {
                     return null;
                 return { type: 'thought', text: event.text, stage: 'thinking' };
             case 'tool_use': {
-                const desc = this.summarizeInput(event.input);
+                const desc = this.summarizeInput(event.input, event.name);
                 return {
                     type: 'thought',
                     text: desc ? `🔧 ${event.name}: ${desc}` : `🔧 ${event.name}`,
@@ -109,9 +115,16 @@ export class ThoughtEmitter {
                 return null;
         }
     }
-    summarizeInput(input) {
+    summarizeInput(input, toolName) {
         if (!input || typeof input !== 'object')
             return '';
+        // Bash + ctl send/file: 显示完整命令内容（含发送的消息正文）
+        if (toolName === 'Bash' && typeof input.command === 'string') {
+            const cmd = input.command;
+            if (cmd.includes('evolclaw ctl send') || cmd.includes('evolclaw ctl file')) {
+                return cmd;
+            }
+        }
         return (input.description ||
             input.file_path ||
             input.pattern ||

package/dist/utils/init-channel.js

@@ -728,7 +728,7 @@ export async function createAidSilent(opts) {
     if (fs.existsSync(aidDir) && fs.existsSync(path.join(aidDir, 'private'))) {
         return { aid: opts.aid, alreadyExisted: true };
     }
-    const { AUNClient } = await import('@agentunion/fastaun');
+    const { AUNClient, GatewayDiscovery } = await import('@agentunion/fastaun');
     let client = new AUNClient({ aun_path: aunPath });
     const result = await client.auth.createAid({ aid: opts.aid });
     // Download CA root cert (if not already present)
@@ -742,6 +742,18 @@ export async function createAidSilent(opts) {
         catch { /* ignore */ }
         client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath, aid: opts.aid });
     }
+    // Set gateway URL for uploadAgentMd
+    let gatewayUrl = result.gateway || '';
+    if (!gatewayUrl) {
+        try {
+            const discovery = new GatewayDiscovery({});
+            gatewayUrl = await discovery.discover(`https://${opts.aid}/.well-known/aun-gateway`);
+        }
+        catch { /* fall through */ }
+    }
+    if (gatewayUrl) {
+        client._gatewayUrl = gatewayUrl;
+    }
     // Write initial agent.md (initialized: false, name = aid first label)
     const agentName = opts.aid.split('.')[0];
     const agentMdContent = `---\naid: "${opts.aid}"\nname: "${agentName}"\ntype: "ai"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolclaw\ninitialized: false\n---\n`;
@@ -790,7 +802,6 @@ export function appendAunInstance(config, inst) {
 }
 export async function setupAunAid(rl, _config) {
     let aid = '';
-    let gatewayPort; // only used locally for AID creation, not written to config
     // Outer loop: allows retrying with a different AID
     while (true) {
         // Ask AID with format validation
@@ -806,12 +817,6 @@ export async function setupAunAid(rl, _config) {
                 aid = '';
             }
         }
-        const portStr = (await ask(rl, '  Gateway 端口 [留空使用默认 443]: ')).trim();
-        gatewayPort = portStr ? parseInt(portStr, 10) : undefined;
-        if (gatewayPort !== undefined && (isNaN(gatewayPort) || gatewayPort < 1 || gatewayPort > 65535)) {
-            console.log('  ⚠ 端口号无效，使用默认 443');
-            gatewayPort = undefined;
-        }
         // Check if AID exists locally
         const aunPath = path.join(os.homedir(), '.aun');
         const aidDir = path.join(aunPath, 'AIDs', aid);
@@ -828,21 +833,13 @@ export async function setupAunAid(rl, _config) {
         console.log('  正在创建 AID...');
         let failed = false;
         try {
-            const { AUNClient } = await import('@agentunion/fastaun');
+            const { AUNClient, GatewayDiscovery } = await import('@agentunion/fastaun');
             let client = new AUNClient({ aun_path: aunPath });
-            // 如果用户指定了自定义端口，手动设置 gateway URL；否则让 SDK 自动发现
-            if (gatewayPort) {
-                const domain = aid.split('.').slice(1).join('.');
-                client._gatewayUrl = `wss://gateway.${domain}:${gatewayPort}/aun`;
-            }
             const result = await client.auth.createAid({ aid });
             console.log(`  ✓ AID ${result.aid} 创建成功`);
             // 下载 CA 根证书（如果本地不存在），从 SDK 返回的实际网关 URL 派生
             const caDownloaded = await downloadCaRoot(aunPath, result.gateway || '', '  ');
-            // 关键：SDK 默认 rootCaPath=null，只读取包内 bundled certs。
-            // 必须显式传 root_ca_path 指向刚下载的 root.crt，uploadAgentMd 才能验证 server cert。
-            // 同时传 aid，否则新 client 不知道该加载哪个身份，uploadAgentMd 会报
-            // "no local identity found, call auth.createAid() first"。
+            // 重建 client：传 root_ca_path 以验证 server cert，传 aid 以加载身份
             const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
             if (caDownloaded && fs.existsSync(caCertPath)) {
                 try {
@@ -850,10 +847,18 @@ export async function setupAunAid(rl, _config) {
                 }
                 catch { /* ignore */ }
                 client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath, aid });
-                if (gatewayPort) {
-                    const domain = aid.split('.').slice(1).join('.');
-                    client._gatewayUrl = `wss://gateway.${domain}:${gatewayPort}/aun`;
+            }
+            // 设置 gateway URL（从 createAid 返回值或 well-known 自动发现）
+            let gatewayUrl = result.gateway || '';
+            if (!gatewayUrl) {
+                try {
+                    const discovery = new GatewayDiscovery({});
+                    gatewayUrl = await discovery.discover(`https://${aid}/.well-known/aun-gateway`);
                 }
+                catch { /* fall through */ }
+            }
+            if (gatewayUrl) {
+                client._gatewayUrl = gatewayUrl;
             }
             // Collect agent.md info and publish
             const typeInput = (await ask(rl, '  Agent 类型 human/ai [ai]: ')).trim().toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolclaw",
-  "version": "2.6.1",
+  "version": "2.6.3",
   "description": "Lightweight AI Agent gateway connecting Claude Agent SDK to messaging channels (Feishu, ACP) with multi-project session management",
   "type": "module",
   "main": "dist/index.js",