evolclaw 3.1.4 → 3.1.5

package/dist/core/interaction-router.js

@@ -1,14 +1,55 @@
 import { logger } from '../utils/logger.js';
 export class InteractionRouter {
     handlers = new Map();
+    /** sessionId → 该会话当前待应答的交互数量，用于触发 wait 生命周期钩子 */
+    pendingBySession = new Map();
+    waitHooks;
+    setWaitHooks(hooks) {
+        this.waitHooks = hooks;
+    }
+    /**
+     * 在 register() 之前提前标记 session 为等待状态（适用于发卡片有异步延迟的场景）。
+     * 必须与 unmarkWaiting() 配对使用，或后续 register() 会接管计数。
+     */
+    markWaiting(sessionId) {
+        this.incPending(sessionId);
+    }
+    /** 取消 markWaiting() 的占位（后续若有 register() 接管则不需调用此方法） */
+    unmarkWaiting(sessionId) {
+        this.decPending(sessionId);
+    }
+    /** 登记一个待应答交互；session 计数 0→1 时触发 onWaitStart */
+    incPending(sessionId) {
+        const next = (this.pendingBySession.get(sessionId) ?? 0) + 1;
+        this.pendingBySession.set(sessionId, next);
+        if (next === 1)
+            this.waitHooks?.onWaitStart(sessionId);
+    }
+    /** 注销一个待应答交互；session 计数 1→0 时触发 onWaitEnd */
+    decPending(sessionId) {
+        const cur = this.pendingBySession.get(sessionId) ?? 0;
+        if (cur <= 0)
+            return;
+        const next = cur - 1;
+        if (next === 0) {
+            this.pendingBySession.delete(sessionId);
+            this.waitHooks?.onWaitEnd(sessionId);
+        }
+        else {
+            this.pendingBySession.set(sessionId, next);
+        }
+    }
     register(id, sessionId, callback, opts) {
+        // 同 id 替换：槽位本就占用，计数不变，不触发 wait 钩子
         const existing = this.handlers.get(id);
         if (existing?.timer)
             clearTimeout(existing.timer);
+        const isReplacement = !!existing;
         let timer;
         if (opts?.timeoutMs && opts.timeoutMs > 0) {
             timer = setTimeout(() => {
                 this.handlers.delete(id);
+                this.decPending(sessionId);
                 logger.debug(`[InteractionRouter] Timeout for interaction: ${id}`);
                 opts.onTimeout?.();
             }, opts.timeoutMs);
@@ -20,6 +61,8 @@ export class InteractionRouter {
             initiatorId: opts?.initiatorId,
             fallbackCommand: opts?.fallbackCommand,
         });
+        if (!isReplacement)
+            this.incPending(sessionId);
     }
     handle(response) {
         const handler = this.handlers.get(response.id);
@@ -28,6 +71,7 @@ export class InteractionRouter {
         if (handler.timer)
             clearTimeout(handler.timer);
         this.handlers.delete(response.id);
+        this.decPending(handler.sessionId);
         try {
             const result = handler.callback(response.action, response.values, response.operatorId);
             if (result && typeof result.catch === 'function') {
@@ -47,6 +91,7 @@ export class InteractionRouter {
                 if (handler.timer)
                     clearTimeout(handler.timer);
                 this.handlers.delete(id);
+                this.decPending(handler.sessionId);
             }
         }
     }
@@ -56,6 +101,7 @@ export class InteractionRouter {
             if (handler.timer)
                 clearTimeout(handler.timer);
             this.handlers.delete(id);
+            this.decPending(handler.sessionId);
         }
     }
     getPending(sessionId) {
@@ -100,6 +146,16 @@ export function renderActionAsText(req) {
     const lines = [action.title];
     if (action.body)
         lines.push(action.body);
+    // checkers 多选：渲染选项列表
+    if (action.checkers?.length) {
+        lines.push('');
+        action.checkers.forEach((chk, idx) => {
+            const desc = chk.description ? ` — ${chk.description}` : '';
+            lines.push(`  ${idx + 1}. ${chk.label}${desc}`);
+        });
+        lines.push('', '回复选项编号（多选用逗号分隔），或输入自定义内容');
+        return lines.join('\n');
+    }
     if (!fb) {
         return lines.join('\n');
     }
@@ -111,5 +167,8 @@ export function renderActionAsText(req) {
     if (fb.acceptFreeText && fb.freeTextHint) {
         lines.push(`  ${fb.freeTextHint}`);
     }
+    if (action.allowCustomInput) {
+        lines.push(`  或直接输入自定义内容`);
+    }
     return lines.join('\n');
 }

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

@@ -81,12 +81,12 @@ export class MessageBridge {
                     logger.debug(`[MessageBridge] Command detected: "${cmdContent}", routing to handler`);
                     // 命令也要记录入方向 jsonl（不创建 session，直接用 chatDirPath 计算路径）
                     try {
-                        const chatDir = chatDirPath(resolvePaths().sessionsDir, msg.channelType || effectiveChannelType, msg.channelId, msg.selfId);
+                        const chatDir = chatDirPath(resolvePaths().sessionsDir, msg.channelType || effectiveChannelType, msg.channelId, msg.selfAID || '');
                         const inboundEncrypt = msg.replyContext?.metadata?.encrypted != null ? !!(msg.replyContext.metadata.encrypted) : undefined;
                         const inboundChatmode = msg.replyContext?.metadata?.chatmode;
                         appendMessageLog(chatDir, buildInboundEntry({
                             from: msg.peerId || 'unknown',
-                            to: msg.selfId || 'self',
+                            to: msg.selfAID || 'self',
                             chatType: msg.chatType || 'private',
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -114,7 +114,7 @@ export class MessageBridge {
                 if (msg.threadId && msg.replyContext)
                     metadata.replyContext = msg.replyContext;
                 // 写入实例名（审计 + 精确出站路由）
-                metadata.channelName = channelName;
+                metadata.channelKey = channelName;
                 if (chatType === 'private' && msg.peerId) {
                     metadata.peerId = msg.peerId;
                     if (msg.peerName)
@@ -134,7 +134,7 @@ export class MessageBridge {
                 const owningAgent = this.agentRegistry?.resolveByChannel(channelName);
                 const effectiveProjectPath = owningAgent?.projectPath
                     ?? this.defaultProjectPath;
-                const session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, undefined, msg.peerId, chatType, undefined, msg.selfId, msg.channelType || effectiveChannelType, msg.peerType);
+                const session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, undefined, msg.peerId, chatType, undefined, msg.selfAID, msg.channelType || effectiveChannelType, msg.peerType);
                 // 4. 消息前缀（由 policy 决定）
                 const channelInfo = this.processor.getChannelInfo?.(channelName);
                 if (channelInfo?.policy) {
@@ -147,7 +147,7 @@ export class MessageBridge {
                     channel: channelName,
                     channelType: msg.channelType || effectiveChannelType,
                     channelId: msg.channelId, content,
-                    selfId: msg.selfId,
+                    selfAID: msg.selfAID,
                     chatType,
                     images: msg.images, timestamp: Date.now(),
                     peerId: msg.peerId, peerName: msg.peerName,
@@ -162,7 +162,7 @@ export class MessageBridge {
                 const inboundChatmode = msg.replyContext?.metadata?.chatmode;
                 appendMessageLog(chatDir, buildInboundEntry({
                     from: msg.peerId || 'unknown',
-                    to: msg.selfId || 'self',
+                    to: msg.selfAID || 'self',
                     chatType,
                     groupId: msg.groupId ?? null,
                     msgId: msg.messageId ?? null,

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

@@ -31,8 +31,8 @@ function formatTimestampMs(epochMs) {
 export function messageLogPath(chatDir) {
     return path.join(chatDir, MESSAGE_LOG_FILE);
 }
-export function resolveChatDir(sessionsDir, channelType, channelId, selfId) {
-    return chatDirPath(sessionsDir, channelType, channelId, selfId);
+export function resolveChatDir(sessionsDir, channelType, channelId, selfAID) {
+    return chatDirPath(sessionsDir, channelType, channelId, selfAID);
 }
 export function appendMessageLog(chatDir, entry) {
     if (entry.dir === 'in' && isDuplicate(entry.msgId)) {

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.
      *
@@ -99,7 +102,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 +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;
@@ -211,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}`);
@@ -252,6 +265,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 +346,7 @@ export class MessageProcessor {
         finally {
             if (monitorInterval)
                 clearInterval(monitorInterval);
+            this.activeMonitors.delete(streamKey);
         }
     }
     /** 获取回复上下文（跟着任务走） */
@@ -341,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>';
@@ -448,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;
@@ -508,6 +523,7 @@ export class MessageProcessor {
                 : message.content;
             let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
             let effectiveSystemPrompt;
+            let modelOverride;
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
@@ -533,19 +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,
@@ -553,18 +591,24 @@ 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,
                         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,
                         threadId: session.threadId || undefined,
+                        // Stage 3: sessionKey 持久化字段
+                        sessionKey: session.sessionKey,
                         chatMode: isProactive ? 'proactive' : 'interactive',
                         readonly: session.metadata?.permissionMode === 'readonly',
                         baseAgent: normalizedBaseagent.canonical,
@@ -584,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);
@@ -613,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);
                     }
@@ -636,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 中可能混入的错误文本，显示友好提示
@@ -830,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) {
@@ -953,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 { }
@@ -990,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`);
@@ -1004,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
@@ -1018,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 };
@@ -1100,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');
                         }
                     }
                     // 子任务进度
@@ -1178,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 摘要
@@ -1213,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;
                 }
@@ -1232,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',
@@ -1345,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;