evolclaw 2.6.2 → 2.6.4

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', '/chatmode'];
+            // 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', '/chatmode'];
+                : [
+                    ...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);
@@ -665,7 +701,7 @@ export class CommandHandler {
                 if (!hasPermissionController(permAgent)) {
                     return '❌ 权限控制不可用';
                 }
-                const defaultPermMode = identity.role === 'owner' ? 'bypass' : 'readonly';
+                const defaultPermMode = identity.role === 'owner' ? 'bypass' : identity.role === 'admin' ? 'auto' : 'noask';
                 const currentMode = permSession.metadata?.permissionMode ?? defaultPermMode;
                 const modes = permAgent.listModes();
                 // 尝试发送交互卡片
@@ -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) {
@@ -1396,7 +1461,11 @@ 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`;
@@ -1410,6 +1479,19 @@ export class CommandHandler {
             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}`;
         }
@@ -1958,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;
@@ -2526,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) {
@@ -2702,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}
@@ -2732,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

@@ -10,6 +10,7 @@ import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError,
 import { summarizeToolInput } from '../permission.js';
 import { getOwner } from '../../config.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
+import { renderPromptSection } from '../../prompts/templates.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -282,6 +283,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);
             // 记录收到消息
@@ -302,7 +314,7 @@ export class MessageProcessor {
             const imageInfo = message.images && message.images.length > 0 ? ` [${message.images.length} image(s)]` : '';
             const modeInfo = isBackground ? ' [\u540e\u53f0]' : '';
             logger.info(`[${message.channel}] ${message.channelId}: ${message.content}${imageInfo}${modeInfo}`);
-            logger.info(`[MessageProcessor] session=${session.id} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
+            logger.info(`[MessageProcessor] session=${session.id} task=${taskId} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
             // 记录开始处理
             this.eventBus.publish({ type: 'message:processing', sessionId: session.id });
             adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, taskId, this.getReplyContext(message));
@@ -335,22 +347,25 @@ 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);
             // 保存当前 flusher，用于 compact 事件
             this.currentFlusher = flusher;
+            if (isProactive) {
+                logger.info(`[MessageProcessor] proactive mode: flusher silent, outputs via thought.put task=${taskId}`);
+            }
             // 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);
@@ -368,9 +383,9 @@ export class MessageProcessor {
                     ? (sessionKey) => this.messageQueue.cancelIntercept(sessionKey)
                     : undefined,
             });
-            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → readonly）
+            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → noask）
             const role = session.identity?.role;
-            const defaultPermMode = role === 'owner' ? 'bypass' : role === 'admin' ? 'auto' : 'readonly';
+            const defaultPermMode = role === 'owner' ? 'bypass' : role === 'admin' ? 'auto' : 'noask';
             agent.setMode(session.metadata?.permissionMode ?? defaultPermMode);
             // 标记会话为处理中（实时持久化，重启后可恢复）
             this.sessionManager.markProcessing(session.id);
@@ -385,8 +400,7 @@ export class MessageProcessor {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
                 const currentChannelType = options?.channelType || message.channel;
-                // 1. 当前环境信息
-                const peerLabel = session.identity?.role || 'unknown';
+                // 1. 构建模板变量并渲染 runtime 段
                 const peerName = message.peerName || session.metadata?.peerName;
                 const peerType = message.peerType;
                 const peerId = message.peerId;
@@ -400,52 +414,20 @@ export class MessageProcessor {
                 };
                 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 (peerIdentity)
-                    envParts.push(`对端名称: ${peerIdentity}`);
-                if (peerType && peerType !== 'unknown')
-                    envParts.push(`对端类型: ${peerType}`);
-                if (session.chatType)
-                    envParts.push(`聊天类型: ${session.chatType}`);
-                if (session.agentId && session.agentId !== 'claude')
-                    envParts.push(`当前Agent: ${session.agentId}`);
-                contextParts.push(`[当前环境] ${envParts.join(' | ')}`);
-                // 只读模式提示
-                if (session.metadata?.permissionMode === 'readonly') {
-                    const sendHint = isProactive
-                        ? '使用 evolclaw ctl file 发送'
-                        : '使用 [SEND_FILE:] 发送';
-                    contextParts.push(`[只读模式] 禁止修改项目文件。如需生成文件供用户下载，请写入 .evolclaw/tmp/ 目录后${sendHint}`);
-                }
-                // 2. 文件发送能力（按 channelType 去重，提示词只展示第一级通道名）
-                // proactive 模式：不推送 [SEND_FILE:] 提示，统一通过 evolclaw ctl file 显式发送（与 ctl send 契约一致）
+                // 文件发送能力（按 channelType 去重）
+                let crossChannelTypes = [];
+                let currentCanSend = false;
                 if (!isProactive) {
                     const fileChannelTypes = new Set();
-                    const currentCanSend = !!channelInfo.adapter.sendFile;
+                    currentCanSend = !!channelInfo.adapter.sendFile;
                     for (const [, info] of this.channels) {
                         if (info.adapter.sendFile) {
                             fileChannelTypes.add(info.options?.channelType || info.adapter.channelName);
                         }
                     }
-                    const crossChannelTypes = [...fileChannelTypes].filter(t => t !== currentChannelType);
-                    if (currentCanSend || crossChannelTypes.length > 0) {
-                        const hints = [];
-                        if (currentCanSend)
-                            hints.push(`[SEND_FILE:路径] 发送文件到当前通道`);
-                        if (crossChannelTypes.length > 0)
-                            hints.push(`[SEND_FILE:${crossChannelTypes[0]}:路径] 发送文件到指定通道（可用: ${crossChannelTypes.join('/')}）`);
-                        contextParts.push(hints.join('，'));
-                    }
+                    crossChannelTypes = [...fileChannelTypes].filter(t => t !== currentChannelType);
                 }
-                // 3. 当前通道能力
+                // 通道能力
                 const capParts = [];
                 if (options?.supportsImages)
                     capParts.push('图片输入');
@@ -453,30 +435,32 @@ export class MessageProcessor {
                     capParts.push('图片输出');
                 if (channelInfo.adapter.sendFile)
                     capParts.push('文件发送');
-                if (capParts.length > 0) {
-                    contextParts.push(`[通道能力] ${capParts.join('、')}`);
-                }
-                // 4. 群聊 @ 规则：告知 agent 应该 @ 谁，由 agent 自行在回复中添加
+                contextParts.push(renderPromptSection('runtime', {
+                    channel: currentChannelType,
+                    project: path.basename(absoluteProjectPath),
+                    sessionName: session.name || '',
+                    selfIdentity: selfIdentity || '',
+                    peerRole: session.identity?.role || 'unknown',
+                    peerIdentity: peerIdentity || '',
+                    peerType: peerType && peerType !== 'unknown' ? peerType : '',
+                    chatType: session.chatType || '',
+                    agent: session.agentId && session.agentId !== 'claude' ? session.agentId : '',
+                    readonly: session.metadata?.permissionMode === 'readonly',
+                    readonlySendHint: isProactive ? '使用 evolclaw ctl file 发送' : '使用 [SEND_FILE:] 发送',
+                    fileSendCurrent: !isProactive && currentCanSend,
+                    fileSendCross: !isProactive && crossChannelTypes.length > 0,
+                    crossPrimary: crossChannelTypes[0] || '',
+                    crossTypes: crossChannelTypes.join('/'),
+                    capability: capParts.length > 0,
+                    capabilities: capParts.join('、'),
+                }));
+                // 2. 群聊 @ 规则
                 if (message.chatType === 'group' && message.peerId) {
-                    contextParts.push(`[群聊回复规则] 回复时必须在开头添加 @${message.peerId} 来通知对方`);
+                    contextParts.push(renderPromptSection('group', { peerId: message.peerId }));
                 }
-                // 5. Agent ctl 自管理指令提示 + SKILLS.md 生成
-                // 暂时注释：排查 proactive 模式下 agent 未调用 Bash 工具的问题，
-                // 怀疑此段与 [Proactive 模式] 语义重合稀释了后者的权重
-                // if (!this.skillsEnsured) {
-                //   this.ensureSkillsFile();
-                //   this.skillsEnsured = true;
-                // }
-                // const skillsHint = this.getSkillsHint();
-                // if (skillsHint) {
-                //   contextParts.push(`[EvolClaw 自管理] ${skillsHint}`);
-                // }
-                // 6. Proactive 模式提示词：agent 的输出不会自动发送，必须主动调用 ctl send/file
+                // 3. Proactive 模式提示词
                 if (isProactive) {
-                    contextParts.push('[Proactive 模式] 本次对话中你的流式输出不会自动发送给用户，必须通过以下命令主动发送：\n' +
-                        '- 发送文本：evolclaw ctl send "<消息内容>"\n' +
-                        '- 发送文件：evolclaw ctl file <路径>\n' +
-                        '可多次调用。如不调用，用户将看不到任何回复。');
+                    contextParts.push(renderPromptSection('proactive', {}));
                 }
                 const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
@@ -560,22 +544,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
@@ -586,21 +570,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
@@ -684,7 +668,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({
@@ -759,11 +743,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(() => { });
+                }
             }
         }
     }
@@ -799,8 +796,24 @@ export class MessageProcessor {
                 // 每收到事件重置空闲超时
                 const toolName = event.type === 'tool_use' ? event.name : undefined;
                 resetTimer(event.type, toolName);
-                // 记录所有事件类型
-                logger.info(`[MessageProcessor] Event: type=${event.type}`);
+                // 记录所有事件类型（text / tool_use 附带摘要，便于排查）
+                let eventDetail = '';
+                if (event.type === 'text' && event.text) {
+                    const preview = event.text.replace(/\s+/g, ' ').slice(0, 80);
+                    eventDetail = ` text="${preview}${event.text.length > 80 ? '…' : ''}"`;
+                }
+                else if (event.type === 'tool_use') {
+                    const input = event.input;
+                    const desc = input?.description
+                        || input?.file_path
+                        || input?.pattern
+                        || (typeof input?.command === 'string' ? input.command.slice(0, 80) : '')
+                        || (typeof input?.prompt === 'string' ? input.prompt.slice(0, 80) : '')
+                        || (typeof input?.query === 'string' ? input.query.slice(0, 80) : '')
+                        || '';
+                    eventDetail = ` tool=${event.name}${desc ? ` desc="${desc}"` : ''}`;
+                }
+                logger.info(`[MessageProcessor] Event: type=${event.type}${eventDetail}`);
                 // Proactive 可观测：将事件实时透传为 thought（fire-and-forget）
                 if (thoughtEmitter) {
                     thoughtEmitter.emit(event).catch(() => { });