evolclaw 2.0.7 → 2.1.1

package/README.md

@@ -128,10 +128,10 @@ evolclaw init wechat
   },
   "idleMonitor": {
     "enabled": true,                            // 任务超时监控开关
-    "timeout": 120000,                          // 超时阈值（ms），默认 2 分钟
+    "timeout": 120,                             // 超时阈值（秒），默认 120 秒
     "safeModeThreshold": 3                      // 连续超时 N 次后进入安全模式（设为 0 禁用安全模式）
   },
-  "flushDelay": 4000                            // 工具活动消息聚合发送间隔（ms），默认 4 秒
+  "flushDelay": 4                               // 工具活动消息聚合发送间隔（秒），默认 4 秒
 }
 ```
 
@@ -139,6 +139,7 @@ evolclaw init wechat
 - `apiKey`：配置文件 → `ANTHROPIC_AUTH_TOKEN` 环境变量 → `~/.claude/settings.json`
 - `baseUrl`：配置文件 → `ANTHROPIC_BASE_URL` 环境变量 → `~/.claude/settings.json`
 - `model`：配置文件 → `~/.claude/settings.json` → 默认 `sonnet`
+- `effort`：配置文件 → `~/.claude/settings.json` → SDK 默认值（`auto`）
 
 ### 3. 运行
 
@@ -192,6 +193,7 @@ evolclaw/
 - `/slist` - 列出当前项目的所有会话
 - `/s <名称>` - 切换到指定会话
 - `/name <新名称>` - 重命名当前会话
+- `/del <名称>` - 删除指定会话（仅解绑，不删除文件）
 - `/status` - 显示会话状态
 - `/help` - 显示所有命令
 
@@ -212,8 +214,11 @@ evolclaw/
 - `/safe` - 进入安全模式
 
 **模型管理**：
-- `/model` - 显示当前模型和可用列表
-- `/model <model-id>` - 切换模型
+- `/model` - 显示当前模型和推理强度
+- `/model <model>` - 切换模型
+- `/model <effort>` - 切换推理强度（low / medium / high / max）
+- `/model <model> <effort>` - 同时切换模型和推理强度
+- `/model auto` - 恢复 SDK 默认推理强度
 
 ## 技术栈
 

package/data/evolclaw.sample.json

@@ -28,8 +28,9 @@
   },
   "idleMonitor": {
     "enabled": true,
-    "timeout": 120000,
+    "timeout": 120,
     "safeModeThreshold": 3
   },
-  "flushDelay": 4000
+  "flushDelay": 4,
+  "showActivities": "all"
 }

package/dist/channels/feishu.js

@@ -46,10 +46,6 @@ export class FeishuChannel {
                     const msg = data.message;
                     logger.debug('[Feishu] Received message, message_id:', msg.message_id, 'type:', msg.message_type);
                     logger.debug('[Feishu] Full data object:', JSON.stringify(data, null, 2));
-                    // 诊断：话题消息检测
-                    if (msg.thread_id) {
-                        logger.info('[Feishu] Thread message detected, thread_id:', msg.thread_id, 'parent_id:', msg.parent_id, 'root_id:', msg.root_id);
-                    }
                     if (!msg.message_id || this.isDuplicate(msg.message_id)) {
                         logger.debug('[Feishu] Duplicate message ignored:', msg.message_id);
                         return;
@@ -58,6 +54,10 @@ export class FeishuChannel {
                     this.addAckReaction(msg.message_id);
                     if (!this.messageHandler)
                         return;
+                    // 话题消息检测日志（去重后）
+                    if (msg.thread_id) {
+                        logger.info('[Feishu] Thread message, thread_id:', msg.thread_id, 'root_id:', msg.root_id);
+                    }
                     // 提取 @ 提及列表（排除机器人自身）
                     const mentions = (msg.mentions || []).map((m) => ({
                         userId: m.id?.open_id || '',
@@ -74,10 +74,15 @@ export class FeishuChannel {
                         userName = undefined;
                     }
                     try {
-                        // 处理引用消息
+                        // 提取话题信息
+                        const threadId = msg.thread_id || undefined;
+                        const rootId = msg.root_id || undefined;
+                        // 处理引用消息（话题内消息跳过，避免每条都拼接引用前缀）
                         let quotedText = '';
                         let quotedImages = [];
-                        if (msg.parent_id && this.client) {
+                        // 话题创建消息检测：DB 中无对应 thread session 时为首条消息
+                        const isThreadCreating = threadId && !this.hasThreadSession(threadId);
+                        if (msg.parent_id && (!msg.thread_id || isThreadCreating) && this.client) {
                             try {
                                 const res = await this.client.im.message.get({
                                     path: { message_id: msg.parent_id }
@@ -151,7 +156,7 @@ export class FeishuChannel {
                             // 优先使用 text_without_at_bot（去除机器人 @），否则使用 text
                             const content = parsed.text_without_at_bot || parsed.text;
                             const finalContent = quotedText + content;
-                            await this.messageHandler(msg.chat_id, finalContent, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id, mentions.length > 0 ? mentions : undefined);
+                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, mentions: mentions.length > 0 ? mentions : undefined, threadId, rootId });
                         }
                         // 处理图片消息
                         else if (msg.message_type === 'image') {
@@ -165,11 +170,11 @@ export class FeishuChannel {
                             if (imageData) {
                                 const allImages = [...quotedImages, imageData];
                                 const prompt = quotedText + '用户发送了一张图片，请分析这张图片的内容。';
-                                await this.messageHandler(msg.chat_id, prompt, allImages, userId, userName, msg.message_id);
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: allImages, userId, userName, messageId: msg.message_id, threadId, rootId });
                             }
                             else {
                                 const prompt = quotedText + '[图片下载失败] 应用可能缺少 im:message 或 im:message:readonly 权限';
-                                await this.messageHandler(msg.chat_id, prompt, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id);
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
                             }
                         }
                         // 处理文件消息
@@ -184,11 +189,11 @@ export class FeishuChannel {
                             const filePath = await this.downloadFile(fileKey, fileName, msg.message_id, projectPath);
                             if (filePath) {
                                 const prompt = quotedText + `用户发送了文件：${fileName}\n文件已保存到：${filePath}\n请使用 Read 工具读取并分析文件内容。`;
-                                await this.messageHandler(msg.chat_id, prompt, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id);
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
                             }
                             else {
                                 const prompt = quotedText + '[文件下载失败] 应用可能缺少 im:resource 权限';
-                                await this.messageHandler(msg.chat_id, prompt, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id);
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
                             }
                         }
                         // 处理富文本消息
@@ -210,20 +215,21 @@ export class FeishuChannel {
                             if (title)
                                 finalContent = `${title}\n${finalContent}`;
                             finalContent = quotedText + finalContent;
-                            await this.messageHandler(msg.chat_id, finalContent, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id);
+                            await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
                         }
                         // 处理其他类型消息
                         else {
                             logger.debug('[Feishu] Unsupported message type:', msg.message_type);
                             const prompt = quotedText + `[不支持的消息类型: ${msg.message_type}]`;
-                            await this.messageHandler(msg.chat_id, prompt, quotedImages.length > 0 ? quotedImages : undefined, userId, userName, msg.message_id);
+                            await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, userId, userName, messageId: msg.message_id, threadId, rootId });
                         }
                     }
                     catch (error) {
                         logger.error('[Feishu] Failed to process message:', error);
                     }
                 },
-                'im.message.message_read_v1': async () => { }
+                'im.message.message_read_v1': async () => { },
+                'im.message.reaction.created_v1': async () => { }
             });
             this.wsClient = new lark.WSClient({
                 appId: this.config.appId,
@@ -313,9 +319,13 @@ export class FeishuChannel {
                     : JSON.stringify({ text: content });
             }
             if (options?.replyToMessageId) {
+                const replyData = { msg_type: msgType, content: msgContent };
+                if (options.replyInThread) {
+                    replyData.reply_in_thread = true;
+                }
                 await this.client.im.message.reply({
                     path: { message_id: options.replyToMessageId },
-                    data: { msg_type: msgType, content: msgContent }
+                    data: replyData
                 });
             }
             else {
@@ -327,6 +337,11 @@ export class FeishuChannel {
             logger.debug(`[Feishu] Sent message as ${useMarkdown ? 'post (Markdown)' : 'text'}`);
         }
         catch (error) {
+            // 230011: 消息已被撤回，降级为普通消息重试
+            if (error.response?.data?.code === 230011 && options?.replyToMessageId) {
+                logger.warn('[Feishu] Message withdrawn (230011), retrying without reply');
+                return this.sendMessage(chatId, content, { ...options, replyToMessageId: undefined });
+            }
             logger.error('[Feishu] Failed to send message:', error);
             throw error;
         }
@@ -366,6 +381,15 @@ export class FeishuChannel {
             throw error;
         }
     }
+    hasThreadSession(threadId) {
+        try {
+            const row = this.db.prepare('SELECT 1 FROM sessions WHERE thread_id = ? LIMIT 1').get(threadId);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
     async disconnect() {
         if (this.cleanupInterval) {
             clearInterval(this.cleanupInterval);

package/dist/cli.js

@@ -537,8 +537,9 @@ async function cmdRestartMonitor() {
     for (let attempt = 1; attempt <= MAX_HEAL_ATTEMPTS; attempt++) {
         log(`Self-heal attempt ${attempt}/${MAX_HEAL_ATTEMPTS}`);
         await notifyChannel(p, pendingInfo, `🔧 自动修复中（第 ${attempt}/${MAX_HEAL_ATTEMPTS} 次）...`, log);
-        // 调用 claude CLI 修复
-        const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, log);
+        // 调用 claude CLI 修复（递增超时：3/4/5 分钟）
+        const timeout = (2 + attempt) * 60 * 1000;
+        const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, timeout, log);
         if (!healed) {
             log(`Self-heal attempt ${attempt} failed (claude invocation error)`);
             continue;
@@ -633,7 +634,7 @@ async function spawnAndWaitReady(p, log, timeout) {
 /**
  * 调用 claude CLI 进行自动修复
  */
-async function invokeClaude(p, attempt, maxAttempts, log) {
+async function invokeClaude(p, attempt, maxAttempts, timeout, log) {
     const projectDir = getPackageRoot();
     const selfHealLog = p.selfHealLog;
     const stdoutLog = path.join(p.logs, 'stdout.log');
@@ -659,26 +660,31 @@ async function invokeClaude(p, attempt, maxAttempts, log) {
 
 注意：只修复导致启动失败的问题，不要做额外的重构或优化。`;
     try {
-        log(`Invoking claude CLI (attempt ${attempt})...`);
+        log(`Invoking claude CLI (attempt ${attempt}, timeout ${timeout / 60000}min)...`);
         const { stdout, stderr } = await execFileAsync('claude', [
             '-p', prompt,
             '--allowedTools', 'Read,Write,Edit,Bash,Glob,Grep',
             '--output-format', 'text',
         ], {
             cwd: projectDir,
-            timeout: 5 * 60 * 1000, // 5 分钟超时
+            timeout,
             env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'cli' },
             maxBuffer: 10 * 1024 * 1024,
         });
         if (stdout)
             log(`Claude output: ${stdout.slice(0, 500)}`);
         if (stderr)
-            log(`Claude stderr: ${stderr.slice(0, 200)}`);
+            log(`Claude stderr: ${stderr.slice(0, 500)}`);
         log(`Claude CLI completed (attempt ${attempt})`);
         return true;
     }
     catch (error) {
-        log(`Claude CLI error: ${error.message?.slice(0, 300) || error}`);
+        const msg = error.message || String(error);
+        log(`Claude CLI error: ${msg.slice(0, 800)}`);
+        if (error.stdout)
+            log(`Stdout: ${String(error.stdout).slice(0, 500)}`);
+        if (error.stderr)
+            log(`Stderr: ${String(error.stderr).slice(0, 500)}`);
         return false;
     }
 }
@@ -713,14 +719,26 @@ async function notifyChannel(p, pendingInfo, message, log) {
                 appId: config.channels.feishu.appId,
                 appSecret: config.channels.feishu.appSecret,
             });
-            await client.im.message.create({
-                params: { receive_id_type: 'chat_id' },
-                data: {
-                    receive_id: pendingInfo.channelId,
-                    msg_type: 'text',
-                    content: JSON.stringify({ text: message }),
-                },
-            });
+            if (pendingInfo.rootId) {
+                await client.im.message.reply({
+                    path: { message_id: pendingInfo.rootId },
+                    data: {
+                        msg_type: 'text',
+                        content: JSON.stringify({ text: message }),
+                        reply_in_thread: true,
+                    },
+                });
+            }
+            else {
+                await client.im.message.create({
+                    params: { receive_id_type: 'chat_id' },
+                    data: {
+                        receive_id: pendingInfo.channelId,
+                        msg_type: 'text',
+                        content: JSON.stringify({ text: message }),
+                    },
+                });
+            }
             log(`Feishu notification sent: ${message.slice(0, 50)}`);
         }
         catch (error) {

package/dist/config.js

@@ -37,7 +37,10 @@ export function resolveAnthropicConfig(config) {
     const model = config.agents?.anthropic?.model
         || settings.model
         || 'sonnet';
-    return { apiKey, baseUrl, model };
+    const effort = config.agents?.anthropic?.effort
+        || settings.effortLevel
+        || undefined;
+    return { apiKey, baseUrl, model, effort };
 }
 export function loadConfig(configPath = resolvePaths().config) {
     if (!fs.existsSync(configPath)) {

package/dist/core/agent-runner.js

@@ -10,6 +10,7 @@ import { encodePath } from '../utils/platform.js';
 export class AgentRunner {
     apiKey;
     model;
+    effort;
     baseUrl;
     config;
     activeSessions = new Map();
@@ -19,6 +20,7 @@ export class AgentRunner {
     constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
         this.apiKey = apiKey;
         this.model = model || 'sonnet';
+        this.effort = undefined;
         this.baseUrl = baseUrl;
         this.config = config;
         this.onSessionIdUpdate = onSessionIdUpdate;
@@ -38,30 +40,58 @@ export class AgentRunner {
     getModel() {
         return this.model;
     }
+    setEffort(effort) {
+        this.effort = effort;
+    }
+    getEffort() {
+        return this.effort;
+    }
+    syncFromUserSettings() {
+        try {
+            const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return;
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (settings.model && settings.model !== this.model) {
+                logger.info(`[AgentRunner] Synced model from ~/.claude/settings.json: ${settings.model}`);
+                this.model = settings.model;
+            }
+            const newEffort = settings.effortLevel || undefined;
+            if (newEffort !== this.effort) {
+                logger.info(`[AgentRunner] Synced effort from ~/.claude/settings.json: ${newEffort ?? 'auto'}`);
+                this.effort = newEffort;
+            }
+        }
+        catch (error) {
+            logger.debug(`[AgentRunner] Failed to sync from ~/.claude/settings.json:`, error);
+        }
+    }
     setCompactStartCallback(callback) {
         this.onCompactStart = callback;
     }
     async runQuery(sessionId, prompt, projectPath, initialClaudeSessionId, images, systemPromptAppend, sessionManager) {
+        // 同步用户级配置到内存
+        this.syncFromUserSettings();
         ensureDir(projectPath);
         ensureDir(path.join(projectPath, '.claude'));
-        // 优先使用传入的 claudeSessionId（从数据库恢复），否则使用内存中的
-        let claudeSessionId = initialClaudeSessionId || this.activeSessions.get(sessionId);
+        // 优先使用传入的 agentSessionId（从数据库恢复），否则使用内存中的
+        let agentSessionId = initialClaudeSessionId || this.activeSessions.get(sessionId);
         // 检查是否在安全模式
         let skipResume = false;
         if (sessionManager) {
             const health = await sessionManager.getHealthStatus(sessionId);
             if (health.safeMode) {
                 // 安全模式：不使用 resume，每次都是新对话
-                claudeSessionId = undefined;
+                agentSessionId = undefined;
                 skipResume = true;
                 logger.warn(`[AgentRunner] Safe mode enabled for ${sessionId}, not resuming session`);
             }
         }
-        // 验证会话文件是否存在且有效（仅在非安全模式且有 claudeSessionId 时）
-        if (claudeSessionId && !skipResume) {
+        // 验证会话文件是否存在且有效（仅在非安全模式且有 agentSessionId 时）
+        if (agentSessionId && !skipResume) {
             const homeDir = os.homedir();
             const encodedProjectPath = encodePath(projectPath);
-            const sessionFile = path.join(homeDir, '.claude', 'projects', encodedProjectPath, `${claudeSessionId}.jsonl`);
+            const sessionFile = path.join(homeDir, '.claude', 'projects', encodedProjectPath, `${agentSessionId}.jsonl`);
             let isValid = false;
             if (fs.existsSync(sessionFile)) {
                 try {
@@ -88,7 +118,7 @@ export class AgentRunner {
             }
             if (!isValid) {
                 logger.warn(`[AgentRunner] Invalid session file, starting new session`);
-                claudeSessionId = undefined;
+                agentSessionId = undefined;
                 this.activeSessions.delete(sessionId);
                 if (this.onSessionIdUpdate) {
                     this.onSessionIdUpdate(sessionId, '');
@@ -117,9 +147,11 @@ export class AgentRunner {
         const useSettingSources = this.config?.agents?.anthropic?.useSettingSources !== false;
         const enableSummaries = this.config?.agents?.anthropic?.agentProgressSummaries !== false;
         // 公共 options（新旧模式共用）
+        logger.info(`[AgentRunner] runQuery model=${this.model} effort=${this.effort ?? 'auto'}`);
         const commonOptions = {
             cwd: projectPath,
             model: this.model,
+            ...(this.effort ? { effort: this.effort } : {}),
             canUseTool,
             permissionMode: 'default',
             persistSession: true,
@@ -220,8 +252,8 @@ export class AgentRunner {
                     queryStream = createQuery(stream);
                 }
                 else {
-                    logger.debug('[AgentRunner] Creating query with text only, claudeSessionId:', initialClaudeSessionId);
-                    queryStream = createQuery(prompt, claudeSessionId);
+                    logger.debug('[AgentRunner] Creating query with text only, agentSessionId:', initialClaudeSessionId);
+                    queryStream = createQuery(prompt, agentSessionId);
                 }
                 this.activeStreams.set(sessionId, queryStream);
                 return queryStream;
@@ -243,26 +275,29 @@ export class AgentRunner {
             logger.info(`[AgentRunner] Interrupted session: ${sessionId}`);
         }
     }
+    hasActiveStream(sessionId) {
+        return this.activeStreams.has(sessionId);
+    }
     registerStream(key, stream) {
         this.activeStreams.set(key, stream);
     }
     cleanupStream(sessionId) {
         this.activeStreams.delete(sessionId);
     }
-    updateSessionId(sessionId, claudeSessionId) {
-        logger.info(`[AgentRunner] updateSessionId called: sessionId=${sessionId}, claudeSessionId=${claudeSessionId}`);
-        this.activeSessions.set(sessionId, claudeSessionId);
+    updateSessionId(sessionId, agentSessionId) {
+        logger.info(`[AgentRunner] updateSessionId called: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
+        this.activeSessions.set(sessionId, agentSessionId);
         if (this.onSessionIdUpdate) {
-            this.onSessionIdUpdate(sessionId, claudeSessionId);
+            this.onSessionIdUpdate(sessionId, agentSessionId);
         }
     }
-    runSessionCommand(prompt, claudeSessionId, projectPath) {
+    runSessionCommand(prompt, agentSessionId, projectPath) {
         return query({
             prompt,
             options: {
                 cwd: projectPath,
                 model: this.model,
-                resume: claudeSessionId,
+                resume: agentSessionId,
                 maxTurns: 1,
                 permissionMode: 'default',
                 env: this.getAgentEnv()
@@ -272,10 +307,10 @@ export class AgentRunner {
     /**
      * 主动压缩会话上下文
      */
-    async compactSession(sessionId, claudeSessionId, projectPath) {
+    async compactSession(sessionId, agentSessionId, projectPath) {
         try {
-            logger.info(`[AgentRunner] Compacting session: ${claudeSessionId}`);
-            const stream = this.runSessionCommand('/compact', claudeSessionId, projectPath);
+            logger.info(`[AgentRunner] Compacting session: ${agentSessionId}`);
+            const stream = this.runSessionCommand('/compact', agentSessionId, projectPath);
             for await (const event of stream) {
                 if (event.type === 'system' && event.subtype === 'compact_boundary') {
                     logger.info(`[AgentRunner] Compact completed, pre_tokens: ${event.compact_metadata?.pre_tokens}`);
@@ -292,10 +327,10 @@ export class AgentRunner {
     /**
      * 通过 SDK /clear 命令清空会话历史
      */
-    async clearSession(claudeSessionId, projectPath) {
+    async clearSession(agentSessionId, projectPath) {
         try {
-            logger.info(`[AgentRunner] Clearing session via SDK: ${claudeSessionId}`);
-            const stream = this.runSessionCommand('/clear', claudeSessionId, projectPath);
+            logger.info(`[AgentRunner] Clearing session via SDK: ${agentSessionId}`);
+            const stream = this.runSessionCommand('/clear', agentSessionId, projectPath);
             for await (const event of stream) {
                 logger.debug(`[AgentRunner] Clear event: type=${event.type}, subtype=${event.subtype || 'none'}`);
             }