evolclaw 3.1.4 → 3.1.6

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

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs';
+import os from 'os';
 import crypto from 'crypto';
 import { hasCompact } from '../../agents/claude-runner.js';
 import { IMRenderer } from './im-renderer.js';
@@ -12,6 +13,24 @@ 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';
+/** OS 信息在进程生命周期内是常量，模块加载时算一次。例: "Windows 11 Pro (win32 10.0.26200)" */
+const OS_INFO = (() => {
+    let label = '';
+    try {
+        label = os.version();
+    }
+    catch { /* 旧 Node 无 os.version */ }
+    return `${label ? label + ' ' : ''}(${os.platform()} ${os.release()})`;
+})();
+/** 当前 UTC 偏移，格式 +08:00 / -05:00。每条消息算（DST 安全）。 */
+function currentTzOffset() {
+    const off = -new Date().getTimezoneOffset(); // 分钟，东区为正
+    const sign = off >= 0 ? '+' : '-';
+    const abs = Math.abs(off);
+    return `${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+}
 function getContextTooLongHint(agent) {
     if (canCompactAgent(agent)) {
         return '上下文过长，请精简提问或使用 /compact 压缩上下文';
@@ -67,9 +86,12 @@ export class MessageProcessor {
     agentMap;
     primaryRunnerKey;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
+    /** sessionId → 模型降级状态（带退避探测，进程重启清零） */
+    modelFallbackMap = new Map();
     interactionRouter;
     messageQueue;
-    skillsEnsured = false; // 全局 SKILLS.md 是否已确保
+    /** sessionId → 活跃的空闲监控器，用于等待用户交互期间暂停/恢复计时 */
+    activeMonitors = new Map();
     /**
      * Get the runner for a given (channel, baseagent) pair.
      *
@@ -99,7 +121,7 @@ export class MessageProcessor {
         if (session.threadId)
             return false;
         // 使用 session 自身的 channelType 精确定位 active.json，避免扫描误匹配
-        const active = this.sessionManager.getActiveSessionSync(session.channel, session.channelId, session.channelType, session.selfId);
+        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) {
@@ -126,6 +148,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;
@@ -195,15 +227,15 @@ export class MessageProcessor {
     }
     // 命令前缀列表（与 CommandHandler.quickCommandPrefixes 保持同步）
     static COMMAND_PREFIXES = [
-        '/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart',
+        '/new', '/pwd', '/help', '/status', '/restart',
         '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
         '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check',
-        '/p ', '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
+        '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
         '/aid', '/upgrade', '/evolagent',
     ];
     /** 判断消息内容是否为已知命令 */
     isKnownCommand(content) {
-        return content === '/p' || content === '/s' ||
+        return content === '/s' ||
             MessageProcessor.COMMAND_PREFIXES.some(cmd => content.startsWith(cmd));
     }
     /**
@@ -211,10 +243,33 @@ 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;
+        // thread(feishu) pending strategy: inject replyContext so first reply creates the thread
+        if (message.triggerMeta?.pendingThread && message.triggerMeta?.rootMessageId) {
+            const triggerId = message.triggerMeta.triggerId;
+            const channelKeyForAgent = session.metadata?.channelKey || message.channel;
+            const trigMgr = this.agentRegistry?.resolveByChannel(channelKeyForAgent)?.triggerManager;
+            const onThreadCreated = trigMgr
+                ? (threadId) => {
+                    try {
+                        trigMgr.update(triggerId, { targetThreadId: threadId, pendingThread: false });
+                        logger.info(`[MessageProcessor] Feishu thread created for trigger ${triggerId}: ${threadId}`);
+                    }
+                    catch (e) {
+                        logger.warn(`[MessageProcessor] Failed to write back thread_id for trigger ${triggerId}: ${e}`);
+                    }
+                }
+                : undefined;
+            message.replyContext = {
+                ...(message.replyContext ?? {}),
+                replyToMessageId: message.triggerMeta.rootMessageId,
+                replyInThread: true,
+                ...(onThreadCreated ? { metadata: { ...(message.replyContext?.metadata ?? {}), onThreadCreated } } : {}),
+            };
+        }
+        const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
         if (!channelInfo) {
             logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
@@ -252,6 +307,7 @@ export class MessageProcessor {
             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();
@@ -332,6 +388,7 @@ export class MessageProcessor {
         finally {
             if (monitorInterval)
                 clearInterval(monitorInterval);
+            this.activeMonitors.delete(streamKey);
         }
     }
     /** 获取回复上下文（跟着任务走） */
@@ -341,7 +398,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>';
@@ -373,7 +430,7 @@ export class MessageProcessor {
             };
         };
         const isProactive = session.sessionMode === 'proactive';
-        const isAutonomous = session.sessionMode === 'autonomous' || message.triggerMeta?.silent === true;
+        const isAutonomous = session.sessionMode === 'autonomous';
         const envelope = buildEnvelope({
             taskId,
             channel: message.channel,
@@ -448,7 +505,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;
@@ -508,6 +565,10 @@ export class MessageProcessor {
                 : message.content;
             let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
             let effectiveSystemPrompt;
+            let modelOverride;
+            let usedFallback = false;
+            let skipEvolclawModel = false;
+            let agentModel;
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
@@ -533,19 +594,62 @@ 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级后该范围所有会话的下条消息即时生效；
+                // 多对端并发各自独立解析、各自传参，无共享状态可被污染。
+                let effectiveModel;
+                // 取降级状态，按退避策略决定是否跳过 evolclaw 作用域模型
+                const fbState = this.modelFallbackMap.get(session.id) ?? {
+                    failCount: 0, fallbackActive: false,
+                    messagesSinceFallback: 0, nextProbeAt: 2, hintShown: false,
+                };
+                // 退避期内递增消息计数，判断是否到探测点
+                if (fbState.fallbackActive) {
+                    fbState.messagesSinceFallback++;
+                    skipEvolclawModel = fbState.messagesSinceFallback < fbState.nextProbeAt;
+                    this.modelFallbackMap.set(session.id, fbState);
+                }
+                // 非跳过时：尝试解析 evolclaw 作用域模型
+                let evolclawModelOverride;
+                if (!skipEvolclawModel) {
+                    try {
+                        const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey });
+                        if (resolved.model) {
+                            evolclawModelOverride = { model: resolved.model, effort: resolved.effort };
+                            effectiveModel = resolved.model;
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`[MessageProcessor] resolveEffectiveModel failed: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                    modelOverride = evolclawModelOverride;
+                }
                 const normalizedBaseagent = normalizeBaseagent(agent.name);
-                const agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
+                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'),
+                        // evolclaw 运行模式：dev=源码仓库 | install=全局安装包
+                        evolclawMode: fs.existsSync(path.join(pkgRoot, 'src', 'index.ts')) ? 'dev' : 'install',
+                        // 路径变量(用于 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,
@@ -553,23 +657,39 @@ export class MessageProcessor {
                         peerId: peerIdRaw || undefined,
                         peerKey,
                         peerName: peerName || undefined,
-                        peerRole: session.identity?.role || 'unknown',
+                        peerRole: session.identity?.role || 'anonymous',
                         peerType: message.peerType || undefined,
+                        sameDevice: message.sameDevice || undefined,
+                        sameNetwork: message.sameNetwork || undefined,
+                        sameEgressIp: message.sameEgressIp || undefined,
                         groupId: session.metadata?.groupId || undefined,
                         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,
                         sessionCreatedAt: session.createdAt ? new Date(session.createdAt).toISOString() : undefined,
+                        // 时区（把 ISO 时间戳转本地时间用）+ OS 环境
+                        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || undefined,
+                        tzOffset: currentTzOffset(),
+                        osInfo: OS_INFO,
                         threadId: session.threadId || undefined,
+                        // Stage 3: sessionKey 持久化字段
+                        sessionKey: session.sessionKey,
                         chatMode: isProactive ? 'proactive' : 'interactive',
                         readonly: session.metadata?.permissionMode === 'readonly',
                         baseAgent: normalizedBaseagent.canonical,
                         baseAgentName: normalizedBaseagent.displayName,
                         baseAgentModel: agentModel || undefined,
+                        effectiveModel: effectiveModel || agentModel || undefined,
+                        modelFallbackActive: (fbState.fallbackActive || skipEvolclawModel) ? true : undefined,
+                        modelFallbackModel: (fbState.fallbackActive || skipEvolclawModel) ? (agentModel || undefined) : undefined,
                         agentSessionId: session.agentSessionId || undefined,
                     },
                     sessionId: session.id,
@@ -584,16 +704,36 @@ 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);
+                        // 探测成功（退避期内到达探测点且用的是 evolclaw 模型）→ 清零降级状态
+                        if (fbState.fallbackActive && !skipEvolclawModel && !usedFallback) {
+                            this.modelFallbackMap.delete(session.id);
+                            logger.info(`[MessageProcessor] Model probe succeeded, cleared fallback state for session=${session.id}`);
+                        }
                         break; // 成功，跳出重试循环
                     }
                     catch (retryError) {
                         if (streamRegistered) {
                             agent.cleanupStream(streamKey);
                         }
+                        // 模型不可用：累计计数，本次切换到 baseAgentModel 立即重试，不让用户看到失败
+                        if (classifyError(retryError) === ErrorType.MODEL_UNAVAILABLE && evolclawModelOverride?.model) {
+                            fbState.failCount++;
+                            if (fbState.failCount >= 2) {
+                                fbState.fallbackActive = true;
+                                fbState.messagesSinceFallback = 0;
+                                fbState.nextProbeAt = Math.min(Math.pow(2, fbState.failCount - 1), 8);
+                            }
+                            this.modelFallbackMap.set(session.id, fbState);
+                            logger.warn(`[MessageProcessor] Model unavailable: ${evolclawModelOverride.model}, failCount=${fbState.failCount}, fallbackActive=${fbState.fallbackActive}`);
+                            // 切换到 baseAgentModel 重试（清除 modelOverride，让 runQuery 使用 this.model）
+                            modelOverride = undefined;
+                            usedFallback = true;
+                            continue;
+                        }
                         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);
@@ -613,9 +753,8 @@ export class MessageProcessor {
                     await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
-                        // compact 成功，带 resume 重试（不重复原始消息，让 Agent 继续未完成的工作）
                         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);
                     }
@@ -641,7 +780,7 @@ export class MessageProcessor {
                 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 中可能混入的错误文本，显示友好提示
@@ -651,7 +790,6 @@ export class MessageProcessor {
                         contextTooLongPattern.test(retryErrorsText) ||
                         contextTooLongPattern.test(streamResult.fullText));
                     if (retryStillTooLong) {
-                        renderer.stripContextError(contextTooLongPattern);
                         renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
                     }
                 }
@@ -768,6 +906,20 @@ export class MessageProcessor {
             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}`);
+            // 降级模型回复末尾追加标记（代码层硬注入，不依赖模型输出）
+            const usingFallback = usedFallback || (skipEvolclawModel && agentModel != null);
+            if (usingFallback && agentModel) {
+                const curFbState = this.modelFallbackMap.get(session.id);
+                const showHint = curFbState && curFbState.nextProbeAt >= 8 && !curFbState.hintShown;
+                const suffix = showHint
+                    ? `\n\n---\n⚠️ [降级模型: ${agentModel} | 可告诉我"帮我检查可用模型"来诊断]`
+                    : `\n\n---\n⚠️ [降级模型: ${agentModel}]`;
+                renderer.addText(suffix);
+                if (showHint && curFbState) {
+                    curFbState.hintShown = true;
+                    this.modelFallbackMap.set(session.id, curFbState);
+                }
+            }
             // 被用户中断（新消息打断）时跳过 flush — 新 task 已接管渠道，旧 task 的 flush 无意义且可能卡住
             const preFlushInterrupt = this.interruptedSessions.get(session.id);
             if (preFlushInterrupt === 'new_message' || preFlushInterrupt === 'stop' || preFlushInterrupt === 'recalled') {
@@ -830,7 +982,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, tokenUsage: streamResult.tokenUsage, contextUsage: streamResult.contextUsage } }).catch(() => { });
                     }
                 }
                 if (message.triggerMeta) {
@@ -840,10 +992,6 @@ export class MessageProcessor {
                     else {
                         this.eventBus.publish({ type: 'trigger:completed', triggerId: message.triggerMeta.triggerId, messageId: messageId, durationMs });
                     }
-                    // Clean up autonomous sessions after completion to avoid accumulating orphaned sessions
-                    if (session.sessionMode === 'autonomous') {
-                        this.sessionManager.unbindSession(session.id).catch(() => { });
-                    }
                 }
                 await this.sessionManager.recordSuccess(session.id);
                 this.eventBus.publish({
@@ -953,7 +1101,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 { }
@@ -976,21 +1124,23 @@ export class MessageProcessor {
             ? { replyContext: message.replyContext }
             : undefined;
         const projectPath = this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd();
-        // --session silent 触发器：新建独立 autonomous 会话，与原会话历史隔离
-        if (message.triggerMeta?.silent) {
-            const prevActive = await this.sessionManager.getActiveSession(message.channel, message.channelId);
-            const session = await this.sessionManager.createNewSession(message.channel, message.channelId, projectPath, `trigger-${message.triggerMeta.triggerId.slice(0, 8)}`);
-            await this.sessionManager.updateSession(session.id, { sessionMode: 'autonomous' });
-            session.sessionMode = 'autonomous';
-            if (prevActive) {
-                await this.sessionManager.switchToSession(message.channel, message.channelId, prevActive.id);
+        // current strategy: resume bound session, make it active so output is not suppressed
+        if (message.triggerMeta?.boundSessionId) {
+            const bound = await this.sessionManager.getSessionById(message.triggerMeta.boundSessionId);
+            if (bound) {
+                const switched = await this.sessionManager.switchToSession(bound.channel, bound.channelId, bound.id);
+                if (switched) {
+                    const absoluteProjectPath = path.isAbsolute(switched.projectPath)
+                        ? switched.projectPath : path.resolve(process.cwd(), switched.projectPath);
+                    return { session: switched, absoluteProjectPath };
+                }
+                logger.warn(`[MessageProcessor] switchToSession failed for bound session ${bound.id}, falling back to latest`);
+            }
+            else {
+                logger.warn(`[MessageProcessor] Bound session ${message.triggerMeta.boundSessionId} not found, falling back to latest`);
             }
-            const absoluteProjectPath = path.isAbsolute(session.projectPath)
-                ? session.projectPath
-                : 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`);
@@ -1004,6 +1154,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
@@ -1018,7 +1175,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 };
@@ -1100,7 +1257,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');
                         }
                     }
                     // 子任务进度
@@ -1178,14 +1335,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, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage };
                         // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
                         // 由那里按 LLM 输出的每个 text item 单独写一条，此处不再写。
                         // 失败且无前置错误输出：显示 errors 摘要
@@ -1213,6 +1371,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;
                 }
@@ -1232,7 +1399,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, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',
@@ -1345,85 +1512,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;