evolclaw 2.1.0 → 2.1.1

package/dist/core/message-processor.js

@@ -19,10 +19,12 @@ export class MessageProcessor {
     currentFlusher;
     currentIsGroup = false;
     shouldSuppressActivities = false;
-    /** 话题 session 永远不是后台任务；主 session 与当前活跃 session 比对 */
+    /** 判断是否为后台会话（仅主会话参与判断，话题会话独立） */
     async isBackgroundSession(session, channel, channelId) {
+        // 话题会话独立运行，不是后台任务
         if (session.threadId)
             return false;
+        // 主会话：与当前活跃会话比对
         const active = await this.sessionManager.getActiveSession(channel, channelId);
         return active ? session.id !== active.id : false;
     }
@@ -61,7 +63,7 @@ export class MessageProcessor {
         const isOwnerUser = isOwner(this.config, message.channel, message.userId || '');
         // 非主人（群聊或单聊）：空闲监控静默/简短
         const quietMode = isGroup || !isOwnerUser;
-        // 计算是否抑制活动输出
+        // 计算是否抑制中间输出（工具活动 + 流式文本）
         const shouldSuppress = () => {
             const mode = this.config.showActivities ?? 'all';
             if (mode === 'all')
@@ -70,6 +72,8 @@ export class MessageProcessor {
                 return isGroup;
             if (mode === 'owner-dm-only')
                 return isGroup || !isOwnerUser;
+            if (mode === 'none')
+                return true;
             return false;
         };
         this.shouldSuppressActivities = shouldSuppress();
@@ -265,7 +269,7 @@ ${suggestions}`, sendOpts);
                     await adapter.sendText(message.channelId, text, Object.keys(opts).length ? opts : undefined);
                 }
                 // 后台任务：静默，不发送输出
-            }, this.config.flushDelay ? this.config.flushDelay * 1000 : 4000, options?.fileMarkerPattern);
+            }, (this.config.flushDelay || 4) * 1000, options?.fileMarkerPattern, this.config.debug?.flusherDiag);
             // 保存当前 flusher，用于 compact 事件
             this.currentFlusher = flusher;
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
@@ -311,7 +315,7 @@ ${suggestions}`, sendOpts);
                     // 文件存在性检查：真实路径但文件不存在，告知用户
                     if (!fs.existsSync(resolvedPath)) {
                         logger.warn(`[${adapter.name}] File not found: ${resolvedPath}`);
-                        await adapter.sendText(message.channelId, `⚠️ 文件未找到: ${filePath}`);
+                        await adapter.sendText(message.channelId, `⚠️ 文件未找到: ${filePath}`, this.getThreadSendOpts(session));
                         continue;
                     }
                     logger.info(`[${adapter.name}] Sending file: ${resolvedPath}`);
@@ -320,7 +324,7 @@ ${suggestions}`, sendOpts);
                     }
                     catch (error) {
                         logger.error(`[${adapter.name}] Failed to send file: ${resolvedPath}`, error);
-                        await adapter.sendText(message.channelId, `❌ 文件发送失败: ${filePath}`);
+                        await adapter.sendText(message.channelId, `❌ 文件发送失败: ${filePath}`, this.getThreadSendOpts(session));
                     }
                 }
             }
@@ -380,7 +384,14 @@ ${suggestions}`, sendOpts);
             }
             else {
                 const userMessage = getErrorMessage(error);
-                await adapter.sendText(message.channelId, userMessage);
+                // 获取 session 用于话题回复（如果 resolveSession 已执行）
+                let sendOpts;
+                try {
+                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
+                    sendOpts = this.getThreadSendOpts(session);
+                }
+                catch { }
+                await adapter.sendText(message.channelId, userMessage, sendOpts);
             }
         }
     }
@@ -388,7 +399,11 @@ ${suggestions}`, sendOpts);
      * 解析会话和项目路径
      */
     async resolveSession(message) {
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
+        // 话题会话：传入 rootId metadata（首条消息的 messageId 作为 rootId）
+        const metadata = message.threadId && message.messageId
+            ? { feishu: { rootId: message.messageId } }
+            : undefined;
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId, metadata);
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
             : path.resolve(process.cwd(), session.projectPath);
@@ -419,11 +434,13 @@ ${suggestions}`, sendOpts);
                 const isCurrentlyBackground = await this.isBackgroundSession(session, session.channel, session.channelId);
                 // === 前台任务：正常处理所有事件 ===
                 if (!isCurrentlyBackground) {
-                    // 流式文本事件
+                    // 流式文本事件（抑制时跳过，只累积到 allText）
                     if (event.type === 'text_delta' && event.text) {
                         hasTextDelta = true;
                         hasReceivedText = true;
-                        flusher.addText(event.text);
+                        if (!shouldSuppress()) {
+                            flusher.addText(event.text);
+                        }
                     }
                     // 系统事件：compact_boundary（群聊时静默）
                     if (event.type === 'system' && event.subtype === 'compact_boundary') {
@@ -457,7 +474,9 @@ ${suggestions}`, sendOpts);
                             else if (content.type === 'text' && content.text && !hasTextDelta) {
                                 // 仅在没有 text_delta 事件时从 assistant 事件提取文本，避免重复
                                 hasReceivedText = true;
-                                flusher.addTextBlock(content.text);
+                                if (!shouldSuppress()) {
+                                    flusher.addTextBlock(content.text);
+                                }
                             }
                         }
                     }
@@ -470,14 +489,19 @@ ${suggestions}`, sendOpts);
                             flusher.addActivity(`⚠️ ${toolName}: ${errorMsg}`);
                         }
                     }
-                    // Result 事件：仅在没有流式文本时使用 result 作为最终输出
+                    // Result 事件：最终输出
                     if (event.type === 'result' && event.result) {
-                        logger.debug(`[MessageProcessor] result event: hasReceivedText=${hasReceivedText}, result="${event.result}"`);
-                        if (!hasReceivedText) {
-                            // 没有通过 text_delta 或 assistant 收到文本，使用 result 作为兜底
+                        logger.debug(`[MessageProcessor] result event: hasReceivedText=${hasReceivedText}, shouldSuppress=${shouldSuppress()}, result="${event.result}"`);
+                        if (shouldSuppress()) {
+                            // 抑制模式：直接发送 result（跳过中间输出）
+                            flusher.addText(event.result);
+                        }
+                        else if (!hasReceivedText) {
+                            // 非抑制模式 + 无流式文本：使用 result 作为兜底
                             flusher.addText(event.result);
                         }
-                        await flusher.flush();
+                        // 非抑制模式 + 有流式文本：已通过 text_delta 累积，无需再添加
+                        await flusher.flush(true); // isFinal=true 标记最终输出
                     }
                     continue;
                 }

package/dist/core/session-manager.js

@@ -170,13 +170,11 @@ export class SessionManager {
     `);
     }
     async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name) {
-        const normalizedThreadId = threadId || '';
-        // 话题会话：直接按 thread_id 查找/创建
-        if (normalizedThreadId) {
-            return this.getOrCreateThreadSession(channel, channelId, normalizedThreadId, defaultProjectPath, metadata, name);
+        // 话题会话：独立查找/创建，不参与 isActive 竞争
+        if (threadId) {
+            return this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name);
         }
-        // 主会话：原有逻辑
-        // 1. 查找该聊天的活跃会话
+        // 主会话：查找活跃会话
         const active = this.db.prepare(`
       SELECT * FROM sessions
       WHERE channel = ? AND channel_id = ? AND is_active = 1 AND thread_id = ''
@@ -185,28 +183,24 @@ export class SessionManager {
             const validSessionId = this.validateSessionFile(active);
             return { ...this.rowToSession(active), agentSessionId: validSessionId };
         }
-        // 2. 没有活跃会话，查找该聊天在默认项目的会话（匹配 thread_id）
+        // 查找默认项目的主会话
         const existing = this.db.prepare(`
       SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND project_path = ? AND thread_id = ?
+      WHERE channel = ? AND channel_id = ? AND project_path = ? AND thread_id = ''
       ORDER BY updated_at DESC LIMIT 1
-    `).get(channel, channelId, defaultProjectPath, normalizedThreadId);
+    `).get(channel, channelId, defaultProjectPath);
         if (existing) {
             const validSessionId = this.validateSessionFile(existing);
-            // 激活该会话
-            this.db.prepare(`
-        UPDATE sessions SET is_active = 1, updated_at = ?
-        WHERE id = ?
-      `).run(Date.now(), existing.id);
+            this.db.prepare(`UPDATE sessions SET is_active = 1, updated_at = ? WHERE id = ?`).run(Date.now(), existing.id);
             return { ...this.rowToSession(existing), agentSessionId: validSessionId, isActive: true };
         }
-        // 3. 创建新会话（默认为活跃）
+        // 创建新主会话
         const session = {
             id: `${channel}-${channelId}-${Date.now()}`,
             channel,
             channelId,
             projectPath: defaultProjectPath,
-            threadId: normalizedThreadId,
+            threadId: '',
             agentType: 'claude',
             metadata,
             name: name || '默认会话',
@@ -214,22 +208,7 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now()
         };
-        // 使用 INSERT OR IGNORE 避免并发时的 UNIQUE 约束冲突
-        const result = this.db.prepare(`
-      INSERT OR IGNORE INTO sessions (id, channel, channel_id, project_path, thread_id, agent_type, agent_session_id, name, is_active, created_at, updated_at, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(session.id, session.channel, session.channelId, session.projectPath, session.threadId, session.agentType, session.agentSessionId ?? null, session.name ?? null, 1, session.createdAt, session.updatedAt, session.metadata ? JSON.stringify(session.metadata) : null);
-        // 如果插入被忽略（已存在），重新查询
-        if (result.changes === 0) {
-            const recheck = this.db.prepare(`
-        SELECT * FROM sessions
-        WHERE channel = ? AND channel_id = ? AND project_path = ? AND thread_id = ?
-      `).get(channel, channelId, defaultProjectPath, normalizedThreadId);
-            if (recheck) {
-                this.db.prepare(`UPDATE sessions SET is_active = 1, updated_at = ? WHERE id = ?`).run(Date.now(), recheck.id);
-                return { ...this.rowToSession(recheck), isActive: true, updatedAt: Date.now() };
-            }
-        }
+        this.insertSession(session);
         return session;
     }
     async updateSession(sessionId, updates) {
@@ -247,15 +226,16 @@ export class SessionManager {
         this.db.prepare(`UPDATE sessions SET ${fields}, updated_at = ? WHERE id = ?`).run(...values, Date.now(), sessionId);
     }
     getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name) {
+        // 查找已有话题会话
         const existing = this.db.prepare(`
       SELECT * FROM sessions
       WHERE channel = ? AND channel_id = ? AND thread_id = ?
-      LIMIT 1
     `).get(channel, channelId, threadId);
         if (existing) {
             const validSessionId = this.validateSessionFile(existing);
-            const existingMeta = this.rowToSession(existing).metadata;
+            // 合并 metadata（如果提供）
             if (metadata) {
+                const existingMeta = this.rowToSession(existing).metadata;
                 const merged = existingMeta ? { ...existingMeta, ...metadata } : metadata;
                 this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
                     .run(JSON.stringify(merged), Date.now(), existing.id);
@@ -263,12 +243,13 @@ export class SessionManager {
             }
             return { ...this.rowToSession(existing), agentSessionId: validSessionId };
         }
-        const activeSession = this.db.prepare(`
+        // 继承当前活跃主会话的项目路径
+        const activeMain = this.db.prepare(`
       SELECT project_path FROM sessions
       WHERE channel = ? AND channel_id = ? AND is_active = 1 AND thread_id = ''
-      LIMIT 1
     `).get(channel, channelId);
-        const projectPath = activeSession?.project_path || defaultProjectPath;
+        const projectPath = activeMain?.project_path || defaultProjectPath;
+        // 创建新话题会话（isActive 固定为 false）
         const session = {
             id: `${channel}-${channelId}-${Date.now()}`,
             channel,
@@ -283,15 +264,6 @@ export class SessionManager {
             updatedAt: Date.now()
         };
         this.insertSession(session);
-        // Race condition 保护
-        const recheck = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND thread_id = ?
-      LIMIT 1
-    `).get(channel, channelId, threadId);
-        if (recheck && recheck.id !== session.id) {
-            return this.rowToSession(recheck);
-        }
         return session;
     }
     async switchProject(channel, channelId, newProjectPath) {
@@ -411,6 +383,12 @@ export class SessionManager {
     `).run(newName, Date.now(), sessionId);
         return result.changes > 0;
     }
+    async unbindSession(sessionId) {
+        const result = this.db.prepare(`
+      DELETE FROM sessions WHERE id = ?
+    `).run(sessionId);
+        return result.changes > 0;
+    }
     async createNewSession(channel, channelId, projectPath, name) {
         // 取消当前活跃会话
         this.deactivateAll(channel, channelId);

package/dist/index.js

@@ -46,6 +46,9 @@ async function main() {
     const agentRunner = new AgentRunner(anthropic.apiKey, anthropic.model, async (sessionId, agentSessionId) => {
         await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
     }, anthropic.baseUrl, config);
+    if (anthropic.effort) {
+        agentRunner.setEffort(anthropic.effort);
+    }
     logger.info('✓ Agent runner ready');
     // 创建消息缓存
     const messageCache = new MessageCache();
@@ -79,7 +82,7 @@ async function main() {
     const cmdHandler = new CommandHandler(sessionManager, agentRunner, config, messageCache);
     // 创建消息处理器
     const processor = new MessageProcessor(agentRunner, sessionManager, config, messageCache, (content, channel, channelId, userId, threadId) => {
-        const sendFn = async (id, text) => {
+        const sendFn = async (id, text, opts) => {
             const adapter = cmdHandler.getAdapter(channel);
             if (!adapter)
                 return;
@@ -105,7 +108,7 @@ async function main() {
                 text = text.replace(fileMarkerPattern, '').trim();
             }
             if (text) {
-                await adapter.sendText(id, text);
+                await adapter.sendText(id, text, opts);
             }
         };
         return cmdHandler.handle(content, channel, channelId, sendFn, userId, threadId);

package/dist/index.js.bak

@@ -0,0 +1,340 @@
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig } from './config.js';
+import { SessionManager } from './core/session-manager.js';
+import { AgentRunner } from './core/agent-runner.js';
+import { FeishuChannel } from './channels/feishu.js';
+import { AUNChannel } from './channels/aun.js';
+import { WechatChannel } from './channels/wechat.js';
+import { MessageProcessor } from './core/message-processor.js';
+import { MessageQueue } from './core/message-queue.js';
+import { MessageCache } from './core/message-cache.js';
+import { CommandHandler } from './core/command-handler.js';
+import { logger } from './utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+async function main() {
+    // 过滤飞书 SDK 的 info 日志
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const filter = (...args) => {
+        const firstArg = String(args[0] || '');
+        return firstArg.includes('[info]') || firstArg.includes('[ws]');
+    };
+    console.log = (...args) => {
+        if (filter(...args))
+            return;
+        originalLog(...args);
+    };
+    console.info = (...args) => {
+        if (filter(...args))
+            return;
+        originalInfo(...args);
+    };
+    logger.info('EvolClaw starting...');
+    // 确保数据目录存在
+    ensureDataDirs();
+    // 加载配置
+    const config = loadConfig();
+    const anthropic = resolveAnthropicConfig(config);
+    logger.info('✓ Config loaded (API keys hidden)');
+    if (anthropic.baseUrl) {
+        logger.info(`✓ Using custom API base URL: ${anthropic.baseUrl}`);
+    }
+    // 初始化数据库
+    const sessionManager = new SessionManager();
+    logger.info('✓ Database initialized');
+    // 初始化 Agent Runner（带持久化回调）
+    const agentRunner = new AgentRunner(anthropic.apiKey, anthropic.model, async (sessionId, agentSessionId) => {
+        await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
+    }, anthropic.baseUrl, config);
+    if (anthropic.effort) {
+        agentRunner.setEffort(anthropic.effort);
+    }
+    logger.info('✓ Agent runner ready');
+    // 创建消息缓存
+    const messageCache = new MessageCache();
+    logger.info('✓ Message cache initialized');
+    // 定期清理过期消息（每小时）
+    setInterval(() => {
+        messageCache.cleanupExpired();
+    }, 60 * 60 * 1000);
+    // 飞书渠道（条件初始化）
+    let feishu = null;
+    if (config.channels?.feishu?.enabled !== false && config.channels?.feishu?.appId) {
+        feishu = new FeishuChannel({
+            appId: config.channels.feishu.appId,
+            appSecret: config.channels.feishu.appSecret,
+            db: sessionManager.getDatabase()
+        });
+        // 设置项目路径提供器
+        feishu.onProjectPathRequest(async (chatId) => {
+            const session = await sessionManager.getOrCreateSession('feishu', chatId, config.projects?.defaultPath || process.cwd());
+            return path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+        });
+    }
+    // AUN 渠道（条件初始化）
+    let aun = null;
+    if (config.channels?.aun?.enabled !== false && config.channels?.aun?.domain) {
+        aun = new AUNChannel({ domain: config.channels.aun.domain, agentName: config.channels.aun.agentName });
+    }
+    // 创建命令处理器
+    const cmdHandler = new CommandHandler(sessionManager, agentRunner, config, messageCache);
+    // 创建消息处理器
+    const processor = new MessageProcessor(agentRunner, sessionManager, config, messageCache, (content, channel, channelId, userId, threadId) => {
+        const sendFn = async (id, text, opts) => {
+            const adapter = cmdHandler.getAdapter(channel);
+            if (!adapter)
+                return;
+            // 文件标记处理（通过 adapter.sendFile 能力判断，不按渠道名分支）
+            if (adapter.sendFile) {
+                const fileMarkerPattern = /\[SEND_FILE:([^\]]+)\]/g;
+                const fileMatches = [...text.matchAll(fileMarkerPattern)];
+                for (const match of fileMatches) {
+                    const filePath = match[1].trim();
+                    // 跳过占位符/代码片段中的伪路径
+                    if (!filePath || /[\\[\]{}*+?|^$]/.test(filePath))
+                        continue;
+                    const session = await sessionManager.getActiveSession(channel, channelId);
+                    const projectPath = session?.projectPath || process.cwd();
+                    const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.join(projectPath, filePath);
+                    try {
+                        await adapter.sendFile(id, absoluteFilePath);
+                    }
+                    catch (error) {
+                        logger.error(`[${channel}] Failed to send file: ${absoluteFilePath}`, error);
+                    }
+                }
+                text = text.replace(fileMarkerPattern, '').trim();
+            }
+            if (text) {
+                await adapter.sendText(id, text, opts);
+            }
+        };
+        return cmdHandler.handle(content, channel, channelId, sendFn, userId, threadId);
+    });
+    // 回填 processor 和 messageQueue 的引用
+    cmdHandler.setProcessor(processor);
+    // 设置 compact 开始回调
+    agentRunner.setCompactStartCallback((sessionId) => {
+        processor.handleCompactStart();
+    });
+    // 创建消息队列
+    const messageQueue = new MessageQueue(async (message) => {
+        await processor.processMessage(message);
+    });
+    // 设置中断回调
+    messageQueue.setInterruptCallback(async (sessionKey) => {
+        await agentRunner.interrupt(sessionKey);
+    });
+    // 回填 messageQueue 引用
+    cmdHandler.setMessageQueue(messageQueue);
+    // 注册 Feishu 适配器（如果已初始化）
+    if (feishu) {
+        const feishuAdapter = {
+            name: 'feishu',
+            sendText: (channelId, text, options) => feishu.sendMessage(channelId, text, options),
+            sendFile: (channelId, filePath) => feishu.sendFile(channelId, filePath),
+            isGroupChat: (channelId) => feishu.getChatMode(channelId).then(m => m === 'group'),
+        };
+        const feishuOptions = {
+            systemPromptAppend: '[重要系统功能] 你可以通过飞书发送文件给用户。方法：在响应中使用 [SEND_FILE:文件路径] 标记。示例：文件已准备好！[SEND_FILE:./report.txt] 路径支持相对路径（相对项目目录）或绝对路径。系统会自动上传并发送。',
+            fileMarkerPattern: /\[SEND_FILE:([^\]]+)\]/g,
+            supportsImages: true,
+        };
+        processor.registerChannel(feishuAdapter, feishuOptions);
+        cmdHandler.registerAdapter(feishuAdapter);
+    }
+    // 注册 AUN 适配器（如果已初始化）
+    if (aun) {
+        const aunAdapter = {
+            name: 'aun',
+            sendText: (channelId, text) => aun.sendMessage(channelId, text),
+        };
+        processor.registerChannel(aunAdapter);
+        cmdHandler.registerAdapter(aunAdapter);
+    }
+    // ── WeChat 渠道（条件初始化）──
+    let wechat = null;
+    if (config.channels?.wechat?.enabled && config.channels?.wechat?.token) {
+        wechat = new WechatChannel({
+            baseUrl: config.channels.wechat.baseUrl || 'https://ilinkai.weixin.qq.com',
+            token: config.channels.wechat.token,
+        });
+        // 设置项目路径提供器（用于接收文件保存）
+        wechat.onProjectPathRequest(async (channelId) => {
+            const session = await sessionManager.getOrCreateSession('wechat', channelId, config.projects?.defaultPath || process.cwd());
+            return path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+        });
+        const wechatAdapter = {
+            name: 'wechat',
+            sendText: (channelId, text) => wechat.sendMessage(channelId, text),
+            sendFile: (channelId, filePath) => wechat.sendFile(channelId, filePath),
+        };
+        const wechatOptions = {
+            systemPromptAppend: '[系统功能] 你可以发送文件给用户。方法：在响应中使用 [SEND_FILE:文件路径] 标记。示例：文件已准备好！[SEND_FILE:./report.txt]',
+            fileMarkerPattern: /\[SEND_FILE:([^\]]+)\]/g,
+        };
+        processor.registerChannel(wechatAdapter, wechatOptions);
+        cmdHandler.registerAdapter(wechatAdapter);
+        // Session 过期通知（通过 Feishu 等其他渠道告知用户）
+        wechat.onSessionExpiredNotify(async (message) => {
+            // 尝试通过已注册的 Feishu owner 通知
+            const feishuOwner = config.channels?.feishu?.owner;
+            if (feishuOwner) {
+                try {
+                    // Feishu owner ID 是 open_id，但 sendMessage 需要 chat_id
+                    // 这里只记日志，因为 owner 的 chat_id 需要从 session 中获取
+                    logger.warn(`[WeChat] ${message}`);
+                }
+                catch { }
+            }
+            else {
+                logger.warn(`[WeChat] ${message}`);
+            }
+        });
+        wechat.onMessage(async (channelId, content, userId, images) => {
+            content = content.trim();
+            // 首次交互自动绑定主人
+            if (userId && !config.channels?.wechat?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'wechat', userId);
+                logger.info(`[Owner] Auto-bound WeChat owner: ${userId}`);
+            }
+            // 命令快速路径
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'wechat', channelId, undefined, userId);
+                if (cmdResult !== null) {
+                    if (cmdResult) {
+                        try {
+                            await wechat.sendMessage(channelId, cmdResult);
+                        }
+                        catch (error) {
+                            logger.error('[WeChat] Failed to send command response:', error);
+                        }
+                    }
+                    return;
+                }
+            }
+            // 获取当前项目路径
+            const session = await sessionManager.getOrCreateSession('wechat', channelId, config.projects?.defaultPath || process.cwd());
+            // 普通消息进入队列
+            await messageQueue.enqueue(`wechat-${channelId}`, { channel: 'wechat', channelId, content, images, timestamp: Date.now(), userId }, session.projectPath);
+        });
+    }
+    // Feishu 消息处理
+    if (feishu) {
+        feishu.onMessage(async ({ channelId: chatId, content: rawContent, images, userId, userName, messageId, mentions, threadId, rootId }) => {
+            let content = rawContent.trim();
+            // 首次交互自动绑定主人
+            if (userId && !config.channels?.feishu?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'feishu', userId);
+                logger.info(`[Owner] Auto-bound owner: ${userName} (${userId})`);
+            }
+            // 命令立即处理，不进入队列
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'feishu', chatId, undefined, userId, threadId);
+                if (cmdResult !== null) {
+                    if (cmdResult) {
+                        try {
+                            await feishu.sendMessage(chatId, cmdResult, { forceText: true, replyToMessageId: rootId, replyInThread: true });
+                        }
+                        catch (error) {
+                            logger.error('[Feishu] Failed to send command response:', error);
+                        }
+                    }
+                    return;
+                }
+            }
+            // 获取当前项目路径（话题会话自动创建，携带 metadata）
+            const metadata = rootId ? { feishu: { rootId } } : undefined;
+            const session = await sessionManager.getOrCreateSession('feishu', chatId, config.projects?.defaultPath || process.cwd(), threadId, metadata);
+            // 群聊消息添加用户名前缀
+            const chatMode = await feishu.getChatMode(chatId);
+            if (chatMode === 'group' && userName) {
+                content = `[${userName}] ${content}`;
+            }
+            // 普通消息进入队列（使用 session.id 作为 key，话题间可并行）
+            await messageQueue.enqueue(session.id, { channel: 'feishu', channelId: chatId, content, images, timestamp: Date.now(), userId, userName, messageId, isGroup: chatMode === 'group', mentions, threadId }, session.projectPath);
+        });
+    }
+    // AUN 消息处理
+    if (aun) {
+        aun.onMessage(async (sessionId, content) => {
+            content = content.trim();
+            // 首次交互自动绑定主人
+            if (!config.channels?.aun?.owner) {
+                const { setOwner } = await import('./config.js');
+                setOwner(config, 'aun', sessionId);
+                logger.info(`[Owner] Auto-bound AUN owner: ${sessionId}`);
+            }
+            // 命令立即处理，不进入队列
+            if (cmdHandler.isCommand(content)) {
+                const cmdResult = await cmdHandler.handle(content, 'aun', sessionId, undefined, sessionId);
+                if (cmdResult) {
+                    await aun.sendMessage(sessionId, cmdResult);
+                    return;
+                }
+            }
+            // 获取当前项目路径
+            const session = await sessionManager.getOrCreateSession('aun', sessionId, config.projects?.defaultPath || process.cwd());
+            // 普通消息进入队列
+            await messageQueue.enqueue(`aun-${sessionId}`, { channel: 'aun', channelId: sessionId, content, timestamp: Date.now(), userId: sessionId }, session.projectPath);
+        });
+    }
+    // 连接渠道
+    const channels = [];
+    const channelInstances = [
+        ...(feishu ? [{ name: 'Feishu', instance: feishu, timeout: 5000 }] : []),
+        ...(aun ? [{ name: 'AUN', instance: aun }] : []),
+        ...(wechat ? [{ name: 'WeChat', instance: wechat }] : []),
+    ];
+    for (const { name, instance, timeout } of channelInstances) {
+        try {
+            if (timeout) {
+                await Promise.race([
+                    instance.connect(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), timeout))
+                ]);
+            }
+            else {
+                await instance.connect();
+            }
+            logger.info(`✓ ${name} connected`);
+            channels.push(name);
+        }
+        catch (error) {
+            logger.warn(`⚠ ${name} connection failed (will continue without it)`);
+            if (error instanceof Error) {
+                logger.warn(`  Reason: ${error.message}`);
+            }
+        }
+    }
+    logger.info(`\n🚀 EvolClaw is running with ${channels.length} channel(s): ${channels.join(', ')}\n`);
+    // 写入 ready 信号，供 restart-monitor 检测启动成功
+    const readySignalPath = resolvePaths().readySignal;
+    fs.writeFileSync(readySignalPath, String(Date.now()));
+    logger.info(`✓ Ready signal written: ${readySignalPath}`);
+    // 优雅关闭
+    const shutdown = async () => {
+        logger.info('\n\nShutting down gracefully...');
+        if (feishu)
+            await feishu.disconnect();
+        if (aun)
+            await aun.disconnect();
+        if (wechat)
+            await wechat.disconnect();
+        sessionManager.close();
+        logger.info('✓ Shutdown complete');
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((error) => {
+    logger.error('Fatal error:', error);
+    process.exit(1);
+});