evolclaw 3.1.3 → 3.1.5

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

@@ -12,6 +12,8 @@ import { getPackageRoot, resolveRoot } from '../../paths.js';
 import { renderKitSections } from '../../agents/kit-renderer.js';
 import { normalizeBaseagent } from '../../agents/baseagent-normalize.js';
 import { renderActionAsText, renderCommandCardAsText } from '../interaction-router.js';
+import { formatPeerKey } from '../relation/peer-key.js';
+import { resolveEffectiveModel } from '../model/model-scope.js';
 function getContextTooLongHint(agent) {
     if (canCompactAgent(agent)) {
         return '上下文过长，请精简提问或使用 /compact 压缩上下文';
@@ -69,7 +71,8 @@ export class MessageProcessor {
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
     interactionRouter;
     messageQueue;
-    skillsEnsured = false; // 全局 SKILLS.md 是否已确保
+    /** sessionId → 活跃的空闲监控器，用于等待用户交互期间暂停/恢复计时 */
+    activeMonitors = new Map();
     /**
      * Get the runner for a given (channel, baseagent) pair.
      *
@@ -95,10 +98,11 @@ export class MessageProcessor {
         return [...this.agentMap.keys()];
     }
     /** 判断是否为后台会话（仅主会话参与判断，话题会话独立） */
-    async isBackgroundSession(session, channel, channelId) {
+    isBackgroundSession(session, _channel, _channelId) {
         if (session.threadId)
             return false;
-        const active = await this.sessionManager.getActiveSession(channel, channelId);
+        // 使用 session 自身的 channelType 精确定位 active.json，避免扫描误匹配
+        const active = this.sessionManager.getActiveSessionSync(session.channel, session.channelId, session.channelType, session.selfAID);
         return active ? session.id !== active.id : false;
     }
     constructor(agentRunnerOrMap, sessionManager, globalSettings, messageCache, eventBus, commandHandler, primaryRunnerKey) {
@@ -125,6 +129,16 @@ export class MessageProcessor {
     }
     setInteractionRouter(router) {
         this.interactionRouter = router;
+        // 等待用户交互期间暂停 idle 监控，应答/取消/超时后恢复——
+        // 避免把「正在等用户点按钮」误判为「任务卡死」而中断任务。
+        router.setWaitHooks({
+            onWaitStart: (sessionId) => {
+                this.activeMonitors.get(sessionId)?.pause();
+            },
+            onWaitEnd: (sessionId) => {
+                this.activeMonitors.get(sessionId)?.resume();
+            },
+        });
     }
     setMessageQueue(queue) {
         this.messageQueue = queue;
@@ -210,10 +224,10 @@ export class MessageProcessor {
      */
     async processMessage(message) {
         const idleMs = (this.globalSettings.idleMonitor?.timeout ?? 120) * 1000;
-        // 先解析会话，再优先用 session.metadata.channelName 精确定位实例级 adapter
+        // 先解析会话，再优先用 session.metadata.channelKey 精确定位实例级 adapter
         // message.channel 现在存实例名（channelName），可直接用于精确路由
         const { session, absoluteProjectPath } = await this.resolveSession(message);
-        const channelKey = session.metadata?.channelName || message.channel;
+        const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
         if (!channelInfo) {
             logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
@@ -245,12 +259,13 @@ export class MessageProcessor {
             monitor?.recordEvent(eventType || 'unknown', toolName);
         };
         // Cache background status to avoid async call inside setInterval
-        const isBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+        const isBackground = this.isBackgroundSession(session, message.channel, message.channelId);
         const timeoutPromise = new Promise((_, reject) => {
             rejectFn = reject;
             if (!monitorEnabled)
                 return;
             monitor = new StreamIdleMonitor(idleMs);
+            this.activeMonitors.set(streamKey, monitor);
             monitorInterval = setInterval(() => {
                 // Drain all pending levels in one tick
                 let result = monitor.check();
@@ -331,6 +346,7 @@ export class MessageProcessor {
         finally {
             if (monitorInterval)
                 clearInterval(monitorInterval);
+            this.activeMonitors.delete(streamKey);
         }
     }
     /** 获取回复上下文（跟着任务走） */
@@ -340,7 +356,7 @@ export class MessageProcessor {
     /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
     async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
-        const channelKey = session.metadata?.channelName || message.channel;
+        const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
         // Per-method agent name for stats bucketing (agent.name or '<unknown>')
         const agentNameForStats = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '<unknown>';
@@ -382,7 +398,7 @@ export class MessageProcessor {
             replyContext: taskReplyContext(),
         });
         try {
-            const isBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+            const isBackground = this.isBackgroundSession(session, message.channel, message.channelId);
             // 记录收到消息
             logger.message({
                 msgId: messageId,
@@ -439,7 +455,7 @@ export class MessageProcessor {
                     // （不支持 thought 的 channel 静默丢弃，避免降级为普通消息）
                     if (isProactive && payload.kind === 'activity.batch' && !adapter.capabilities?.thought)
                         return;
-                    const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+                    const isCurrentlyBackground = this.isBackgroundSession(session, message.channel, message.channelId);
                     if (isCurrentlyBackground)
                         return;
                     const opts = {};
@@ -447,7 +463,7 @@ export class MessageProcessor {
                     if (baseReplyCtx) {
                         Object.assign(opts, baseReplyCtx);
                     }
-                    else if (firstReply && message.messageId) {
+                    else if (firstReply && message.messageId && message.source !== 'trigger') {
                         if (payload.kind === 'result.text' && payload.text) {
                             opts.replyToMessageId = message.messageId;
                             firstReply = false;
@@ -507,6 +523,7 @@ export class MessageProcessor {
                 : message.content;
             let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
             let effectiveSystemPrompt;
+            let modelOverride;
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
@@ -516,18 +533,13 @@ export class MessageProcessor {
                 const selfAid = typeof adapterAny._selfAid === 'function' ? adapterAny._selfAid() : undefined;
                 const selfName = typeof adapterAny._selfName === 'function' ? adapterAny._selfName() : undefined;
                 const peerName = message.peerName || session.metadata?.peerName;
-                // 文件发送能力
-                let currentCanSend = false;
-                if (!isProactive) {
-                    currentCanSend = !!(channelInfo.adapter.capabilities?.file);
-                }
                 // 通道能力
                 const capParts = [];
                 if (options?.supportsImages)
                     capParts.push('图片输入');
                 if (channelInfo.adapter.capabilities?.image)
                     capParts.push('图片输出');
-                if (channelInfo.adapter.capabilities?.file)
+                if (!isProactive && channelInfo.adapter.capabilities?.file)
                     capParts.push('文件发送');
                 // Personal layer
                 const owningAgent = this.agentRegistry?.resolveByChannel(channelKey);
@@ -537,18 +549,41 @@ export class MessageProcessor {
                     contextParts.push(persona);
                 if (working)
                     contextParts.push(`[当前关注]\n${working}`);
-                // 计算 peerKey: <channel>#<urlEncode(peerId)>
+                // 计算 peerKey: <channelType>#<urlEncode(peerId)>
                 const peerIdRaw = message.peerId;
                 const peerKey = (currentChannelType && peerIdRaw)
-                    ? `${currentChannelType}#${encodeURIComponent(peerIdRaw)}`
+                    ? formatPeerKey(currentChannelType, peerIdRaw)
                     : undefined;
+                // 按 关系级 > agent级 > 全局 解析本次调用的模型/强度，作为 per-call 入参传入 runQuery。
+                // 不缓存、不绑会话——改关系级/agent级后该范围所有会话的下条消息即时生效；
+                // 多对端并发各自独立解析、各自传参，无共享状态可被污染。
+                try {
+                    const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey });
+                    if (resolved.model)
+                        modelOverride = { model: resolved.model, effort: resolved.effort };
+                }
+                catch (e) {
+                    logger.warn(`[MessageProcessor] resolveEffectiveModel failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
                 const normalizedBaseagent = normalizeBaseagent(agent.name);
+                const agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
                 // Kit renderer: 组装上下文
+                const pkgRoot = getPackageRoot();
                 const kitCtx = {
                     vars: {
                         EVOLCLAW_HOME: resolveRoot(),
-                        PACKAGE_ROOT: getPackageRoot(),
+                        PACKAGE_ROOT: pkgRoot,
                         CURRENT_PROJECT: absoluteProjectPath,
+                        // ECK 派生路径（manifest 引用时需要展开）
+                        KITS: path.join(pkgRoot, 'kits'),
+                        KITS_RULES: path.join(pkgRoot, 'kits', 'rules'),
+                        KITS_DOCS: path.join(pkgRoot, 'kits', 'docs'),
+                        KITS_TEMPLATES: path.join(pkgRoot, 'kits', 'templates'),
+                        KITS_FRAGMENTS: path.join(pkgRoot, 'kits', 'templates', 'system-fragments'),
+                        // 路径变量(用于 manifest 路径展开,resolvePath 用 ctx.vars 取真值)
+                        PERSONAL_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'personal') : undefined,
+                        RELATIONS_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'relations') : undefined,
+                        VENUES_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'venues') : undefined,
                         selfAid: selfAid || undefined,
                         selfName: selfName || undefined,
                         hasPersona: !!persona,
@@ -556,20 +591,30 @@ export class MessageProcessor {
                         peerId: peerIdRaw || undefined,
                         peerKey,
                         peerName: peerName || undefined,
-                        peerRole: session.identity?.role || 'unknown',
+                        peerRole: session.identity?.role || 'anonymous',
+                        peerType: message.peerType || undefined,
                         groupId: session.metadata?.groupId || undefined,
-                        scene: session.chatType ? (session.chatType === 'group' ? 'group' : 'private') : 'coding',
                         chatType: session.chatType || null,
                         channel: currentChannelType || null,
                         venueUid: undefined,
+                        // 群分发模式 / 客户端类型 / 权限模式
+                        dispatch: session.metadata?.dispatchMode || undefined,
+                        clientType: message.clientType || undefined,
+                        permissionMode: session.metadata?.permissionMode || 'auto',
+                        capabilities: capParts.length > 0 ? capParts.join('、') : undefined,
                         project: path.basename(absoluteProjectPath),
+                        sessionId: session.id,
                         sessionName: session.name || undefined,
-                        chatmode: isProactive ? 'proactive' : 'interactive',
+                        sessionCreatedAt: session.createdAt ? new Date(session.createdAt).toISOString() : undefined,
+                        threadId: session.threadId || undefined,
+                        // Stage 3: sessionKey 持久化字段
+                        sessionKey: session.sessionKey,
+                        chatMode: isProactive ? 'proactive' : 'interactive',
                         readonly: session.metadata?.permissionMode === 'readonly',
-                        canSendFile: !isProactive && currentCanSend,
-                        capabilities: capParts.length > 0 ? capParts.join('、') : undefined,
                         baseAgent: normalizedBaseagent.canonical,
                         baseAgentName: normalizedBaseagent.displayName,
+                        baseAgentModel: agentModel || undefined,
+                        agentSessionId: session.agentSessionId || undefined,
                     },
                     sessionId: session.id,
                 };
@@ -583,7 +628,7 @@ export class MessageProcessor {
                     let streamRegistered = false;
                     try {
                         logger.info(`[MessageProcessor] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${attempt}/${MAX_RETRIES} agentSessionId=${session.agentSessionId ?? 'none'}`);
-                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager);
+                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager, modelOverride);
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
                         streamResult = await this.processEventStream(stream, session, agent, renderer, resetTimer, shouldSuppress);
@@ -612,9 +657,11 @@ export class MessageProcessor {
                     await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
-                        // compact 成功，带 resume 重试（不重复原始消息，让 Agent 继续未完成的工作）
+                        // compact 成功，清除第一次流中混入的错误文本，再重试
+                        const ctxErrPattern = /prompt is too long|input is too long|上下文过长/i;
+                        renderer.stripContextError(ctxErrPattern);
                         renderer.addNotice('✅ 压缩完成，继续处理...', 'info', 'compact-retry', true);
-                        const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager);
+                        const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride);
                         agent.registerStream(streamKey, retryStream);
                         streamResult = await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress);
                     }
@@ -635,12 +682,13 @@ export class MessageProcessor {
                 contextTooLongPattern.test(errorsText) ||
                 contextTooLongPattern.test(streamResult.fullText));
             if (isPromptTooLong) {
+                renderer.stripContextError(contextTooLongPattern);
                 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);
+                    const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride);
                     agent.registerStream(streamKey, retryStream);
                     streamResult = await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress);
                     // 重试后仍然 prompt_too_long：清理 renderer 中可能混入的错误文本，显示友好提示
@@ -752,7 +800,7 @@ export class MessageProcessor {
             if (finalReplyText) {
                 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);
+                    const isCurrentlyBackground = 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)}"`);
@@ -829,7 +877,7 @@ export class MessageProcessor {
                         adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
                     }
                     else {
-                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, numTurns: streamResult.numTurns, usage: streamResult.usage } }).catch(() => { });
+                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, ttftMs: streamResult.ttftMs, numTurns: streamResult.numTurns, usage: streamResult.usage } }).catch(() => { });
                     }
                 }
                 if (message.triggerMeta) {
@@ -868,7 +916,7 @@ export class MessageProcessor {
                 // 写入消息记录（出方向）已下沉到 aun.ts:deliverTextEntry，
                 // 所有 message.send 成功后统一写入 messages.jsonl，此处不再重复写入。
             }
-            const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+            const isFinallyBackground = this.isBackgroundSession(session, message.channel, message.channelId);
             if (isFinallyBackground && session.sessionMode !== 'autonomous') {
                 const projectName = path.basename(session.projectPath);
                 const count = this.messageCache.getCount(session.id);
@@ -952,7 +1000,7 @@ export class MessageProcessor {
                 // 获取 session 用于话题回复（如果 resolveSession 已执行）
                 let sendOpts;
                 try {
-                    await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd(), message.threadId, undefined, undefined, message.peerId, message.chatType, undefined, message.selfId, message.channelType, message.peerType);
+                    await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd(), message.threadId, undefined, undefined, message.peerId, message.chatType, undefined, message.selfAID, message.channelType, message.peerType);
                     sendOpts = this.getReplyContext(message);
                 }
                 catch { }
@@ -989,7 +1037,7 @@ 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, message.chatType, undefined, message.selfId, message.channelType, message.peerType);
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId, message.chatType, undefined, message.selfAID, message.channelType, message.peerType);
         // 兜底纠正1：群聊强制 proactive
         if (message.chatType === 'group' && session.sessionMode !== 'proactive') {
             logger.info(`[MessageProcessor] group proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive`);
@@ -1003,6 +1051,13 @@ export class MessageProcessor {
             session.sessionMode = 'proactive';
             await this.sessionManager.updateSession(session.id, { sessionMode: 'proactive' });
         }
+        // Proactive→Interactive 模式切换提示：上一轮 proactive 使用了标志位，本轮已切换为 interactive
+        if (session.sessionMode === 'interactive' && session.metadata?.lastProactiveFlag) {
+            message.content = '本轮会话已切换为 interactive 模式，无需调用工具发送消息。\n\n' + message.content;
+            delete session.metadata.lastProactiveFlag;
+            await this.sessionManager.updateSession(session.id, { metadata: session.metadata });
+            logger.info(`[MessageProcessor] Injected interactive mode hint for session ${session.id}`);
+        }
         // replyContext 不再写入 session.metadata（跟着 message 走，避免群聊多人覆盖）
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
@@ -1017,7 +1072,7 @@ export class MessageProcessor {
      */
     async processEventStream(stream, session, agent, renderer, resetTimer, shouldSuppress) {
         // Per-session agent name for stats bucketing
-        const agentNameForStats = this.agentRegistry?.resolveByChannel(session.metadata?.channelName || session.channel)?.name ?? '<unknown>';
+        const agentNameForStats = this.agentRegistry?.resolveByChannel(session.metadata?.channelKey || session.channel)?.name ?? '<unknown>';
         let hasReceivedText = false;
         let hasErrorResult = false; // 是否已有 tool_result/error 事件输出过错误
         let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
@@ -1083,7 +1138,7 @@ export class MessageProcessor {
                     });
                     continue;
                 }
-                const isCurrentlyBackground = await this.isBackgroundSession(session, session.channel, session.channelId);
+                const isCurrentlyBackground = this.isBackgroundSession(session, session.channel, session.channelId);
                 // === 前台任务：正常处理所有事件 ===
                 if (!isCurrentlyBackground) {
                     // 流式文本
@@ -1099,7 +1154,7 @@ export class MessageProcessor {
                     if (event.type === 'compact') {
                         this.eventBus.publish({ type: 'runner:compact-complete', sessionId: session.id, preTokens: event.preTokens });
                         if (!shouldSuppress()) {
-                            renderer.addNotice(`\ud83d\udca1 会话压缩完成，继续执行...（压缩前 tokens: ${event.preTokens}）`, 'info', 'compact');
+                            renderer.addNotice(`\ud83d\udca1 会话压缩完成，继续执行...）`, 'info', 'compact');
                         }
                     }
                     // 子任务进度
@@ -1177,14 +1232,15 @@ export class MessageProcessor {
                     // SDK 可能产生多个 complete 事件（如 subagent 或 auto-compact 二次查询），
                     // 仅记录状态，最终 flush(true) 在流结束后统一执行
                     if (event.type === 'complete') {
-                        logger.info(`[MessageProcessor] complete event: isError=${event.isError} terminalReason=${event.terminalReason ?? 'none'} subtype=${event.subtype ?? 'none'} hasReceivedText=${hasReceivedText}`);
+                        const isAbort = event.terminalReason === 'aborted_streaming' || event.terminalReason === 'aborted_tools';
+                        logger.info(`[MessageProcessor] ${isAbort ? 'task interrupted' : '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, numTurns: event.numTurns, usage: event.usage };
+                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, usage: event.usage };
                         // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
                         // 由那里按 LLM 输出的每个 text item 单独写一条，此处不再写。
                         // 失败且无前置错误输出：显示 errors 摘要
@@ -1212,6 +1268,15 @@ export class MessageProcessor {
                         if (renderer.hasContent()) {
                             await renderer.flushActivitiesOnly();
                         }
+                        // 检测 proactive 标志位，设置 lastProactiveFlag 供模式切换提示使用
+                        if (session.sessionMode === 'proactive' && lastReplyText) {
+                            if (/\[PROACTIVE:REPLY_CONFIRMED_(SENT|NONE)\]/.test(lastReplyText)) {
+                                session.metadata = session.metadata || {};
+                                session.metadata.lastProactiveFlag = true;
+                                await this.sessionManager.updateSession(session.id, { metadata: session.metadata });
+                                logger.debug(`[MessageProcessor] Set lastProactiveFlag for session ${session.id}`);
+                            }
+                        }
                     }
                     continue;
                 }
@@ -1231,7 +1296,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, numTurns: event.numTurns, usage: event.usage };
+                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, usage: event.usage };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',
@@ -1344,85 +1409,6 @@ export class MessageProcessor {
         // 都找不到，返回项目根目录路径
         return rootPath;
     }
-    /**
-     * 确保全局数据目录下有最新版本的 SKILLS.md
-     * 目标：{EVOLCLAW_HOME}/data/SKILLS.md
-     */
-    ensureSkillsFile() {
-        try {
-            const targetDir = path.join(resolveRoot(), 'data');
-            const targetPath = path.join(targetDir, 'SKILLS.md');
-            const templatePath = path.join(getPackageRoot(), 'src', 'templates', 'skills.md');
-            // 模板不存在则跳过（构建环境可能没有 src/）
-            if (!fs.existsSync(templatePath)) {
-                // 尝试 dist/templates/skills.md
-                const distTemplatePath = path.join(getPackageRoot(), 'dist', 'templates', 'skills.md');
-                if (!fs.existsSync(distTemplatePath))
-                    return;
-                this.copySkillsIfNeeded(distTemplatePath, targetDir, targetPath);
-                return;
-            }
-            this.copySkillsIfNeeded(templatePath, targetDir, targetPath);
-        }
-        catch {
-            // 静默失败，不影响正常消息处理
-        }
-    }
-    copySkillsIfNeeded(templatePath, targetDir, targetPath) {
-        const templateContent = fs.readFileSync(templatePath, 'utf-8');
-        const templateVersion = templateContent.match(/^version:\s*(.+)$/m)?.[1]?.trim() || '0';
-        if (fs.existsSync(targetPath)) {
-            const existing = fs.readFileSync(targetPath, 'utf-8');
-            const existingVersion = existing.match(/^version:\s*(.+)$/m)?.[1]?.trim() || '0';
-            if (this.compareSemver(existingVersion, templateVersion) >= 0)
-                return; // 已是最新
-        }
-        if (!fs.existsSync(targetDir)) {
-            fs.mkdirSync(targetDir, { recursive: true });
-        }
-        fs.writeFileSync(targetPath, templateContent, 'utf-8');
-    }
-    /** 简易 semver 比较：支持 "1", "1.0", "1.0.0" 等格式，返回 -1/0/1 */
-    compareSemver(a, b) {
-        const pa = a.split('.').map(Number);
-        const pb = b.split('.').map(Number);
-        const len = Math.max(pa.length, pb.length);
-        for (let i = 0; i < len; i++) {
-            const na = pa[i] || 0;
-            const nb = pb[i] || 0;
-            if (na !== nb)
-                return na > nb ? 1 : -1;
-        }
-        return 0;
-    }
-    /**
-     * 从 data/SKILLS.md 读取 frontmatter 并生成提示。
-     * 不缓存：每次读取保证用户编辑立即生效。
-     * 调用前应确保 ensureSkillsFile() 已执行过（首次落盘）。
-     */
-    getSkillsHint() {
-        try {
-            const skillsPath = path.join(resolveRoot(), 'data', 'SKILLS.md');
-            if (!fs.existsSync(skillsPath))
-                return null;
-            const content = fs.readFileSync(skillsPath, 'utf-8');
-            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-            if (!frontmatterMatch)
-                return null;
-            const fm = frontmatterMatch[1];
-            const desc = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() || 'EvolClaw 运行时管理指令';
-            const trigger = fm.match(/^trigger:\s*(.+)$/m)?.[1]?.trim() || '';
-            const parts = [
-                `可通过 Bash 指令管理运行时，${desc}。`,
-                trigger ? `触发时机：${trigger}。` : '',
-                `完整文档见 ${skillsPath}`,
-            ];
-            return parts.filter(Boolean).join('');
-        }
-        catch {
-            return null;
-        }
-    }
     /**
      * 判断文件路径是否为占位符/示例文本
      * 用于过滤大模型在说明文字中误写的 [SEND_FILE:...] 标记

package/dist/core/message/stream-idle-monitor.js

@@ -10,6 +10,7 @@ export class StreamIdleMonitor {
     state;
     triggeredLevels = new Set();
     idleMs;
+    paused = false;
     constructor(idleMs) {
         this.idleMs = idleMs;
         this.state = {
@@ -22,6 +23,24 @@ export class StreamIdleMonitor {
             hasReceivedText: false,
         };
     }
+    /**
+     * 暂停空闲计时（等待用户交互期间调用，如权限确认 / AskUserQuestion / PlanMode）。
+     * 暂停期间 check() 始终返回 null，等待时长不计入 idle。
+     */
+    pause() {
+        this.paused = true;
+    }
+    /**
+     * 恢复空闲计时。从恢复时刻重新起算 idle，并清空已触发级别——
+     * 用户应答后是一次全新的执行周期，不应继承等待前的 idle 状态。
+     */
+    resume() {
+        if (!this.paused)
+            return;
+        this.paused = false;
+        this.state.lastEventTime = Date.now();
+        this.triggeredLevels.clear();
+    }
     /**
      * 记录 SDK 事件，更新状态并重置空闲计时
      */
@@ -44,6 +63,8 @@ export class StreamIdleMonitor {
      * 检查空闲状态，返回 null（未空闲）或分级结果
      */
     check() {
+        if (this.paused)
+            return null;
         const now = Date.now();
         const idleDuration = now - this.state.lastEventTime;
         const notifyThreshold = this.idleMs * NOTIFY_MULTIPLIER;