evolclaw 3.0.0 → 3.1.1

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

@@ -10,7 +10,8 @@ import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError,
 import { summarizeToolInput } from '../permission.js';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
-import { renderPromptSection } from '../../agents/templates.js';
+import { renderKitSections } from '../../agents/kit-renderer.js';
+import { normalizeBaseagent } from '../../agents/baseagent-normalize.js';
 import { renderActionAsText, renderCommandCardAsText } from '../interaction-router.js';
 /**
  * 构造 OutboundEnvelope —— 出站三件套的信封部分。
@@ -124,7 +125,8 @@ export class MessageProcessor {
         const agent = this.agentRegistry.resolveByChannel(channelName);
         if (!agent)
             return null;
-        const globalCm = this.agentRegistry?.resolveByChannel(channelName)?.config?.chatmode;
+        // chatmode 解析优先级：agent.config.chatmode > globalSettings.chatmode
+        const globalCm = agent.config?.chatmode ?? this.globalSettings.chatmode;
         return agent.getContext(channelName, chatType, globalCm);
     }
     /**
@@ -182,7 +184,7 @@ export class MessageProcessor {
         '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
         '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check',
         '/p ', '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
-        '/aid', '/agentmd',
+        '/aid', '/agentmd', '/upgrade',
     ];
     /** 判断消息内容是否为已知命令 */
     isKnownCommand(content) {
@@ -345,6 +347,8 @@ export class MessageProcessor {
         // 为本次任务处理生成唯一 task_id（客户端生成，格式 task-{10hex}）
         const taskId = `task-${crypto.randomUUID().replace(/-/g, '').slice(0, 10)}`;
         const chatmode = session.sessionMode ?? 'interactive';
+        // 诊断日志：记录 inbound message_id 和生成的 task_id 的对应关系
+        logger.info(`[MessageProcessor] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode}`);
         // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
         const taskReplyContext = () => {
             const base = this.getReplyContext(message);
@@ -392,7 +396,8 @@ export class MessageProcessor {
             const peerLabel = peerName && peerName !== peerShort ? `${peerShort}(${peerName})` : peerShort;
             logger.info(`[MessageProcessor] session=${session.id} task=${taskId} peer=${peerLabel} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
             // 记录开始处理
-            this.eventBus.publish({ type: 'task:started', sessionId: session.id });
+            const taskEncrypt = message.replyContext?.metadata?.encrypted != null ? !!(message.replyContext.metadata.encrypted) : undefined;
+            this.eventBus.publish({ type: 'task:started', sessionId: session.id, agentName: agentNameForStats, encrypt: taskEncrypt, chatmode: session.sessionMode || 'interactive' });
             // 触发器消息不发 processing status（无需通知用户）
             if (message.source !== 'trigger') {
                 adapter.send(envelope, { kind: 'status.started' }).catch(() => { });
@@ -416,6 +421,10 @@ export class MessageProcessor {
                 send: async (payload) => {
                     if (isAutonomous)
                         return; // autonomous session: never send to channel
+                    // proactive 模式：activity.batch 是 thought 协议内容，只发给支持 thought 的 channel
+                    // （不支持 thought 的 channel 静默丢弃，避免降级为普通消息）
+                    if (isProactive && payload.kind === 'activity.batch' && !adapter.capabilities?.thought)
+                        return;
                     const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
                     if (isCurrentlyBackground)
                         return;
@@ -431,7 +440,7 @@ export class MessageProcessor {
                         }
                     }
                     if (payload.kind === 'result.text' && payload.isFinal) {
-                        opts.title = '\u2713 \u6700\u7ec8\u56de\u590d:';
+                        opts.title = '\u2705 \u6700\u7ec8\u56de\u590d:';
                     }
                     opts.metadata = { ...(opts.metadata ?? {}), taskId, chatmode };
                     const enrichedEnvelope = { ...envelope, replyContext: opts };
@@ -488,32 +497,15 @@ export class MessageProcessor {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
                 const currentChannelType = options?.channelType || message.channel;
-                // 1. 构建模板变量并渲染 runtime 段
-                const peerName = message.peerName || session.metadata?.peerName;
-                const peerType = message.peerType;
-                const peerId = message.peerId;
+                // 提取 self 信息
                 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);
-                // 文件发送能力（按 channelType 去重）
-                let crossChannelTypes = [];
+                const peerName = message.peerName || session.metadata?.peerName;
+                // 文件发送能力
                 let currentCanSend = false;
                 if (!isProactive) {
-                    const fileChannelTypes = new Set();
                     currentCanSend = !!(channelInfo.adapter.capabilities?.file);
-                    for (const [, info] of this.channels) {
-                        if (info.adapter.capabilities?.file) {
-                            fileChannelTypes.add(info.options?.channelType || info.adapter.channelName);
-                        }
-                    }
-                    crossChannelTypes = [...fileChannelTypes].filter(t => t !== currentChannelType);
                 }
                 // 通道能力
                 const capParts = [];
@@ -523,49 +515,53 @@ export class MessageProcessor {
                     capParts.push('图片输出');
                 if (channelInfo.adapter.capabilities?.file)
                     capParts.push('文件发送');
-                // Personal layer: persona.md + working memory 注入
+                // Personal layer
                 const owningAgent = this.agentRegistry?.resolveByChannel(channelKey);
-                if (owningAgent) {
-                    const persona = owningAgent.getPersona?.();
-                    if (persona)
-                        contextParts.push(persona);
-                    const working = owningAgent.getWorkingMemory?.();
-                    if (working)
-                        contextParts.push(`[当前关注]\n${working}`);
-                }
-                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(renderPromptSection('group', { peerId: message.peerId }));
-                }
-                // 3. Proactive 模式提示词
-                if (isProactive) {
-                    contextParts.push(renderPromptSection('proactive', {}));
-                }
-                // 4. 触发器功能提示词（非触发器消息时注入，让 AI 知道可以使用触发器）
-                if (message.source !== 'trigger') {
-                    const triggerSection = renderPromptSection('trigger', {});
-                    if (triggerSection)
-                        contextParts.push(triggerSection);
-                }
+                const persona = owningAgent?.getPersona?.() || undefined;
+                const working = owningAgent?.getWorkingMemory?.() || undefined;
+                if (persona)
+                    contextParts.push(persona);
+                if (working)
+                    contextParts.push(`[当前关注]\n${working}`);
+                // 计算 peerKey: <channel>#<urlEncode(peerId)>
+                const peerIdRaw = message.peerId;
+                const peerKey = (currentChannelType && peerIdRaw)
+                    ? `${currentChannelType}#${encodeURIComponent(peerIdRaw)}`
+                    : undefined;
+                const normalizedBaseagent = normalizeBaseagent(agent.name);
+                // Kit renderer: 组装上下文
+                const kitCtx = {
+                    vars: {
+                        EVOLCLAW_HOME: resolveRoot(),
+                        PACKAGE_ROOT: getPackageRoot(),
+                        CURRENT_PROJECT: absoluteProjectPath,
+                        selfAid: selfAid || undefined,
+                        selfName: selfName || undefined,
+                        hasPersona: !!persona,
+                        hasWorkingMemory: !!working,
+                        peerId: peerIdRaw || undefined,
+                        peerKey,
+                        peerName: peerName || undefined,
+                        peerRole: session.identity?.role || 'unknown',
+                        groupId: session.metadata?.groupId || undefined,
+                        scene: session.chatType ? (session.chatType === 'group' ? 'group' : 'private') : 'coding',
+                        chatType: session.chatType || null,
+                        channel: currentChannelType || null,
+                        venueUid: undefined,
+                        project: path.basename(absoluteProjectPath),
+                        sessionName: session.name || undefined,
+                        sessionMode: isProactive ? 'proactive' : 'interactive',
+                        readonly: session.metadata?.permissionMode === 'readonly',
+                        canSendFile: !isProactive && currentCanSend,
+                        capabilities: capParts.length > 0 ? capParts.join('、') : undefined,
+                        baseAgent: normalizedBaseagent.canonical,
+                        baseAgentName: normalizedBaseagent.displayName,
+                    },
+                    sessionId: session.id,
+                };
+                const kitContext = renderKitSections(kitCtx);
+                if (kitContext)
+                    contextParts.push(kitContext);
                 effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
                 const MAX_RETRIES = 3;
@@ -586,7 +582,7 @@ export class MessageProcessor {
                         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);
-                            renderer.addNotice(`⚠️ API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`, 'warn', 'retry', true);
+                            renderer.addNotice(`API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`, 'warn', 'retry', true);
                             await renderer.flush();
                             await new Promise(resolve => setTimeout(resolve, delay));
                             continue;
@@ -598,12 +594,12 @@ export class MessageProcessor {
             catch (error) {
                 if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId && hasCompact(agent)) {
                     // 尝试 compact 压缩会话
-                    renderer.addNotice('\u26a0\ufe0f 上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+                    renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
                     await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
                         // compact 成功，带 resume 重试（不重复原始消息，让 Agent 继续未完成的工作）
-                        renderer.addNotice('\u2705 压缩完成，正在重试...', 'info', 'compact-retry', true);
+                        renderer.addNotice('✅ 压缩完成，继续处理...', 'info', 'compact-retry', true);
                         const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager);
                         agent.registerStream(streamKey, retryStream);
                         streamResult = await this.processEventStream(retryStream, session, renderer, resetTimer, shouldSuppress);
@@ -616,6 +612,35 @@ export class MessageProcessor {
                     throw error;
                 }
             }
+            // prompt_too_long：SDK 以 complete 事件（非异常）返回，需在此处触发 compact
+            // 检测条件：terminalReason 明确为 prompt_too_long，或文本/errors 包含相关错误文本
+            const contextTooLongPattern = /prompt is too long|input is too long|上下文过长/i;
+            const errorsText = streamResult.errors?.join(' ') || '';
+            const isPromptTooLong = streamResult.isError && session.agentSessionId && hasCompact(agent) && (streamResult.terminalReason === 'prompt_too_long' ||
+                contextTooLongPattern.test(streamResult.lastReplyText) ||
+                contextTooLongPattern.test(errorsText) ||
+                contextTooLongPattern.test(streamResult.fullText));
+            if (isPromptTooLong) {
+                renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+                await renderer.flush();
+                const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
+                if (compacted) {
+                    renderer.addNotice('✅ 压缩完成，继续处理...', 'info', 'compact-retry', true);
+                    const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager);
+                    agent.registerStream(streamKey, retryStream);
+                    streamResult = await this.processEventStream(retryStream, session, renderer, resetTimer, shouldSuppress);
+                }
+                else {
+                    throw new Error('CONTEXT_COMPACT_FAILED');
+                }
+            }
+            else if (streamResult.isError && !isPromptTooLong && (streamResult.terminalReason === 'prompt_too_long' ||
+                contextTooLongPattern.test(streamResult.lastReplyText) ||
+                contextTooLongPattern.test(errorsText) ||
+                contextTooLongPattern.test(streamResult.fullText))) {
+                // 上下文过长但无法 auto-compact（无 session ID 或 agent 不支持），显示友好提示
+                renderer.addNotice('上下文过长，请精简提问或使用 /compact 压缩上下文', 'warn', 'context-too-long', true);
+            }
             // 处理文件标记 - 支持 [SEND_FILE:path] 和 [SEND_FILE:channel:path]
             // 注意：始终扫描全部文本（含中间轮），因为文件标记可能出现在任意轮次
             // suppressed 模式下 renderer 只有最后一轮文本，需要用 streamResult.fullText（SDK 全文）兜底
@@ -698,43 +723,35 @@ export class MessageProcessor {
                     }
                 }
             } // end of !isProactive
-            // 最终回复文本添加到 renderer（统一在流结束后处理，避免多 complete 事件重复发送）
-            // suppressed 模式：中间流式文本未推送，使用最后一轮回复（回退到全文）
-            // 非 suppressed 且无流式文本：同上
-            // 非 suppressed 且有流式文本：已经逐步推送过了，不重复添加
-            //   但如果 renderer 既未发送过内容也没有 pending 内容（如 text 事件全为空），仍需兜底
+            // 最终回复文本：suppressed 模式或无 text 事件时需要兜底添加
             const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
-            // 识别 Claude SDK 本地预处理兜底（如 "Unknown skill: xxx"）：
-            // 特征：无流式 text + complete.result 匹配已知模式
-            // 这类输出不是 agent 的回复意图，而是 SDK 本地拦截到的"未知斜杠命令"提示。
-            // Proactive 模式下 renderer silent，需要兜底发出以告知用户，否则用户完全无反馈。
-            const isSdkFallbackMessage = !!finalReplyText
-                && !streamResult.hasReceivedText
-                && /^Unknown skill:\s+\S+/i.test(finalReplyText.trim());
             if (finalReplyText) {
-                if (isProactive && isSdkFallbackMessage) {
-                    // Proactive 模式 + SDK 本地兜底：直接 sendText 绕过 silent renderer
+                if (isProactive && !streamResult.hasReceivedText && /^Unknown skill:\s+\S+/i.test(finalReplyText.trim())) {
+                    // Proactive 模式 + SDK 本地兜底：直接发送绕过 silent renderer
                     const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
                     if (!isCurrentlyBackground) {
                         await adapter.send({ ...envelope, replyContext: capturedReplyContext }, { kind: 'result.text', text: finalReplyText, isFinal: true });
                         logger.info(`[MessageProcessor] proactive SDK fallback replied task=${taskId} text="${finalReplyText.slice(0, 60)}"`);
                     }
                 }
-                else if (shouldSuppress()) {
-                    renderer.addText(finalReplyText);
-                }
-                else if (!streamResult.hasReceivedText || (!renderer.hasSentContent() && !renderer.hasContent())) {
+                else if (shouldSuppress() || !streamResult.hasReceivedText) {
                     renderer.addText(finalReplyText);
                 }
             }
-            // Flush 剩余内容（文件标记已在 flush 时自动移除）
-            await renderer.flush(true);
-            // 清理 activeStreams（正常完成）
+            // 先清理流和处理中状态（保证即使 flush 卡住，session 也不会永久处于"处理中"）
             agent.cleanupStream(streamKey);
             logger.info(`[MessageProcessor] agent.cleanupStream ok: session=${session.id} task=${taskId}`);
-            // 清除处理中状态
             this.sessionManager.clearProcessing(session.id);
             logger.info(`[MessageProcessor] session ${session.id} processing cleared task=${taskId}`);
+            // 被用户中断（新消息打断）时跳过 flush — 新 task 已接管渠道，旧 task 的 flush 无意义且可能卡住
+            const preFlushInterrupt = this.interruptedSessions.get(session.id);
+            if (preFlushInterrupt === 'new_message' || preFlushInterrupt === 'stop' || preFlushInterrupt === 'recalled') {
+                logger.info(`[MessageProcessor] Skipping flush for interrupted task=${taskId} reason=${preFlushInterrupt}`);
+            }
+            else {
+                // Flush 剩余内容（文件标记已在 flush 时自动移除）
+                await renderer.flush(true);
+            }
             // 更新 EvolAgent.lastActivity
             if (this.agentRegistry) {
                 const owningAgent = this.agentRegistry.resolveByChannel(channelKey);
@@ -788,7 +805,7 @@ export class MessageProcessor {
                         adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
                     }
                     else {
-                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs } }).catch(() => { });
+                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, numTurns: streamResult.numTurns, usage: streamResult.usage } }).catch(() => { });
                     }
                 }
                 if (message.triggerMeta) {
@@ -813,6 +830,7 @@ export class MessageProcessor {
                     finalText: streamResult.lastReplyText || undefined,
                     durationMs: Date.now() - startTime,
                     agentName: agentNameForStats,
+                    numTurns: streamResult.numTurns,
                     timestamp: Date.now()
                 });
                 // 记录处理完成
@@ -823,22 +841,8 @@ export class MessageProcessor {
                     status: 'completed',
                     duration: Date.now() - startTime
                 });
-                // 写入消息记录（出方向）
-                if (streamResult.lastReplyText || streamResult.fullText) {
-                    const chatDir = this.sessionManager.getChatDir(session);
-                    appendMessageLog(chatDir, buildOutboundEntry({
-                        from: message.selfId || session.selfId || 'self',
-                        to: message.peerId || message.channelId,
-                        chatType: (message.chatType || session.chatType || 'private'),
-                        groupId: session.metadata?.groupId ?? null,
-                        msgId: `${messageId}_reply`,
-                        content: streamResult.lastReplyText || streamResult.fullText,
-                        replyTo: message.messageId ?? null,
-                        agent: session.agentId || null,
-                        model: agent.getModel?.() || null,
-                        durationMs: Date.now() - startTime,
-                    }));
-                }
+                // 写入消息记录（出方向）已下沉到 aun.ts:deliverTextEntry，
+                // 所有 message.send 成功后统一写入 messages.jsonl，此处不再重复写入。
             }
             const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             if (isFinallyBackground && session.sessionMode !== 'autonomous') {
@@ -961,7 +965,20 @@ export class MessageProcessor {
                 : path.resolve(process.cwd(), session.projectPath);
             return { session, absoluteProjectPath };
         }
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId);
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId, undefined, undefined, undefined, undefined, message.peerType);
+        // 兜底纠正1：群聊强制 proactive
+        if (message.chatType === 'group' && session.sessionMode !== 'proactive') {
+            logger.info(`[MessageProcessor] group proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive`);
+            session.sessionMode = 'proactive';
+            await this.sessionManager.updateSession(session.id, { sessionMode: 'proactive' });
+        }
+        // 兜底纠正2：旧 session 创建时没传 peerType（建为 interactive），后续非 human 消息进来时升级为 proactive。
+        // 新建场景已由 getOrCreateSession 内部 resolveDefaultSessionMode 处理，这里只兜底历史会话。
+        if (message.peerType && message.peerType !== 'human' && message.peerType !== 'unknown' && session.sessionMode !== 'proactive') {
+            logger.info(`[MessageProcessor] proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive (peerType=${message.peerType})`);
+            session.sessionMode = 'proactive';
+            await this.sessionManager.updateSession(session.id, { sessionMode: 'proactive' });
+        }
         // replyContext 不再写入 session.metadata（跟着 message 走，避免群聊多人覆盖）
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
@@ -982,6 +999,8 @@ export class MessageProcessor {
         let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
         // 追踪最后一轮 assistant 回复文本（tool_use 之后的纯文本）
         let lastReplyText = '';
+        // callId → description 映射，用于 tool_result 回显描述
+        const toolDescByCallId = new Map();
         try {
             for await (const event of stream) {
                 // 每收到事件重置空闲超时
@@ -1049,7 +1068,7 @@ export class MessageProcessor {
                         lastReplyText += event.text;
                         this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: event.text, isFinal: false });
                         if (!shouldSuppress()) {
-                            renderer.addText(event.text);
+                            renderer.addText(event.text, event.outputTokens, event.turn);
                         }
                     }
                     // compact 完成
@@ -1073,7 +1092,11 @@ export class MessageProcessor {
                     }
                     // 工具调用
                     if (event.type === 'tool_use') {
-                        // 工具调用意味着当前文本是中间轮，重置最后回复追踪
+                        // 工具调用意味着当前 turn 结束，flush 已累积的文本作为独立消息
+                        if (renderer.hasTextPending()) {
+                            await renderer.flushText();
+                        }
+                        // 重置最后回复追踪
                         lastReplyText = '';
                         this.eventBus.publish({
                             type: 'tool:use',
@@ -1084,7 +1107,10 @@ export class MessageProcessor {
                         });
                         if (!shouldSuppress()) {
                             const desc = summarizeToolInput(event.name, event.input || {});
-                            renderer.addToolCall(event.name, event.input, event.callId, desc);
+                            if (event.callId) {
+                                toolDescByCallId.set(event.callId, desc);
+                            }
+                            renderer.addToolCall(event.name, event.input, event.callId, desc, event.turn, event.outputTokens);
                         }
                     }
                     // 工具结果
@@ -1098,47 +1124,80 @@ export class MessageProcessor {
                             agentName: agentNameForStats,
                             timestamp: Date.now()
                         });
+                        // 从 tool_use 阶段缓存的描述中回溯
+                        const cachedDesc = event.callId ? toolDescByCallId.get(event.callId) : undefined;
                         if (event.isError && !shouldSuppress()) {
                             hasErrorResult = true;
                             let errorMsg = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result)) || '\u6267\u884c\u5931\u8d25';
                             // 移除 XML 风格的错误标签
                             errorMsg = errorMsg.replace(/<tool_use_error>(.*?)<\/tool_use_error>/gs, '$1');
-                            renderer.addToolResult(event.name || '\u5de5\u5177', false, undefined, errorMsg, event.callId);
+                            renderer.addToolResult(event.name || '\u5de5\u5177', false, undefined, errorMsg, event.callId, undefined, cachedDesc);
                         }
                         else if (!event.isError && !shouldSuppress()) {
-                            renderer.addToolResult(event.name || '\u5de5\u5177', true, event.result, undefined, event.callId);
+                            renderer.addToolResult(event.name || '\u5de5\u5177', true, event.result, undefined, event.callId, undefined, cachedDesc);
                         }
                     }
                     // 运行时错误（Codex: turn.failed / item error）
                     if (event.type === 'error') {
                         logger.warn(`[MessageProcessor] error event: ${event.errorType}: ${event.error}`);
-                        if (!hasErrorResult && !shouldSuppress()) {
+                        // 记录错误文本到 lastReplyText，供后续 isPromptTooLong 检测
+                        lastReplyText += event.error || '';
+                        // 上下文过长的错误不在此处输出 notice，留给外层 isPromptTooLong 触发 auto-compact
+                        const isContextError = /prompt is too long|input is too long|上下文过长/i.test(event.error || '');
+                        if (!isContextError && !hasErrorResult && !shouldSuppress()) {
                             hasErrorResult = true;
-                            renderer.addNotice(`\u274c ${event.error}`, 'warn', 'runtime-error', true);
+                            renderer.addNotice(`${event.error}`, 'warn', 'runtime-error', true);
                         }
                     }
                     // 完成事件
                     // SDK 可能产生多个 complete 事件（如 subagent 或 auto-compact 二次查询），
                     // 仅记录状态，最终 flush(true) 在流结束后统一执行
                     if (event.type === 'complete') {
-                        logger.debug(`[MessageProcessor] complete event: hasReceivedText=${hasReceivedText}, isError=${event.isError}, shouldSuppress=${shouldSuppress()}`);
+                        logger.info(`[MessageProcessor] complete event: isError=${event.isError} terminalReason=${event.terminalReason ?? 'none'} subtype=${event.subtype ?? 'none'} hasReceivedText=${hasReceivedText}`);
                         // 自动回填会话名称
                         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 };
+                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, usage: event.usage };
+                        // proactive 模式：每轮 LLM 调用完成后写一条 thought 到 messages.jsonl
+                        // 这样 thought 数 = LLM 调用轮数，而不是 chunk 数
+                        if (session.sessionMode === 'proactive' && lastReplyText) {
+                            try {
+                                const chatDir = this.sessionManager.getChatDir(session);
+                                const sessionEncrypt = this.sessionManager.getSessionEncrypt(session.id);
+                                appendMessageLog(chatDir, buildOutboundEntry({
+                                    from: session.selfId || 'self',
+                                    to: session.metadata?.peerId ?? session.channelId,
+                                    chatType: (session.chatType ?? 'private'),
+                                    groupId: session.metadata?.groupId ?? null,
+                                    msgId: `thought-${session.id}-${Date.now()}`,
+                                    content: lastReplyText,
+                                    agent: session.agentId || null,
+                                    model: null,
+                                    durationMs: null,
+                                    encrypt: sessionEncrypt ?? undefined,
+                                    chatmode: 'proactive',
+                                    msgType: 'thought',
+                                }));
+                            }
+                            catch { }
+                        }
                         // 失败且无前置错误输出：显示 errors 摘要
                         // 但用户主动中断（新消息打断 或 /stop 命令）时不显示错误提示
+                        // 上下文过长的错误留给外层 isPromptTooLong 触发 auto-compact，不在此处输出
                         const interruptReason = this.interruptedSessions.get(session.id);
                         const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop' || interruptReason === 'recalled';
-                        if (event.isError && !hasErrorResult && !shouldSuppress() && !isUserInterrupt) {
-                            const errorSummary = event.errors?.join('; ') || '\u4efb\u52a1\u6267\u884c\u5931\u8d25';
-                            // 使用 terminalReason 提供更友好的错误提示
+                        const isContextTooLong = event.terminalReason === 'prompt_too_long'
+                            || /prompt is too long|input is too long|上下文过长/i.test(event.errors?.join(' ') || '')
+                            || /prompt is too long|input is too long|上下文过长/i.test(lastReplyText);
+                        if (event.isError && !hasErrorResult && !shouldSuppress() && !isUserInterrupt && !isContextTooLong) {
+                            const errorSummary = event.errors?.join('; ') || '任务执行失败';
+                            // 使用 terminalReason 提供更友好的错误提示（不带 emoji，由 formatter 统一加）
                             const userFriendlyMessage = event.terminalReason
-                                ? getErrorMessage(null, event.terminalReason)
-                                : `\u274c ${errorSummary}`;
+                                ? getErrorMessage(null, event.terminalReason, false)
+                                : errorSummary;
                             renderer.addNotice(userFriendlyMessage, 'warn', 'task-error', true);
                         }
                         // 中间 complete：flush 掉已有 activities（不带 isFinal），让中间结果及时显示
@@ -1165,7 +1224,7 @@ export class MessageProcessor {
                     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 };
+                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, usage: event.usage };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',
@@ -1185,6 +1244,7 @@ export class MessageProcessor {
                         finalText: lastReplyText || event.result || undefined,
                         durationMs: event.durationMs,
                         agentName: agentNameForStats,
+                        numTurns: event.numTurns,
                         timestamp: Date.now()
                     });
                 }
@@ -1212,9 +1272,16 @@ export class MessageProcessor {
         catch (error) {
             // User interrupt (AbortError) is expected, log at info level
             const catchInterruptReason = this.interruptedSessions.get(session.id);
-            const catchIsUserInterrupt = catchInterruptReason === 'new_message' || catchInterruptReason === 'stop';
+            const catchIsUserInterrupt = catchInterruptReason === 'new_message' || catchInterruptReason === 'stop' || catchInterruptReason === 'recalled';
             if (error instanceof Error && error.name === 'AbortError') {
                 logger.info('[MessageProcessor] Stream interrupted (AbortError)');
+                // User-initiated interrupt: skip flush — new task takes over the channel,
+                // flushing here would send a spurious "最终回复" before the new task's output
+                if (catchIsUserInterrupt) {
+                    completeResult.isError = false;
+                    completeResult.hasReceivedText = hasReceivedText;
+                    return completeResult;
+                }
             }
             else if (catchIsUserInterrupt) {
                 // SDK telemetry noise after user-initiated interrupt — not a real error
@@ -1231,7 +1298,7 @@ export class MessageProcessor {
                 logger.error('[MessageProcessor] Stream processing error:', error);
             }
             if (error instanceof Error && error.message.includes('process exited')) {
-                renderer.addNotice('\u274c Claude Code \u8fdb\u7a0b\u5f02\u5e38\u9000\u51fa\uff0c\u8bf7\u91cd\u8bd5', 'warn', 'process-exit', true);
+                renderer.addNotice('Claude Code 进程异常退出，请重试', 'warn', 'process-exit', true);
             }
             // Flush any pending error activities before re-throwing,
             // and mark the error so outer catch won't send a duplicate message

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

@@ -80,7 +80,8 @@ export class MessageQueue {
         }
         const queueKey = this.getQueueKey(sessionKey, projectPath);
         const agentName = options?.agentName || DEFAULT_AGENT_NAME;
-        logger.debug(`[Queue] Enqueuing message for ${queueKey} (agent=${agentName})`);
+        const isProcessing = this.processing.has(queueKey);
+        logger.info(`[Queue] enqueue: key=${queueKey} processing=${isProcessing} queueLen=${this.queues.get(queueKey)?.length ?? 0} agent=${agentName}`);
         return new Promise((resolve, reject) => {
             if (!this.queues.has(queueKey)) {
                 this.queues.set(queueKey, []);
@@ -104,6 +105,12 @@ export class MessageQueue {
                 else {
                     // 群聊：FIFO，不打断
                     logger.debug(`[Queue] ${queueKey} is processing, message queued (FIFO)`);
+                    this.eventBus?.publish({
+                        type: 'task:queued',
+                        channel: message.channel,
+                        channelId: message.channelId,
+                        replyContext: message.replyContext,
+                    });
                 }
             }
             else {
@@ -114,7 +121,7 @@ export class MessageQueue {
     }
     async processNext(queueKey) {
         this.processing.add(queueKey);
-        logger.debug(`[Queue] Processing queue ${queueKey}`);
+        logger.info(`[Queue] processNext: start key=${queueKey}`);
         while (true) {
             // 等待外部锁释放（/compact, /clear 等快速命令）
             const lock = this.getExternalLock(queueKey);
@@ -124,7 +131,7 @@ export class MessageQueue {
             }
             const queue = this.queues.get(queueKey);
             if (!queue || queue.length === 0) {
-                logger.debug(`[Queue] Queue ${queueKey} is empty, stopping`);
+                logger.info(`[Queue] processNext: queue empty, releasing key=${queueKey}`);
                 this.processing.delete(queueKey);
                 this.processingAgent.delete(queueKey);
                 this.currentSessionKey = undefined;