evolclaw 2.2.0 → 2.4.0

package/dist/core/{message-processor.js → message/message-processor.js}

@@ -1,12 +1,12 @@
 import path from 'path';
 import fs from 'fs';
-import { hasCompact } from '../agents/claude-runner.js';
-import { StreamFlusher } from '../utils/stream-flusher.js';
-import { StreamIdleMonitor } from '../utils/stream-idle-monitor.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage, classifyError, ErrorType } from '../utils/error-utils.js';
-import { summarizeToolInput } from '../utils/permission-utils.js';
-import { getOwner } from '../config.js';
+import { hasCompact } from '../../agents/claude-runner.js';
+import { StreamFlusher } from './stream-flusher.js';
+import { StreamIdleMonitor } from './stream-idle-monitor.js';
+import { logger } from '../../utils/logger.js';
+import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError } from '../../utils/error-utils.js';
+import { summarizeToolInput } from '../permission.js';
+import { getOwner } from '../../config.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -18,11 +18,13 @@ export class MessageProcessor {
     eventBus;
     commandHandler;
     channels = new Map();
+    channelTypeMap = new Map(); // channelType → channelName（首个实例）
     currentFlusher;
     shouldSuppressActivities = false;
     agentMap;
     defaultAgentId;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
+    interactionRouter;
     /** 按 agentId 获取 agent，回退到默认 */
     getAgent(agentId) {
         if (agentId && this.agentMap.has(agentId))
@@ -62,23 +64,31 @@ export class MessageProcessor {
             }
         });
     }
+    setInteractionRouter(router) {
+        this.interactionRouter = router;
+    }
     /**
      * 注册渠道适配器
      */
     registerChannel(adapter, policy, options) {
-        this.channels.set(adapter.name, { adapter, options, policy });
+        this.channels.set(adapter.channelName, { adapter, options, policy });
+        // 维护 channelType → channelName 映射（首个实例优先）
+        const type = options?.channelType || adapter.channelName;
+        if (!this.channelTypeMap.has(type)) {
+            this.channelTypeMap.set(type, adapter.channelName);
+        }
     }
     /**
-     * 获取渠道适配器
+     * 获取渠道适配器（支持实例名和 channelType）
      */
     getAdapter(channelName) {
-        return this.channels.get(channelName)?.adapter;
+        return this.resolveChannelInfo(channelName)?.adapter;
     }
     /**
-     * 获取渠道信息（含 policy）
+     * 获取渠道信息（含 policy，支持实例名和 channelType）
      */
     getChannelInfo(channelName) {
-        return this.channels.get(channelName);
+        return this.resolveChannelInfo(channelName);
     }
     /**
      * 处理 compact 开始事件
@@ -91,19 +101,48 @@ export class MessageProcessor {
             this.currentFlusher.addActivity('\u23f3 会话压缩中...');
         }
     }
+    /**
+     * 根据 channel 标识查找渠道信息
+     * 先按实例名精确匹配，再按 channelType 映射到实例名
+     */
+    resolveChannelInfo(channel) {
+        // 1. 精确匹配实例名
+        let info = this.channels.get(channel);
+        if (info)
+            return info;
+        // 2. 按 channelType 查找（兼容按类型名路由）
+        const instanceName = this.channelTypeMap.get(channel);
+        if (instanceName)
+            info = this.channels.get(instanceName);
+        return info;
+    }
+    // 命令前缀列表（与 CommandHandler.quickCommandPrefixes 保持同步）
+    static COMMAND_PREFIXES = [
+        '/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart',
+        '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
+        '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/send', '/check',
+        '/p ', '/s ', '/name ',
+    ];
+    /** 判断消息内容是否为已知命令 */
+    isKnownCommand(content) {
+        return content === '/p' || content === '/s' ||
+            MessageProcessor.COMMAND_PREFIXES.some(cmd => content.startsWith(cmd));
+    }
     /**
      * 处理消息（主入口）
      */
     async processMessage(message) {
         const idleMs = (this.config.idleMonitor?.timeout ?? 120) * 1000;
-        const channelInfo = this.channels.get(message.channel);
+        // 先解析会话，再优先用 session.metadata.channelName 精确定位实例级 adapter
+        // message.channel 现在存实例名（channelName），可直接用于精确路由
+        const { session, absoluteProjectPath } = await this.resolveSession(message);
+        const channelKey = session.metadata?.channelName || message.channel;
+        const channelInfo = this.resolveChannelInfo(channelKey);
         if (!channelInfo) {
-            logger.error(`[MessageProcessor] Unknown channel: ${message.channel}`);
+            logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
             return;
         }
         const { policy } = channelInfo;
-        // 解析会话（唯一的 getOrCreateSession 调用点）
-        const { session, absoluteProjectPath } = await this.resolveSession(message);
         const streamKey = session.id;
         const chatType = message.chatType || 'private';
         const identityRole = session.identity?.role || 'anonymous';
@@ -142,7 +181,7 @@ export class MessageProcessor {
                             const msg = showIdleMonitor
                                 ? result.message
                                 : `\u26a0\ufe0f 任务超时（${result.idleSec}秒无响应），已自动中断`;
-                            channelInfo.adapter.sendText(message.channelId, msg).catch(e => {
+                            channelInfo.adapter.sendText(message.channelId, msg, this.getReplyContext(message)).catch(e => {
                                 logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
                             });
                         }
@@ -157,7 +196,7 @@ export class MessageProcessor {
                         logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
                         if (channelInfo && showIdleMonitor && !shouldSuppress()) {
                             if (!isBackground) {
-                                channelInfo.adapter.sendText(message.channelId, result.message).catch(e => {
+                                channelInfo.adapter.sendText(message.channelId, result.message, this.getReplyContext(message)).catch(e => {
                                     logger.debug(`[MessageProcessor] Failed to send idle monitor message:`, e);
                                 });
                             }
@@ -183,13 +222,22 @@ export class MessageProcessor {
                     // 上下文过长是可恢复错误，不累计触发安全模式
                     if (errorType === ErrorType.CONTEXT_TOO_LONG) {
                         logger.info(`[MessageProcessor] Context too long error, skipping safe mode accumulation`);
+                        // 认证错误（401 / Invalid API Key）不是会话问题，安全模式无法修复，不累计
+                    }
+                    else if (errorType === ErrorType.AUTH_ERROR) {
+                        logger.info(`[MessageProcessor] Auth error (invalid API key), skipping safe mode accumulation`);
+                        // API 错误（5xx / 算力池切换等）是平台暂时性问题，安全模式无法修复，不累计
+                    }
+                    else if (errorType === ErrorType.API_ERROR) {
+                        logger.info(`[MessageProcessor] API error, skipping safe mode accumulation`);
                     }
                     else if (!policy.accumulateErrors(chatType, identityRole)) {
                         logger.info(`[MessageProcessor] Non-accumulating error (chatType=${chatType}, identity=${identityRole}), skipping safe mode accumulation`);
                     }
                     else {
-                        const newCount = await this.sessionManager.recordError(session.id, errorType, error.message);
-                        await this.checkSafeMode(session, message.channelId, channelInfo.adapter, safeModeThreshold, newCount);
+                        const prefixed = prefixErrorType(ERROR_PREFIX.INFRA, errorType);
+                        const newCount = await this.sessionManager.recordError(session.id, prefixed, error.message);
+                        await this.checkSafeMode(session, message.channelId, channelInfo.adapter, safeModeThreshold, newCount, message);
                     }
                 }
                 catch (statusError) {
@@ -203,18 +251,18 @@ export class MessageProcessor {
                 clearInterval(monitorInterval);
         }
     }
-    /** 从 session 提取渠道预构建的回复上下文 */
-    getReplyContext(session) {
-        return session.metadata?.replyContext;
+    /** 获取回复上下文（跟着任务走） */
+    getReplyContext(message) {
+        return message.replyContext;
     }
     /**
      * 检查是否需要进入安全模式（safeModeThreshold 为 0 时跳过）
      */
-    async checkSafeMode(session, channelId, adapter, safeModeThreshold, consecutiveErrors) {
+    async checkSafeMode(session, channelId, adapter, safeModeThreshold, consecutiveErrors, message) {
         if (safeModeThreshold <= 0)
             return;
         const health = await this.sessionManager.getHealthStatus(session.id);
-        const sendOpts = this.getReplyContext(session);
+        const sendOpts = this.getReplyContext(message);
         const isThread = !!session.threadId;
         if (consecutiveErrors >= safeModeThreshold && !health.safeMode) {
             await this.sessionManager.setSafeMode(session.id, true);
@@ -238,9 +286,17 @@ ${suggestions}`, sendOpts);
     }
     async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
-        const channelInfo = this.channels.get(message.channel);
+        const channelKey = session.metadata?.channelName || message.channel;
+        const channelInfo = this.resolveChannelInfo(channelKey);
         if (!channelInfo) {
-            logger.error(`[MessageProcessor] Unknown channel: ${message.channel}`);
+            logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
+            return;
+        }
+        // 二次拦截：如果命令消息绕过 MessageBridge 的 handleCommand 泄漏到这里，
+        // 静默丢弃而不是发送给 Agent（命令已在 MessageBridge 层处理过）
+        const rawContent = message.content.replace(/^(>[^\n]*\n)+\n?/, '').trim();
+        if (rawContent.startsWith('/') && this.isKnownCommand(rawContent)) {
+            logger.warn(`[MessageProcessor] Command leaked past MessageBridge, dropped: "${rawContent.substring(0, 40)}"`);
             return;
         }
         const { adapter, options } = channelInfo;
@@ -268,7 +324,7 @@ ${suggestions}`, sendOpts);
             logger.info(`[${message.channel}] ${message.channelId}: ${message.content}${imageInfo}${modeInfo}`);
             // 记录开始处理
             this.eventBus.publish({ type: 'message:processing', sessionId: session.id });
-            adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, this.getReplyContext(session));
+            adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, this.getReplyContext(message));
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
@@ -279,21 +335,23 @@ ${suggestions}`, sendOpts);
             // 创建 StreamFlusher，传入文件标记模式用于自动过滤
             // 使用动态判断，确保切换项目后不会继续输出
             let firstReply = true;
-            const flusher = new StreamFlusher(async (text, isFinal) => {
+            const flusher = new StreamFlusher(async (text, isFinal, hasText) => {
                 const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
                 if (!isCurrentlyBackground) {
                     const opts = {};
                     if (isFinal)
-                        opts.title = '\u6700\u7ec8\u56de\u590d:';
-                    // 话题会话：使用 Channel 预构建的 replyContext（确保消息进入话题）
-                    const replyCtx = session.metadata?.replyContext;
+                        opts.title = '\u2713 \u6700\u7ec8\u56de\u590d:';
+                    // replyContext 跟着任务走：优先用当前 message 的，兜底用 session 的（话题会话创建时写入）
+                    const replyCtx = this.getReplyContext(message);
                     if (replyCtx) {
                         Object.assign(opts, replyCtx);
                     }
                     else if (firstReply && message.messageId) {
-                        // 主会话：首条消息引用回复用户原消息
-                        opts.replyToMessageId = message.messageId;
-                        firstReply = false;
+                        // 主会话：首条消息引用回复用户原消息（只在含真实文字时消费）
+                        if (hasText) {
+                            opts.replyToMessageId = message.messageId;
+                            firstReply = false;
+                        }
                     }
                     await adapter.sendText(message.channelId, text, Object.keys(opts).length ? opts : undefined);
                 }
@@ -304,11 +362,18 @@ ${suggestions}`, sendOpts);
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
             // 设置权限审批的消息发送回调（指向当前渠道）
             agent.setSendPrompt(async (text) => {
-                await adapter.sendText(message.channelId, text, this.getReplyContext(session));
+                await adapter.sendText(message.channelId, text, this.getReplyContext(message));
+            });
+            // 设置权限审批的交互上下文（支持交互卡片）
+            agent.setPermissionContext?.({
+                adapter,
+                channelId: message.channelId,
+                replyContext: this.getReplyContext(message),
+                interactionRouter: this.interactionRouter,
             });
-            // 设置 per-session 权限模式
-            const permissionMode = session.metadata?.permissionMode || 'default';
-            agent.setMode(permissionMode);
+            // 设置 per-session 权限模式（动态默认值：owner → bypass，guest → readonly）
+            const defaultPermMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+            agent.setMode(session.metadata?.permissionMode ?? defaultPermMode);
             // 标记会话为处理中（实时持久化，重启后可恢复）
             this.sessionManager.markProcessing(session.id);
             // 检查是否因新消息自动中断 — 包装 prompt 让 Agent 知道上下文
@@ -317,15 +382,16 @@ ${suggestions}`, sendOpts);
             const effectivePrompt = prevInterruptReason === 'new_message' && session.agentSessionId
                 ? `【新消息插入】\n\n${message.content}\n\n【请无视之前中断继续处理】`
                 : message.content;
+            let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
+                const currentChannelType = options?.channelType || message.channel;
                 // 1. 当前环境信息
                 const peerLabel = session.identity?.role || 'unknown';
-                const sessionName = session.name || '默认会话';
                 const peerName = message.peerName || session.metadata?.peerName;
                 const envParts = [
-                    `会话通道: ${message.channel}`,
+                    `会话通道: ${currentChannelType}`,
                     `当前项目: ${path.basename(absoluteProjectPath)}`,
                 ];
                 if (session.name)
@@ -333,25 +399,74 @@ ${suggestions}`, sendOpts);
                 envParts.push(`对端身份: ${peerLabel}`);
                 if (peerName)
                     envParts.push(`对端名称: ${peerName}`);
+                if (session.chatType)
+                    envParts.push(`聊天类型: ${session.chatType}`);
+                if (session.agentId && session.agentId !== 'claude')
+                    envParts.push(`当前Agent: ${session.agentId}`);
                 contextParts.push(`[当前环境] ${envParts.join(' | ')}`);
-                // 2. 文件发送能力
-                const fileChannels = [...this.channels.entries()]
-                    .filter(([, info]) => info.adapter.sendFile)
-                    .map(([name]) => name);
-                const currentCanSend = fileChannels.includes(message.channel);
-                const crossChannels = fileChannels.filter(n => n !== message.channel);
-                if (currentCanSend || crossChannels.length > 0) {
+                // 只读模式提示
+                if (session.metadata?.permissionMode === 'readonly') {
+                    contextParts.push('[只读模式] 禁止修改项目文件。如需生成文件供用户下载，请写入 .evolclaw/tmp/ 目录后使用 [SEND_FILE:] 发送');
+                }
+                // 2. 文件发送能力（按 channelType 去重，提示词只展示第一级通道名）
+                const fileChannelTypes = new Set();
+                const 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 (crossChannels.length > 0)
-                        hints.push(`[SEND_FILE:${crossChannels[0]}:路径] 发送文件到指定通道（可用: ${crossChannels.join('/')}）`);
+                    if (crossChannelTypes.length > 0)
+                        hints.push(`[SEND_FILE:${crossChannelTypes[0]}:路径] 发送文件到指定通道（可用: ${crossChannelTypes.join('/')}）`);
                     contextParts.push(hints.join('，'));
                 }
+                // 3. 当前通道能力
+                const capParts = [];
+                if (options?.supportsImages)
+                    capParts.push('图片输入');
+                if (channelInfo.adapter.sendImage)
+                    capParts.push('图片输出');
+                if (channelInfo.adapter.sendFile)
+                    capParts.push('文件发送');
+                if (capParts.length > 0) {
+                    contextParts.push(`[通道能力] ${capParts.join('、')}`);
+                }
+                // 4. 群聊 @ 规则：告知 agent 应该 @ 谁，由 agent 自行在回复中添加
+                if (message.chatType === 'group' && message.peerId) {
+                    contextParts.push(`[群聊回复规则] 回复时必须在开头添加 @${message.peerId} 来通知对方`);
+                }
                 const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
-                const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager);
-                agent.registerStream(streamKey, stream);
-                await this.processEventStream(stream, session, flusher, resetTimer, shouldSuppress);
+                // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
+                const MAX_RETRIES = 3;
+                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                    let streamRegistered = false;
+                    try {
+                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager);
+                        agent.registerStream(streamKey, stream);
+                        streamRegistered = true;
+                        streamResult = await this.processEventStream(stream, session, flusher, resetTimer, shouldSuppress);
+                        break; // 成功，跳出重试循环
+                    }
+                    catch (retryError) {
+                        if (streamRegistered) {
+                            agent.cleanupStream(streamKey);
+                        }
+                        if (attempt < MAX_RETRIES && isRetryableError(retryError)) {
+                            const delay = Math.pow(2, attempt) * 1000; // 2s, 4s
+                            logger.warn(`[MessageProcessor] Retryable error (attempt ${attempt}/${MAX_RETRIES}), retrying in ${delay}ms:`, retryError);
+                            flusher.addActivity(`⚠️ API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`);
+                            await flusher.flush();
+                            await new Promise(resolve => setTimeout(resolve, delay));
+                            continue;
+                        }
+                        throw retryError; // 不可重试或已耗尽重试次数
+                    }
+                }
             }
             catch (error) {
                 if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId && hasCompact(agent)) {
@@ -364,7 +479,7 @@ ${suggestions}`, sendOpts);
                         flusher.addActivity('\u2705 压缩完成，正在重试...');
                         const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, options?.systemPromptAppend, this.sessionManager);
                         agent.registerStream(streamKey, retryStream);
-                        await this.processEventStream(retryStream, session, flusher, resetTimer, shouldSuppress);
+                        streamResult = await this.processEventStream(retryStream, session, flusher, resetTimer, shouldSuppress);
                     }
                     else {
                         throw new Error('CONTEXT_COMPACT_FAILED');
@@ -375,61 +490,91 @@ ${suggestions}`, sendOpts);
                 }
             }
             // 处理文件标记 - 支持 [SEND_FILE:path] 和 [SEND_FILE:channel:path]
+            // 注意：始终扫描全部文本（含中间轮），因为文件标记可能出现在任意轮次
+            // suppressed 模式下 flusher 只有最后一轮文本，需要用 streamResult.fullText（SDK 全文）兜底
             const FILE_MARKER_RE = /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g;
             const markerPattern = options?.fileMarkerPattern ?? FILE_MARKER_RE;
-            const fullText = flusher.getFinalText();
+            const flusherText = flusher.getFinalText();
+            const fullText = flusherText.length >= (streamResult.fullText?.length || 0) ? flusherText : streamResult.fullText;
             const fileMatches = [...fullText.matchAll(markerPattern)];
             for (const match of fileMatches) {
                 // 兼容旧格式 (1组) 和新格式 (2组)
                 const hasChannelGroup = match.length >= 3;
-                const targetChannelName = hasChannelGroup ? (match[1] ?? message.channel) : message.channel;
+                const targetSpec = hasChannelGroup ? (match[1] ?? undefined) : undefined;
                 const filePath = (hasChannelGroup ? match[2] : match[1]).trim();
                 if (this.isPlaceholderPath(filePath)) {
-                    logger.info(`[${adapter.name}] Skipped placeholder file marker: [SEND_FILE:${filePath}]`);
+                    logger.info(`[${adapter.channelName}] Skipped placeholder file marker: [SEND_FILE:${filePath}]`);
                     continue;
                 }
+                // 解析目标：按实例名匹配，再按 channelType 映射
+                let targetInfo = targetSpec ? this.channels.get(targetSpec) : channelInfo;
+                let targetLabel = targetSpec || message.channel;
+                if (targetSpec && !targetInfo) {
+                    // 按 channelType 查找首个匹配的实例
+                    const instanceName = this.channelTypeMap.get(targetSpec);
+                    if (instanceName)
+                        targetInfo = this.channels.get(instanceName);
+                }
+                const currentChannelType = channelInfo.options?.channelType || adapter.channelName;
+                const isCrossChannel = targetSpec && targetSpec !== message.channel
+                    && targetSpec !== currentChannelType;
                 // 跨通道仅限 owner
-                if (targetChannelName !== message.channel && session.identity?.role !== 'owner') {
-                    await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, this.getReplyContext(session));
+                if (isCrossChannel && session.identity?.role !== 'owner') {
+                    await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, this.getReplyContext(message));
                     continue;
                 }
                 const resolvedPath = this.resolveFilePath(filePath, absoluteProjectPath);
                 if (!fs.existsSync(resolvedPath)) {
-                    logger.warn(`[${adapter.name}] File not found: ${resolvedPath}`);
-                    await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, this.getReplyContext(session));
+                    logger.warn(`[${adapter.channelName}] File not found: ${resolvedPath}`);
+                    await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, this.getReplyContext(message));
                     continue;
                 }
                 // 找目标 adapter
-                const targetInfo = this.channels.get(targetChannelName);
                 if (!targetInfo) {
-                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetChannelName} 未启用或不存在`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, this.getReplyContext(message));
                     continue;
                 }
                 if (!targetInfo.adapter.sendFile) {
-                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetChannelName} 不支持文件发送`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, this.getReplyContext(message));
                     continue;
                 }
                 // 找目标 channelId
                 let targetChannelId = message.channelId;
-                if (targetChannelName !== message.channel) {
-                    const ownerPeerId = getOwner(this.config, targetChannelName);
-                    targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelName, ownerPeerId) ?? '') : '';
+                if (isCrossChannel) {
+                    const targetAdapterName = targetInfo.adapter.channelName;
+                    const targetChannelType = targetInfo.options?.channelType || targetAdapterName;
+                    const ownerPeerId = getOwner(this.config, targetAdapterName);
+                    targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelType, ownerPeerId) ?? '') : '';
                     if (!targetChannelId) {
-                        await adapter.sendText(message.channelId, `\u274c 未找到 ${targetChannelName} 的私聊会话，请先在该通道发送一条消息`, this.getReplyContext(session));
+                        await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, this.getReplyContext(message));
                         continue;
                     }
                 }
-                logger.info(`[${adapter.name}] Sending file via ${targetChannelName}: ${resolvedPath}`);
+                logger.info(`[${adapter.channelName}] Sending file via ${targetInfo.adapter.channelName}: ${resolvedPath}`);
                 try {
-                    await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, this.getReplyContext(session));
-                    this.eventBus.publish({ type: 'agent:file-sent', sessionId: session.id, filePath: resolvedPath, channel: targetChannelName });
-                    if (targetChannelName !== message.channel) {
-                        await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetChannelName} 发送`, this.getReplyContext(session));
+                    await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, this.getReplyContext(message));
+                    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));
                     }
                 }
                 catch (error) {
-                    logger.error(`[${adapter.name}] Failed to send file: ${resolvedPath}`, error);
-                    await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, this.getReplyContext(session));
+                    logger.error(`[${adapter.channelName}] Failed to send file: ${resolvedPath}`, error);
+                    await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, this.getReplyContext(message));
+                }
+            }
+            // 最终回复文本添加到 flusher（统一在流结束后处理，避免多 complete 事件重复发送）
+            // suppressed 模式：中间流式文本未推送，使用最后一轮回复（回退到全文）
+            // 非 suppressed 且无流式文本：同上
+            // 非 suppressed 且有流式文本：已经逐步推送过了，不重复添加
+            //   但如果 flusher 既未发送过内容也没有 pending 内容（如 text 事件全为空），仍需兜底
+            const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
+            if (finalReplyText) {
+                if (shouldSuppress()) {
+                    flusher.addText(finalReplyText);
+                }
+                else if (!streamResult.hasReceivedText || (!flusher.hasSentContent() && !flusher.hasContent())) {
+                    flusher.addText(finalReplyText);
                 }
             }
             // Flush 剩余内容（文件标记已在 flush 时自动移除）
@@ -440,39 +585,76 @@ ${suggestions}`, sendOpts);
                 const hint = session.threadId
                     ? '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /clear 清空会话'
                     : '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话';
-                await adapter.sendText(message.channelId, hint, this.getReplyContext(session));
+                await adapter.sendText(message.channelId, hint, this.getReplyContext(message));
             }
             // 清理 activeStreams（正常完成）
             agent.cleanupStream(streamKey);
-            // 清除处理中状态 + 记录成功响应
+            // 清除处理中状态
             this.sessionManager.clearProcessing(session.id);
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
             const interruptReason = this.interruptedSessions.get(session.id);
-            adapter.sendProcessingStatus?.(message.channelId, interruptReason ? 'interrupted' : 'done', session.id, this.getReplyContext(session));
-            await this.sessionManager.recordSuccess(session.id);
-            this.eventBus.publish({
-                type: 'message:completed',
-                sessionId: session.id,
-                channel: message.channel,
-                channelId: message.channelId,
-                durationMs: Date.now() - startTime,
-                timestamp: Date.now()
-            });
+            if (streamResult.isError) {
+                // Agent 流正常结束但任务结果失败（权限被拒、max turns、工具链失败等）
+                const errorSummary = streamResult.errors?.join('; ') || '任务执行失败';
+                const rawSubtype = streamResult.subtype || 'agent_error';
+                const errorType = prefixErrorType(ERROR_PREFIX.AGENT, rawSubtype);
+                adapter.sendProcessingStatus?.(message.channelId, 'error', session.id, this.getReplyContext(message));
+                this.eventBus.publish({
+                    type: 'message:error',
+                    sessionId: session.id,
+                    error: errorSummary,
+                    errorType,
+                    terminalReason: streamResult.terminalReason
+                });
+                // 仅系统级 subtype 累计安全模式（权限拒绝、max turns 等用户操作不累计）
+                if (isInfraError(rawSubtype, streamResult.terminalReason)) {
+                    const chatType = message.chatType || 'private';
+                    const identityRole = session.identity?.role || 'anonymous';
+                    const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
+                    const { policy } = channelInfo;
+                    if (policy.accumulateErrors(chatType, identityRole)) {
+                        const newCount = await this.sessionManager.recordError(session.id, errorType, errorSummary);
+                        await this.checkSafeMode(session, message.channelId, adapter, safeModeThreshold, newCount, message);
+                    }
+                }
+                logger.message({
+                    msgId: messageId,
+                    sessionId: session.id,
+                    dir: 'inbound',
+                    status: 'failed',
+                    error: errorSummary,
+                    terminalReason: streamResult.terminalReason
+                });
+            }
+            else {
+                // 真正的成功
+                adapter.sendProcessingStatus?.(message.channelId, interruptReason ? 'interrupted' : 'done', session.id, this.getReplyContext(message));
+                await this.sessionManager.recordSuccess(session.id);
+                this.eventBus.publish({
+                    type: 'message:completed',
+                    sessionId: session.id,
+                    channel: message.channel,
+                    channelId: message.channelId,
+                    terminalReason: streamResult.terminalReason,
+                    finalText: streamResult.lastReplyText || undefined,
+                    durationMs: Date.now() - startTime,
+                    timestamp: Date.now()
+                });
+                // 记录处理完成
+                logger.message({
+                    msgId: messageId,
+                    sessionId: session.id,
+                    dir: 'inbound',
+                    status: 'completed',
+                    duration: Date.now() - startTime
+                });
+            }
             const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             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}条消息已缓存)`);
             }
-            const duration = Date.now() - startTime;
-            // 记录处理完成
-            logger.message({
-                msgId: messageId,
-                sessionId: session.id,
-                dir: 'inbound',
-                status: 'completed',
-                duration
-            });
             // 记录发送响应
             logger.message({
                 msgId: `${messageId}_reply`,
@@ -491,44 +673,63 @@ ${suggestions}`, sendOpts);
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
             // 区分超时 / 中断 / 错误
             const errType = classifyError(error);
+            const interruptReason = this.interruptedSessions.get(session.id);
+            const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop';
             const procStatus = errType === ErrorType.SDK_TIMEOUT ? 'timeout'
                 : errType === ErrorType.STREAM_ERROR ? 'interrupted'
                     : 'error';
-            try {
-                adapter.sendProcessingStatus?.(message.channelId, procStatus, session.id, this.getReplyContext(session));
+            // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送中断/错误提示
+            if (!isUserInterrupt) {
+                try {
+                    adapter.sendProcessingStatus?.(message.channelId, procStatus, session.id, this.getReplyContext(message));
+                }
+                catch { }
+            }
+            // 用户主动中断时降级日志；其余仍按 error 记录
+            if (isUserInterrupt) {
+                logger.info(`[${message.channel}] Interrupted by user (${interruptReason})`);
+            }
+            else {
+                logger.error(`[${message.channel}] Error:`, error);
             }
-            catch { }
-            logger.error(`[${message.channel}] Error:`, error);
             const errorMsg = error instanceof Error ? error.message : String(error);
-            const errorType = errType;
+            const errorType = prefixErrorType(ERROR_PREFIX.INFRA, errType);
             this.eventBus.publish({
                 type: 'message:error',
-                sessionId: message.channelId,
+                sessionId: session.id,
                 error: errorMsg,
-                errorType: String(errorType)
+                errorType
             });
             // 记录处理失败
             logger.message({
                 msgId: messageId,
-                sessionId: message.channelId,
+                sessionId: session.id,
                 dir: 'inbound',
                 status: 'failed',
                 error: error instanceof Error ? error.message : String(error)
             });
-            if (error instanceof Error) {
+            if (error instanceof Error && !isUserInterrupt) {
                 logger.error(`[${message.channel}] Error stack:`, error.stack);
             }
             // 发送用户友好的错误消息（SDK_TIMEOUT 已在 kill 级别发过提示，跳过）
+            // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送错误提示
+            // processEventStream 已通过 flusher 发过错误时也跳过
             if (error instanceof Error && error.message === 'SDK_TIMEOUT') {
                 logger.info(`[MessageProcessor] SDK_TIMEOUT error, skip sending duplicate message`);
             }
+            else if (isUserInterrupt) {
+                logger.info(`[MessageProcessor] User interrupt by new_message, skip sending error message`);
+            }
+            else if (error?._errorAlreadySent) {
+                logger.info(`[MessageProcessor] Error already sent via flusher, skip sending duplicate message`);
+            }
             else {
-                const userMessage = getErrorMessage(error);
+                const userMessage = getErrorMessage(error, undefined);
                 // 获取 session 用于话题回复（如果 resolveSession 已执行）
                 let sendOpts;
                 try {
                     const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
-                    sendOpts = this.getReplyContext(session);
+                    sendOpts = this.getReplyContext(message);
                 }
                 catch { }
                 await adapter.sendText(message.channelId, userMessage, sendOpts);
@@ -539,11 +740,12 @@ ${suggestions}`, sendOpts);
      * 解析会话和项目路径
      */
     async resolveSession(message) {
-        // 话题会话：使用 Channel 预构建的 replyContext
-        const metadata = message.replyContext
+        // 话题会话创建时写入 replyContext（threadId 路由）；主会话不写（避免群聊覆盖）
+        const metadata = (message.threadId && message.replyContext)
             ? { replyContext: message.replyContext }
             : undefined;
         const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId, metadata, undefined, message.peerId);
+        // replyContext 不再写入 session.metadata（跟着 message 走，避免群聊多人覆盖）
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
             : path.resolve(process.cwd(), session.projectPath);
@@ -558,6 +760,9 @@ ${suggestions}`, sendOpts);
     async processEventStream(stream, session, flusher, resetTimer, shouldSuppress) {
         let hasReceivedText = false;
         let hasErrorResult = false; // 是否已有 tool_result/error 事件输出过错误
+        let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
+        // 追踪最后一轮 assistant 回复文本（tool_use 之后的纯文本）
+        let lastReplyText = '';
         try {
             for await (const event of stream) {
                 // 每收到事件重置空闲超时
@@ -570,12 +775,31 @@ ${suggestions}`, sendOpts);
                     logger.info(`[MessageProcessor] Session ID updated: ${event.sessionId} for session: ${session.id}`);
                     continue;
                 }
+                // session 状态变更（idle/running/requires_action）
+                if (event.type === 'state_changed') {
+                    logger.info(`[MessageProcessor] Session state: ${event.state} for session: ${session.id}`);
+                    this.eventBus.publish({ type: 'agent:state-changed', sessionId: session.id, state: event.state });
+                    continue;
+                }
+                // agent 状态通知（仅事件，不直出给用户）
+                if (event.type === 'status') {
+                    logger.info(`[MessageProcessor] Agent status: ${event.subtype}: ${event.message}`);
+                    this.eventBus.publish({
+                        type: 'agent:status',
+                        sessionId: session.id,
+                        subtype: event.subtype,
+                        message: event.message,
+                        timestamp: Date.now()
+                    });
+                    continue;
+                }
                 const isCurrentlyBackground = await this.isBackgroundSession(session, session.channel, session.channelId);
                 // === 前台任务：正常处理所有事件 ===
                 if (!isCurrentlyBackground) {
                     // 流式文本
                     if (event.type === 'text') {
                         hasReceivedText = true;
+                        lastReplyText += event.text;
                         this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: event.text, isFinal: false });
                         if (!shouldSuppress()) {
                             flusher.addText(event.text);
@@ -602,6 +826,8 @@ ${suggestions}`, sendOpts);
                     }
                     // 工具调用
                     if (event.type === 'tool_use') {
+                        // 工具调用意味着当前文本是中间轮，重置最后回复追踪
+                        lastReplyText = '';
                         this.eventBus.publish({
                             type: 'tool:use',
                             sessionId: session.id,
@@ -638,46 +864,81 @@ ${suggestions}`, sendOpts);
                         logger.warn(`[MessageProcessor] error event: ${event.errorType}: ${event.error}`);
                         if (!hasErrorResult && !shouldSuppress()) {
                             hasErrorResult = true;
-                            flusher.addActivity(`\u26a0\ufe0f ${event.error}`);
+                            flusher.addActivity(`\u274c ${event.error}`);
                         }
                     }
                     // 完成事件
+                    // SDK 可能产生多个 complete 事件（如 subagent 或 auto-compact 二次查询），
+                    // 仅记录状态，最终 flush(true) 在流结束后统一执行
                     if (event.type === 'complete') {
                         logger.debug(`[MessageProcessor] complete event: hasReceivedText=${hasReceivedText}, isError=${event.isError}, shouldSuppress=${shouldSuppress()}`);
+                        // 自动回填会话名称
+                        if (event.sessionTitle && session.name === '默认会话') {
+                            await this.sessionManager.renameSession(session.id, event.sessionTitle);
+                            logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
+                        }
+                        // 记录完成状态 + 最后一轮回复文本（后续 complete 覆盖前序）
+                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText };
                         // 失败且无前置错误输出：显示 errors 摘要
-                        if (event.isError && !hasErrorResult && !shouldSuppress()) {
+                        // 但用户主动中断（新消息打断 或 /stop 命令）时不显示错误提示
+                        const interruptReason = this.interruptedSessions.get(session.id);
+                        const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop';
+                        if (event.isError && !hasErrorResult && !shouldSuppress() && !isUserInterrupt) {
                             const errorSummary = event.errors?.join('; ') || '\u4efb\u52a1\u6267\u884c\u5931\u8d25';
-                            flusher.addActivity(`\u26a0\ufe0f ${errorSummary}`);
+                            // 使用 terminalReason 提供更友好的错误提示
+                            const userFriendlyMessage = event.terminalReason
+                                ? getErrorMessage(null, event.terminalReason)
+                                : `\u274c ${errorSummary}`;
+                            flusher.addActivity(userFriendlyMessage);
                         }
-                        // 成功结果文本：suppressed 模式下总是添加，否则仅在无流式文本时添加
-                        if (event.result) {
-                            if (shouldSuppress()) {
-                                flusher.addText(event.result);
-                            }
-                            else if (!hasReceivedText) {
-                                flusher.addText(event.result);
-                            }
+                        // 中间 complete：flush 掉已有 activities（不带 isFinal），让中间结果及时显示
+                        // 最终文本留给流结束后的统一 flush(true)
+                        if (flusher.hasContent()) {
+                            await flusher.flushActivitiesOnly();
                         }
-                        await flusher.flush(true);
                     }
                     continue;
                 }
-                // === 后台任务：只处理 complete 事件，仅缓存不发送 ===
+                // === 后台任务：追踪最后回复文本，但只处理 complete 事件 ===
+                if (event.type === 'text') {
+                    lastReplyText += event.text;
+                }
+                else if (event.type === 'tool_use') {
+                    lastReplyText = '';
+                }
                 if (event.type !== 'complete') {
                     continue;
                 }
+                // 自动回填会话名称
+                if (event.sessionTitle && session.name === '默认会话') {
+                    await this.sessionManager.renameSession(session.id, event.sessionTitle);
+                    logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
+                }
+                // 记录完成状态
+                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',
-                        message: event.result || '',
+                        message: lastReplyText || event.result || '',
                         timestamp: Date.now(),
                         metadata: {
                             duration: event.durationMs,
                             cost: event.costUsd
                         }
                     });
+                    // 后台任务完成也纳入统计
+                    this.eventBus.publish({
+                        type: 'message:completed',
+                        sessionId: session.id,
+                        channel: session.channel,
+                        channelId: session.channelId,
+                        finalText: lastReplyText || event.result || undefined,
+                        durationMs: event.durationMs,
+                        timestamp: Date.now()
+                    });
                 }
                 else if (event.isError === true) {
+                    const bgErrorType = prefixErrorType(ERROR_PREFIX.AGENT, event.subtype || 'agent_error');
                     this.messageCache.addEvent(session.id, {
                         type: 'error',
                         message: event.errors?.join('\n') || '\u672a\u77e5\u9519\u8bef',
@@ -686,16 +947,42 @@ ${suggestions}`, sendOpts);
                             errorType: event.subtype
                         }
                     });
+                    // 后台任务失败也纳入统计
+                    this.eventBus.publish({
+                        type: 'message:error',
+                        sessionId: session.id,
+                        error: event.errors?.join('; ') || '\u672a\u77e5\u9519\u8bef',
+                        errorType: bgErrorType
+                    });
                 }
             }
         }
         catch (error) {
-            logger.error('[MessageProcessor] Stream processing error:', error);
+            // User interrupt (AbortError) is expected, log at info level
+            if (error instanceof Error && error.name === 'AbortError') {
+                logger.info('[MessageProcessor] Stream interrupted (AbortError)');
+            }
+            else {
+                logger.error('[MessageProcessor] Stream processing error:', error);
+            }
             if (error instanceof Error && error.message.includes('process exited')) {
                 flusher.addActivity('\u274c Claude Code \u8fdb\u7a0b\u5f02\u5e38\u9000\u51fa\uff0c\u8bf7\u91cd\u8bd5');
             }
+            // Flush any pending error activities before re-throwing,
+            // and mark the error so outer catch won't send a duplicate message
+            if (hasErrorResult || flusher.hasContent()) {
+                try {
+                    await flusher.flush(true);
+                }
+                catch { }
+                if (error instanceof Error) {
+                    error._errorAlreadySent = true;
+                }
+            }
             throw error;
         }
+        completeResult.hasReceivedText = hasReceivedText;
+        return completeResult;
     }
     /**
      * 解析文件路径，支持相对路径和绝对路径