evolclaw 3.0.0 → 3.1.0

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);
@@ -416,6 +420,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 +439,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 +496,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 +514,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;
@@ -616,6 +611,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 +722,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 +804,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) {
@@ -837,6 +853,8 @@ export class MessageProcessor {
                         agent: session.agentId || null,
                         model: agent.getModel?.() || null,
                         durationMs: Date.now() - startTime,
+                        numTurns: streamResult.numTurns,
+                        usage: streamResult.usage,
                     }));
                 }
             }
@@ -961,7 +979,14 @@ 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);
+        // 兜底纠正：旧 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 +1007,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) {
                 // 每收到事件重置空闲超时
@@ -1073,7 +1100,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,6 +1115,9 @@ export class MessageProcessor {
                         });
                         if (!shouldSuppress()) {
                             const desc = summarizeToolInput(event.name, event.input || {});
+                            if (event.callId) {
+                                toolDescByCallId.set(event.callId, desc);
+                            }
                             renderer.addToolCall(event.name, event.input, event.callId, desc);
                         }
                     }
@@ -1098,21 +1132,27 @@ 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);
                         }
@@ -1121,19 +1161,23 @@ export class MessageProcessor {
                     // 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 };
                         // 失败且无前置错误输出：显示 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 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('; ') || '\u4efb\u52a1\u6267\u884c\u5931\u8d25';
                             // 使用 terminalReason 提供更友好的错误提示
                             const userFriendlyMessage = event.terminalReason
@@ -1165,7 +1209,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',
@@ -1212,9 +1256,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

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;

package/dist/core/permission.js

@@ -1,4 +1,5 @@
 import path from 'path';
+import fs from 'fs';
 import { renderActionAsText } from './interaction-router.js';
 import { buildEnvelope, sendInteractionPayload } from './message/message-processor.js';
 // 危险命令黑名单（正则表达式）
@@ -89,9 +90,15 @@ export function summarizeToolInput(toolName, input) {
         return '';
     const extractors = {
         'Read': (i) => i.file_path,
-        'Edit': (i) => i.file_path,
+        'Edit': (i) => formatEditSummary(i),
         'Write': (i) => i.file_path,
-        'Bash': (i) => i.command?.substring(0, 80),
+        'Bash': (i) => {
+            const cmd = i.command?.substring(0, 80) || '';
+            const desc = i.description;
+            if (desc && cmd)
+                return `${cmd} | ${desc}`;
+            return cmd || desc;
+        },
         'Grep': (i) => `pattern: ${i.pattern}`,
         'Glob': (i) => `pattern: ${i.pattern}`,
         'Agent': (i) => i.description || i.prompt?.substring(0, 80),
@@ -110,6 +117,8 @@ export function summarizeToolInput(toolName, input) {
         },
         'TaskCreate': (i) => i.subject || i.description?.substring(0, 80),
         'TaskUpdate': (i) => i.status ? `${i.taskId} → ${i.status}` : i.taskId,
+        'TaskOutput': (i) => `${i.task_id || '?'}${i.block === false ? ' (non-blocking)' : ''}${i.timeout ? ` timeout=${i.timeout}ms` : ''}`,
+        'TaskStop': (i) => i.task_id || i.shell_id || '?',
         'NotebookEdit': (i) => i.notebook_path,
         'WebFetch': (i) => i.url,
         'WebSearch': (i) => i.query?.substring(0, 80),
@@ -131,6 +140,81 @@ export function summarizeToolInput(toolName, input) {
         || input.url
         || '';
 }
+/** 为 Edit 工具生成 diff 风格摘要 */
+function formatEditSummary(input) {
+    const filePath = input.file_path || '';
+    const oldStr = typeof input.old_string === 'string' ? input.old_string : '';
+    const newStr = typeof input.new_string === 'string' ? input.new_string : '';
+    if (!oldStr && !newStr)
+        return filePath;
+    const MAX_DIFF_LINES = 14;
+    const oldLines = oldStr.split('\n');
+    const newLines = newStr.split('\n');
+    // 尝试从文件中定位 old_string 的起始行号
+    let startLine = 0; // 0-based; 0 means unknown
+    if (filePath && oldStr) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const idx = content.indexOf(oldStr);
+            if (idx >= 0) {
+                startLine = content.slice(0, idx).split('\n').length; // 1-based
+            }
+        }
+        catch {
+            // 文件不可读，行号留空
+        }
+    }
+    const diffLines = [];
+    // 找公共前缀行数
+    let prefixLen = 0;
+    while (prefixLen < oldLines.length && prefixLen < newLines.length && oldLines[prefixLen] === newLines[prefixLen]) {
+        prefixLen++;
+    }
+    // 找公共后缀行数
+    let suffixLen = 0;
+    while (suffixLen < oldLines.length - prefixLen &&
+        suffixLen < newLines.length - prefixLen &&
+        oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
+        suffixLen++;
+    }
+    const CONTEXT = 2;
+    // 计算行号宽度（用于对齐）
+    const maxLineNo = startLine > 0 ? startLine + oldLines.length - 1 : 0;
+    const newMaxLineNo = startLine > 0 ? startLine + prefixLen + (newLines.length - suffixLen - prefixLen) - 1 : 0;
+    const padWidth = startLine > 0 ? Math.max(maxLineNo, newMaxLineNo).toString().length : 0;
+    // 格式化一行：行号 + 标记 + 内容
+    // 使用 Unicode 符号避免飞书 Markdown 将 "- " 解析为列表
+    const fmtLine = (lineNo, marker, text) => {
+        if (startLine > 0) {
+            return `${lineNo.toString().padStart(padWidth)} ${marker}  ${text}`;
+        }
+        return `${marker}  ${text}`;
+    };
+    // 上下文前缀（最多 CONTEXT 行）
+    const ctxStart = Math.max(0, prefixLen - CONTEXT);
+    for (let i = ctxStart; i < prefixLen; i++) {
+        diffLines.push(fmtLine(startLine + i, ' ', oldLines[i]));
+    }
+    // 删除行
+    const removedEnd = oldLines.length - suffixLen;
+    for (let i = prefixLen; i < removedEnd && diffLines.length < MAX_DIFF_LINES; i++) {
+        diffLines.push(fmtLine(startLine + i, '−', oldLines[i]));
+    }
+    // 新增行（行号从 prefixLen 位置开始递增）
+    const addedEnd = newLines.length - suffixLen;
+    for (let i = prefixLen; i < addedEnd && diffLines.length < MAX_DIFF_LINES; i++) {
+        diffLines.push(fmtLine(startLine + i, '＋', newLines[i]));
+    }
+    // 上下文后缀（最多 CONTEXT 行）
+    const ctxEnd = Math.min(oldLines.length, removedEnd + CONTEXT);
+    for (let i = removedEnd; i < ctxEnd && diffLines.length < MAX_DIFF_LINES + 2; i++) {
+        diffLines.push(fmtLine(startLine + i, ' ', oldLines[i]));
+    }
+    if (diffLines.length > MAX_DIFF_LINES + 2) {
+        diffLines.splice(MAX_DIFF_LINES, diffLines.length, '  ...');
+    }
+    return `${filePath}\n\`\`\`\n${diffLines.join('\n')}\n\`\`\``;
+}
 export class PermissionGateway {
     pending = new Map();
     timeout = 5 * 60 * 1000;
@@ -222,7 +306,15 @@ export class PermissionGateway {
             await sendPrompt(renderActionAsText(interaction));
         }
         return new Promise((resolve) => {
-            this.pending.set(requestId, { sessionId, toolName, resolve, timer: setTimeout(() => { }, 0) });
+            const timer = setTimeout(() => {
+                const pending = this.pending.get(requestId);
+                if (!pending)
+                    return;
+                this.pending.delete(requestId);
+                this.eventBus?.publish({ type: 'permission:timeout', sessionId, requestId, toolName });
+                pending.resolve('deny');
+            }, this.timeout);
+            this.pending.set(requestId, { sessionId, toolName, resolve, timer });
             // 注册到 InteractionRouter（卡片和文本降级都注册，统一路由）
             if (context?.interactionRouter) {
                 context.interactionRouter.register(requestId, sessionId, (action) => {