evolclaw 2.3.0 → 2.5.0

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

@@ -78,7 +78,8 @@ export class MessageBridge {
                 // 3. session 解析（使用 Channel 层填充的 chatType）
                 const chatType = msg.chatType || 'private';
                 const metadata = {};
-                if (msg.replyContext)
+                // 话题会话创建时写入 replyContext（用于 threadId 路由）；主会话不写（避免群聊覆盖）
+                if (msg.threadId && msg.replyContext)
                     metadata.replyContext = msg.replyContext;
                 // 写入实例名（审计 + 精确出站路由）
                 metadata.channelName = channelName;
@@ -101,6 +102,7 @@ export class MessageBridge {
                     chatType,
                     images: msg.images, timestamp: Date.now(),
                     peerId: msg.peerId, peerName: msg.peerName,
+                    peerType: msg.peerType,
                     messageId: msg.messageId,
                     mentions: msg.mentions, threadId: msg.threadId,
                     replyContext: msg.replyContext,
@@ -150,8 +152,7 @@ export class MessageBridge {
             return false;
         if (parsed.type === 'menu.query') {
             const identity = this.sessionManager.resolveIdentity(channel, msg.peerId);
-            const isAdmin = identity.role === 'owner';
-            const items = this.cmdHandler.getMenuItems(isAdmin);
+            const items = this.cmdHandler.getMenuItems(identity.role, msg.chatType || 'private');
             const response = JSON.stringify({ type: 'menu.response', items });
             if (adapter?.sendCustomPayload) {
                 adapter.sendCustomPayload(msg.channelId, response);
@@ -195,8 +196,8 @@ export class MessageBridge {
         return true;
     }
     /**
-     * 撤回消息：先查 debounce 窗口，再查 message queue。
-     * @returns true 如果找到并取消
+     * 撤回消息：先查 debounce 窗口，再查 message queue，最后查正在执行的任务。
+     * @returns true 如果找到并取消/中断
      */
     cancel(messageId) {
         // 阶段 1: debounce 窗口（尚未入队）
@@ -205,7 +206,10 @@ export class MessageBridge {
                 return true;
         }
         // 阶段 2: 已入队但未处理（合并后 messageId 可能是逗号分隔的多个 id）
-        return this.messageQueue.cancel(messageId);
+        if (this.messageQueue.cancel(messageId))
+            return true;
+        // 阶段 3: 正在执行的任务 → 触发 interrupt
+        return this.messageQueue.cancelActive(messageId);
     }
     /** 清理资源 */
     dispose() {

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

@@ -7,6 +7,7 @@ import { logger } from '../../utils/logger.js';
 import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError } from '../../utils/error-utils.js';
 import { summarizeToolInput } from '../permission.js';
 import { getOwner } from '../../config.js';
+import { getPackageRoot, resolveRoot } from '../../paths.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -25,6 +26,9 @@ export class MessageProcessor {
     defaultAgentId;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
     interactionRouter;
+    messageQueue;
+    skillsHintDesc = undefined; // undefined=未加载, null=无模板, string=缓存描述
+    skillsEnsured = false; // 全局 SKILLS.md 是否已确保
     /** 按 agentId 获取 agent，回退到默认 */
     getAgent(agentId) {
         if (agentId && this.agentMap.has(agentId))
@@ -67,6 +71,9 @@ export class MessageProcessor {
     setInteractionRouter(router) {
         this.interactionRouter = router;
     }
+    setMessageQueue(queue) {
+        this.messageQueue = queue;
+    }
     /**
      * 注册渠道适配器
      */
@@ -149,7 +156,6 @@ export class MessageProcessor {
         // 按 session.agentId 选择 agent 后端
         const agent = this.getAgent(session.agentId);
         const monitorEnabled = this.config.idleMonitor?.enabled !== false;
-        const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
         const showIdleMonitor = policy.showIdleMonitor(chatType, identityRole);
         // 计算是否抑制中间输出（工具活动 + 流式文本）
         const shouldSuppress = () => {
@@ -181,7 +187,7 @@ export class MessageProcessor {
                             const msg = showIdleMonitor
                                 ? result.message
                                 : `\u26a0\ufe0f 任务超时（${result.idleSec}秒无响应），已自动中断`;
-                            channelInfo.adapter.sendText(message.channelId, msg, this.getReplyContext(session)).catch(e => {
+                            channelInfo.adapter.sendText(message.channelId, msg, this.getReplyContext(message)).catch(e => {
                                 logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
                             });
                         }
@@ -196,7 +202,7 @@ export class MessageProcessor {
                         logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
                         if (channelInfo && showIdleMonitor && !shouldSuppress()) {
                             if (!isBackground) {
-                                channelInfo.adapter.sendText(message.channelId, result.message, this.getReplyContext(session)).catch(e => {
+                                channelInfo.adapter.sendText(message.channelId, result.message, this.getReplyContext(message)).catch(e => {
                                     logger.debug(`[MessageProcessor] Failed to send idle monitor message:`, e);
                                 });
                             }
@@ -219,25 +225,24 @@ export class MessageProcessor {
             if (channelInfo) {
                 try {
                     const errorType = classifyError(error);
-                    // 上下文过长是可恢复错误，不累计触发安全模式
+                    // 上下文过长是可恢复错误，不累计错误计数
                     if (errorType === ErrorType.CONTEXT_TOO_LONG) {
-                        logger.info(`[MessageProcessor] Context too long error, skipping safe mode accumulation`);
-                        // 认证错误（401 / Invalid API Key）不是会话问题，安全模式无法修复，不累计
+                        logger.info(`[MessageProcessor] Context too long error, skipping error accumulation`);
+                        // 认证错误（401 / Invalid API Key）不是会话问题，不累计
                     }
                     else if (errorType === ErrorType.AUTH_ERROR) {
-                        logger.info(`[MessageProcessor] Auth error (invalid API key), skipping safe mode accumulation`);
-                        // API 错误（5xx / 算力池切换等）是平台暂时性问题，安全模式无法修复，不累计
+                        logger.info(`[MessageProcessor] Auth error (invalid API key), skipping error accumulation`);
+                        // API 错误（5xx / 算力池切换等）是平台暂时性问题，不累计
                     }
                     else if (errorType === ErrorType.API_ERROR) {
-                        logger.info(`[MessageProcessor] API error, skipping safe mode accumulation`);
+                        logger.info(`[MessageProcessor] API error, skipping error accumulation`);
                     }
                     else if (!policy.accumulateErrors(chatType, identityRole)) {
-                        logger.info(`[MessageProcessor] Non-accumulating error (chatType=${chatType}, identity=${identityRole}), skipping safe mode accumulation`);
+                        logger.info(`[MessageProcessor] Non-accumulating error (chatType=${chatType}, identity=${identityRole}), skipping error accumulation`);
                     }
                     else {
                         const prefixed = prefixErrorType(ERROR_PREFIX.INFRA, errorType);
-                        const newCount = await this.sessionManager.recordError(session.id, prefixed, error.message);
-                        await this.checkSafeMode(session, message.channelId, channelInfo.adapter, safeModeThreshold, newCount);
+                        await this.sessionManager.recordError(session.id, prefixed, error.message);
                     }
                 }
                 catch (statusError) {
@@ -251,39 +256,11 @@ export class MessageProcessor {
                 clearInterval(monitorInterval);
         }
     }
-    /** 从 session 提取渠道预构建的回复上下文 */
-    getReplyContext(session) {
-        return session.metadata?.replyContext;
-    }
-    /**
-     * 检查是否需要进入安全模式（safeModeThreshold 为 0 时跳过）
-     */
-    async checkSafeMode(session, channelId, adapter, safeModeThreshold, consecutiveErrors) {
-        if (safeModeThreshold <= 0)
-            return;
-        const health = await this.sessionManager.getHealthStatus(session.id);
-        const sendOpts = this.getReplyContext(session);
-        const isThread = !!session.threadId;
-        if (consecutiveErrors >= safeModeThreshold && !health.safeMode) {
-            await this.sessionManager.setSafeMode(session.id, true);
-            logger.warn(`[MessageProcessor] Session ${session.id} entered safe mode after ${consecutiveErrors} errors`);
-            this.eventBus.publish({ type: 'session:safe-mode-entered', sessionId: session.id, consecutiveErrors });
-            const suggestions = isThread
-                ? `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /clear - 清空会话历史\n3. /status - 查看详细状态`
-                : `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /new [名称] - 创建新会话（清空历史）\n3. /status - 查看详细状态`;
-            await adapter.sendText(channelId, `\u26a0\ufe0f 安全模式已启用（连续 ${consecutiveErrors} 次异常）
-
-当前限制：
-- 无法记住之前的对话
-- 每次提问需要提供完整上下文
-
-建议操作：
-${suggestions}`, sendOpts);
-        }
-        else if (safeModeThreshold >= 2 && consecutiveErrors === safeModeThreshold - 1) {
-            await adapter.sendText(channelId, `\u26a0\ufe0f 检测到异常（${consecutiveErrors}/${safeModeThreshold}）\n\n如果问题持续，系统将自动进入安全模式。建议使用 /status 查看状态。`, sendOpts);
-        }
+    /** 获取回复上下文（跟着任务走） */
+    getReplyContext(message) {
+        return message.replyContext;
     }
+    /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
     async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelName || message.channel;
@@ -324,7 +301,7 @@ ${suggestions}`, sendOpts);
             logger.info(`[${message.channel}] ${message.channelId}: ${message.content}${imageInfo}${modeInfo}`);
             // 记录开始处理
             this.eventBus.publish({ type: 'message:processing', sessionId: session.id });
-            adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, this.getReplyContext(session));
+            adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, this.getReplyContext(message));
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
@@ -341,8 +318,8 @@ ${suggestions}`, sendOpts);
                     const opts = {};
                     if (isFinal)
                         opts.title = '\u2713 \u6700\u7ec8\u56de\u590d:';
-                    // 话题会话：使用 Channel 预构建的 replyContext（确保消息进入话题）
-                    const replyCtx = session.metadata?.replyContext;
+                    // replyContext 跟着任务走：优先用当前 message 的，兜底用 session 的（话题会话创建时写入）
+                    const replyCtx = this.getReplyContext(message);
                     if (replyCtx) {
                         Object.assign(opts, replyCtx);
                     }
@@ -362,17 +339,25 @@ ${suggestions}`, sendOpts);
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
             // 设置权限审批的消息发送回调（指向当前渠道）
             agent.setSendPrompt(async (text) => {
-                await adapter.sendText(message.channelId, text, this.getReplyContext(session));
+                await adapter.sendText(message.channelId, text, this.getReplyContext(message));
             });
             // 设置权限审批的交互上下文（支持交互卡片）
-            agent.setPermissionContext?.({
+            agent.setPermissionContext?.(session.id, {
                 adapter,
                 channelId: message.channelId,
-                replyContext: this.getReplyContext(session),
+                replyContext: this.getReplyContext(message),
                 interactionRouter: this.interactionRouter,
+                interceptNextMessage: this.messageQueue
+                    ? (sessionKey, handler) => this.messageQueue.interceptNext(sessionKey, handler)
+                    : undefined,
+                cancelIntercept: this.messageQueue
+                    ? (sessionKey) => this.messageQueue.cancelIntercept(sessionKey)
+                    : undefined,
             });
-            // 设置 per-session 权限模式
-            agent.setMode(session.metadata?.permissionMode ?? 'bypass');
+            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → readonly）
+            const role = session.identity?.role;
+            const defaultPermMode = role === 'owner' ? 'bypass' : role === 'admin' ? 'auto' : 'readonly';
+            agent.setMode(session.metadata?.permissionMode ?? defaultPermMode);
             // 标记会话为处理中（实时持久化，重启后可恢复）
             this.sessionManager.markProcessing(session.id);
             // 检查是否因新消息自动中断 — 包装 prompt 让 Agent 知道上下文
@@ -389,6 +374,7 @@ ${suggestions}`, sendOpts);
                 // 1. 当前环境信息
                 const peerLabel = session.identity?.role || 'unknown';
                 const peerName = message.peerName || session.metadata?.peerName;
+                const peerType = message.peerType;
                 const envParts = [
                     `会话通道: ${currentChannelType}`,
                     `当前项目: ${path.basename(absoluteProjectPath)}`,
@@ -398,6 +384,8 @@ ${suggestions}`, sendOpts);
                 envParts.push(`对端身份: ${peerLabel}`);
                 if (peerName)
                     envParts.push(`对端名称: ${peerName}`);
+                if (peerType && peerType !== 'unknown')
+                    envParts.push(`对端类型: ${peerType}`);
                 if (session.chatType)
                     envParts.push(`聊天类型: ${session.chatType}`);
                 if (session.agentId && session.agentId !== 'claude')
@@ -435,6 +423,19 @@ ${suggestions}`, sendOpts);
                 if (capParts.length > 0) {
                     contextParts.push(`[通道能力] ${capParts.join('、')}`);
                 }
+                // 4. 群聊 @ 规则：告知 agent 应该 @ 谁，由 agent 自行在回复中添加
+                if (message.chatType === 'group' && message.peerId) {
+                    contextParts.push(`[群聊回复规则] 回复时必须在开头添加 @${message.peerId} 来通知对方`);
+                }
+                // 5. Agent ctl 自管理指令提示 + SKILLS.md 生成
+                if (!this.skillsEnsured) {
+                    this.ensureSkillsFile();
+                    this.skillsEnsured = true;
+                }
+                const skillsHint = this.getSkillsHint();
+                if (skillsHint) {
+                    contextParts.push(`[EvolClaw 自管理] ${skillsHint}`);
+                }
                 const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
                 const MAX_RETRIES = 3;
@@ -515,22 +516,22 @@ ${suggestions}`, sendOpts);
                     && targetSpec !== currentChannelType;
                 // 跨通道仅限 owner
                 if (isCrossChannel && session.identity?.role !== 'owner') {
-                    await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, this.getReplyContext(message));
                     continue;
                 }
                 const resolvedPath = this.resolveFilePath(filePath, absoluteProjectPath);
                 if (!fs.existsSync(resolvedPath)) {
                     logger.warn(`[${adapter.channelName}] File not found: ${resolvedPath}`);
-                    await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, this.getReplyContext(message));
                     continue;
                 }
                 // 找目标 adapter
                 if (!targetInfo) {
-                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, this.getReplyContext(message));
                     continue;
                 }
                 if (!targetInfo.adapter.sendFile) {
-                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, this.getReplyContext(message));
                     continue;
                 }
                 // 找目标 channelId
@@ -541,21 +542,21 @@ ${suggestions}`, sendOpts);
                     const ownerPeerId = getOwner(this.config, targetAdapterName);
                     targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelType, ownerPeerId) ?? '') : '';
                     if (!targetChannelId) {
-                        await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, this.getReplyContext(session));
+                        await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, this.getReplyContext(message));
                         continue;
                     }
                 }
                 logger.info(`[${adapter.channelName}] Sending file via ${targetInfo.adapter.channelName}: ${resolvedPath}`);
                 try {
-                    await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, this.getReplyContext(session));
+                    await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, this.getReplyContext(message));
                     this.eventBus.publish({ type: 'agent:file-sent', sessionId: session.id, filePath: resolvedPath, channel: targetInfo.adapter.channelName });
                     if (isCrossChannel) {
-                        await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, this.getReplyContext(session));
+                        await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, this.getReplyContext(message));
                     }
                 }
                 catch (error) {
                     logger.error(`[${adapter.channelName}] Failed to send file: ${resolvedPath}`, error);
-                    await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, this.getReplyContext(session));
+                    await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, this.getReplyContext(message));
                 }
             }
             // 最终回复文本添加到 flusher（统一在流结束后处理，避免多 complete 事件重复发送）
@@ -574,14 +575,6 @@ ${suggestions}`, sendOpts);
             }
             // Flush 剩余内容（文件标记已在 flush 时自动移除）
             await flusher.flush(true);
-            // 安全模式尾部提示：如果当前会话处于安全模式，追加提醒
-            const healthStatus = await this.sessionManager.getHealthStatus(session.id);
-            if (healthStatus.safeMode) {
-                const hint = session.threadId
-                    ? '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /clear 清空会话'
-                    : '\n\n\u26a0\ufe0f 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话';
-                await adapter.sendText(message.channelId, hint, this.getReplyContext(session));
-            }
             // 清理 activeStreams（正常完成）
             agent.cleanupStream(streamKey);
             // 清除处理中状态
@@ -593,7 +586,7 @@ ${suggestions}`, sendOpts);
                 const errorSummary = streamResult.errors?.join('; ') || '任务执行失败';
                 const rawSubtype = streamResult.subtype || 'agent_error';
                 const errorType = prefixErrorType(ERROR_PREFIX.AGENT, rawSubtype);
-                adapter.sendProcessingStatus?.(message.channelId, 'error', session.id, this.getReplyContext(session));
+                adapter.sendProcessingStatus?.(message.channelId, 'error', session.id, this.getReplyContext(message));
                 this.eventBus.publish({
                     type: 'message:error',
                     sessionId: session.id,
@@ -601,15 +594,13 @@ ${suggestions}`, sendOpts);
                     errorType,
                     terminalReason: streamResult.terminalReason
                 });
-                // 仅系统级 subtype 累计安全模式（权限拒绝、max turns 等用户操作不累计）
+                // 系统级 subtype 仍累计错误计数，供 /status 诊断使用
                 if (isInfraError(rawSubtype, streamResult.terminalReason)) {
                     const chatType = message.chatType || 'private';
                     const identityRole = session.identity?.role || 'anonymous';
-                    const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
                     const { policy } = channelInfo;
                     if (policy.accumulateErrors(chatType, identityRole)) {
-                        const newCount = await this.sessionManager.recordError(session.id, errorType, errorSummary);
-                        await this.checkSafeMode(session, message.channelId, adapter, safeModeThreshold, newCount);
+                        await this.sessionManager.recordError(session.id, errorType, errorSummary);
                     }
                 }
                 logger.message({
@@ -623,7 +614,7 @@ ${suggestions}`, sendOpts);
             }
             else {
                 // 真正的成功
-                adapter.sendProcessingStatus?.(message.channelId, interruptReason ? 'interrupted' : 'done', session.id, this.getReplyContext(session));
+                adapter.sendProcessingStatus?.(message.channelId, interruptReason ? 'interrupted' : 'done', session.id, this.getReplyContext(message));
                 await this.sessionManager.recordSuccess(session.id);
                 this.eventBus.publish({
                     type: 'message:completed',
@@ -676,7 +667,7 @@ ${suggestions}`, sendOpts);
             // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送中断/错误提示
             if (!isUserInterrupt) {
                 try {
-                    adapter.sendProcessingStatus?.(message.channelId, procStatus, session.id, this.getReplyContext(session));
+                    adapter.sendProcessingStatus?.(message.channelId, procStatus, session.id, this.getReplyContext(message));
                 }
                 catch { }
             }
@@ -724,7 +715,7 @@ ${suggestions}`, sendOpts);
                 let sendOpts;
                 try {
                     const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
-                    sendOpts = this.getReplyContext(session);
+                    sendOpts = this.getReplyContext(message);
                 }
                 catch { }
                 await adapter.sendText(message.channelId, userMessage, sendOpts);
@@ -735,11 +726,12 @@ ${suggestions}`, sendOpts);
      * 解析会话和项目路径
      */
     async resolveSession(message) {
-        // 话题会话：使用 Channel 预构建的 replyContext
-        const metadata = message.replyContext
+        // 话题会话创建时写入 replyContext（threadId 路由）；主会话不写（避免群聊覆盖）
+        const metadata = (message.threadId && message.replyContext)
             ? { replyContext: message.replyContext }
             : undefined;
         const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId, metadata, undefined, message.peerId);
+        // replyContext 不再写入 session.metadata（跟着 message 走，避免群聊多人覆盖）
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
             : path.resolve(process.cwd(), session.projectPath);
@@ -953,9 +945,22 @@ ${suggestions}`, sendOpts);
         }
         catch (error) {
             // User interrupt (AbortError) is expected, log at info level
+            const catchInterruptReason = this.interruptedSessions.get(session.id);
+            const catchIsUserInterrupt = catchInterruptReason === 'new_message' || catchInterruptReason === 'stop';
             if (error instanceof Error && error.name === 'AbortError') {
                 logger.info('[MessageProcessor] Stream interrupted (AbortError)');
             }
+            else if (catchIsUserInterrupt) {
+                // SDK telemetry noise after user-initiated interrupt — not a real error
+                logger.debug('[MessageProcessor] Stream ended after user interrupt:', error?.message?.split('\n')[0]);
+                completeResult.isError = false;
+                completeResult.hasReceivedText = hasReceivedText;
+                return completeResult;
+            }
+            else if (isRetryableError(error)) {
+                // Retryable errors (network aborts, transient API failures) are noise at ERROR level
+                logger.warn('[MessageProcessor] Stream processing error (retryable):', error?.message?.split('\n')[0]);
+            }
             else {
                 logger.error('[MessageProcessor] Stream processing error:', error);
             }
@@ -999,6 +1004,99 @@ ${suggestions}`, sendOpts);
         // 都找不到，返回项目根目录路径
         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;
+    }
+    /**
+     * 从模板 frontmatter 缓存提示（懒加载，整个进程只读一次模板文件）
+     */
+    getSkillsHint() {
+        if (this.skillsHintDesc === undefined) {
+            this.skillsHintDesc = this.loadSkillsHint();
+        }
+        return this.skillsHintDesc;
+    }
+    /**
+     * 从包模板源读取 frontmatter 并生成提示（仅执行一次）
+     */
+    loadSkillsHint() {
+        try {
+            const candidates = [
+                path.join(getPackageRoot(), 'src', 'templates', 'skills.md'),
+                path.join(getPackageRoot(), 'dist', 'templates', 'skills.md'),
+            ];
+            for (const templatePath of candidates) {
+                if (!fs.existsSync(templatePath))
+                    continue;
+                const content = fs.readFileSync(templatePath, 'utf-8');
+                const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+                if (!frontmatterMatch)
+                    continue;
+                const fm = frontmatterMatch[1];
+                const desc = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() || 'EvolClaw 运行时管理指令';
+                const trigger = fm.match(/^trigger:\s*(.+)$/m)?.[1]?.trim() || '';
+                const skillsPath = path.join(resolveRoot(), 'data', 'SKILLS.md');
+                const parts = [
+                    `可通过 Bash 执行 \`evolclaw ctl <cmd>\` 管理运行时：${desc}`,
+                    trigger ? `触发时机：${trigger}` : '',
+                    `完整文档见 ${skillsPath}`,
+                ];
+                return parts.filter(Boolean).join('\n');
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * 判断文件路径是否为占位符/示例文本
      * 用于过滤大模型在说明文字中误写的 [SEND_FILE:...] 标记

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

@@ -8,10 +8,12 @@ export class MessageQueue {
     currentSessionKey;
     currentProjectPath;
     currentAgentId;
+    activeMessageIds = new Set(); // 正在执行的消息 ID
     interruptCallback;
     eventBus;
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
+    interceptors = new Map();
     constructor(handler) {
         this.handler = handler;
     }
@@ -21,6 +23,19 @@ export class MessageQueue {
     setEventBus(eventBus) {
         this.eventBus = eventBus;
     }
+    /**
+     * 注册一次性消息拦截器：下一条来自 sessionKey 的消息不入队、不触发 interrupt，
+     * 直接传给 handler。用于 AskUserQuestion 的"手动输入"场景。
+     */
+    interceptNext(sessionKey, handler) {
+        this.interceptors.set(sessionKey, handler);
+    }
+    /**
+     * 取消拦截器（超时或卡片被其他方式回答时调用）
+     */
+    cancelIntercept(sessionKey) {
+        this.interceptors.delete(sessionKey);
+    }
     /**
      * 检查消息是否应该处理（去重）
      */
@@ -53,6 +68,14 @@ export class MessageQueue {
         if (!this.shouldProcess(message)) {
             return Promise.resolve();
         }
+        // 拦截器检查：AskUserQuestion 等场景的一次性消息拦截
+        const interceptor = this.interceptors.get(sessionKey);
+        if (interceptor) {
+            this.interceptors.delete(sessionKey);
+            logger.debug(`[Queue] Message intercepted for ${sessionKey}`);
+            interceptor(message);
+            return Promise.resolve();
+        }
         const queueKey = this.getQueueKey(sessionKey, projectPath);
         logger.debug(`[Queue] Enqueuing message for ${queueKey}`);
         return new Promise((resolve, reject) => {
@@ -97,6 +120,7 @@ export class MessageQueue {
                 this.processing.delete(queueKey);
                 this.currentSessionKey = undefined;
                 this.currentProjectPath = undefined;
+                this.activeMessageIds.clear();
                 return;
             }
             // FIFO 贪心合并：弹出队首连续同 peerId 的消息
@@ -105,6 +129,12 @@ export class MessageQueue {
             this.currentSessionKey = queueKey;
             this.currentProjectPath = merged.projectPath;
             this.currentAgentId = merged.message.agentId;
+            // 记录正在执行的 messageId（用于撤回中断）
+            this.activeMessageIds.clear();
+            for (const item of items) {
+                if (item.message.messageId)
+                    this.activeMessageIds.add(item.message.messageId);
+            }
             const resolves = items.map(i => i.resolve);
             const rejects = items.map(i => i.reject);
             logger.debug(`[Queue] Processing ${items.length} message(s) from ${merged.message.channel}:${merged.message.channelId}`);
@@ -200,6 +230,24 @@ export class MessageQueue {
         }
         return false;
     }
+    /**
+     * 撤回正在执行的消息：如果 messageId 正在处理中，触发 interrupt。
+     * @returns true 如果找到并触发了中断
+     */
+    cancelActive(messageId) {
+        if (!this.activeMessageIds.has(messageId))
+            return false;
+        if (!this.currentSessionKey)
+            return false;
+        // 从 queueKey 提取 sessionKey
+        const sessionKey = this.currentSessionKey.split('::')[0];
+        logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
+        this.eventBus?.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'recalled' });
+        if (this.interruptCallback) {
+            this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
+        }
+        return true;
+    }
     /**
      * 外部锁：快速命令（/compact, /clear）执行期间阻塞队列处理
      * 返回 release 函数

package/dist/core/message/stream-flusher.js

@@ -161,13 +161,13 @@ export class StreamFlusher {
         if (this.diagEnabled)
             diag(this.instanceId, 'flushActivitiesOnly', { outputLen: output.length });
         if (output) {
+            this.sentContent = true; // 同步标记，避免 timer flush 未 await 时的竞态
             const text = output;
             // chain 保持不断裂：单条失败不阻塞后续（catch → resolve）
             this.sendChain = this.sendChain
                 .then(() => this.send(text, false, false))
                 .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
             await this.sendChain;
-            this.sentContent = true;
             this.lastFlush = Date.now();
             this.flushCount++;
         }
@@ -207,6 +207,7 @@ export class StreamFlusher {
         if (this.diagEnabled)
             diag(this.instanceId, 'flush', { isFinal, outputLen: output.length, flushCount: this.flushCount, sinceLastFlush: Date.now() - this.lastFlush, preview: output.substring(0, 80) });
         if (output) {
+            this.sentContent = true; // 同步标记，避免 timer flush 未 await 时的竞态
             const text = output;
             const final = isFinal;
             const ht = hasText;
@@ -214,7 +215,6 @@ export class StreamFlusher {
                 .then(() => this.send(text, final, ht))
                 .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
             await this.sendChain;
-            this.sentContent = true;
             this.lastFlush = Date.now();
             this.flushCount++;
         }