evolclaw 2.1.2 → 2.3.0

package/dist/index.js

@@ -1,13 +1,26 @@
-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 { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
+import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
+import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, validateConfigIntegrity, validateChannelInstanceNames, getOwner } from './config.js';
+import { SessionManager } from './core/session/session-manager.js';
+import { ClaudeAgentPlugin } from './agents/claude-runner.js';
+import { CodexAgentPlugin } from './agents/codex-runner.js';
+import { GeminiAgentPlugin } from './agents/gemini-runner.js';
+import { FeishuChannelPlugin } from './channels/feishu.js';
+import { WechatChannelPlugin } from './channels/wechat.js';
+import { AUNChannelPlugin } from './channels/aun.js';
+import { MessageProcessor } from './core/message/message-processor.js';
+import { MessageQueue } from './core/message/message-queue.js';
+import { MessageBridge } from './core/message/message-bridge.js';
+import { MessageCache } from './core/message/message-cache.js';
 import { CommandHandler } from './core/command-handler.js';
+import { EventBus } from './core/event-bus.js';
+import { StatsCollector } from './utils/stats-collector.js';
+import { PermissionGateway } from './core/permission.js';
+import { InteractionRouter } from './core/interaction-router.js';
+import { ChannelLoader } from './core/channel-loader.js';
+import { AgentLoader } from './core/agent-loader.js';
+import { IpcServer } from './ipc.js';
 import { logger } from './utils/logger.js';
 import path from 'path';
 import fs from 'fs';
@@ -34,22 +47,65 @@ async function main() {
     ensureDataDirs();
     // 加载配置
     const config = loadConfig();
+    // 配置完整性校验
+    const integrity = validateConfigIntegrity(config);
+    if (!integrity.valid) {
+        const msg = `❌ Config integrity check failed:\n  ${integrity.reasons.join('\n  ')}`;
+        logger.error(msg);
+        console.error(msg); // ensure it lands in stdout.log for self-heal diagnostics
+        process.exit(1);
+    }
     const anthropic = resolveAnthropicConfig(config);
     logger.info('✓ Config loaded (API keys hidden)');
+    // Channel instance name uniqueness check
+    validateChannelInstanceNames(config);
     if (anthropic.baseUrl) {
         logger.info(`✓ Using custom API base URL: ${anthropic.baseUrl}`);
     }
-    // 初始化数据库
-    const sessionManager = new SessionManager();
+    // 创建事件总线
+    const eventBus = new EventBus();
+    logger.info('✓ Event bus initialized');
+    // 统计收集器（近 1 小时滚动统计）
+    const statsCollector = new StatsCollector(eventBus);
+    // 初始化数据库（带 ownerResolver）
+    const sessionManager = new SessionManager(undefined, eventBus, (channel, userId) => {
+        return isOwner(config, channel, userId);
+    });
     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);
+    // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
+    sessionManager.registerFileAdapter(new ClaudeSessionFileAdapter());
+    sessionManager.registerFileAdapter(new CodexSessionFileAdapter());
+    sessionManager.registerFileAdapter(new GeminiSessionFileAdapter());
+    // Agent 插件系统
+    const agentLoader = new AgentLoader();
+    agentLoader.register(new ClaudeAgentPlugin());
+    agentLoader.register(new CodexAgentPlugin());
+    agentLoader.register(new GeminiAgentPlugin());
+    const agentInstances = agentLoader.createAll(config, {
+        onSessionIdUpdate: async (sessionId, agentSessionId) => {
+            await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
+        },
+    });
+    // 构建 agent map，支持按 agentId 路由（当前默认使用第一个 agent）
+    const agentMap = new Map();
+    for (const inst of agentInstances) {
+        agentMap.set(inst.agent.name, inst.agent);
+    }
+    const defaultAgent = config.agents?.defaultAgent || 'claude';
+    const agentRunner = agentMap.get(defaultAgent) || agentInstances[0]?.agent;
+    if (!agentRunner) {
+        throw new Error('No agent backend available. Check agents config.');
+    }
+    logger.info(`✓ Agent runner ready (default: ${agentRunner.name}, available: ${[...agentMap.keys()].join(', ')})`);
+    // 权限审批网关
+    const permissionGateway = new PermissionGateway();
+    permissionGateway.setEventBus(eventBus);
+    // 交互路由器
+    const interactionRouter = new InteractionRouter();
+    // 为所有支持权限的 agent 设置 gateway
+    for (const inst of agentInstances) {
+        inst.agent.setPermissionGateway?.(permissionGateway);
     }
-    logger.info('✓ Agent runner ready');
     // 创建消息缓存
     const messageCache = new MessageCache();
     logger.info('✓ Message cache initialized');
@@ -57,284 +113,378 @@ async function main() {
     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 channelLoader = new ChannelLoader();
+    channelLoader.register(new FeishuChannelPlugin());
+    channelLoader.register(new WechatChannelPlugin());
+    channelLoader.register(new AUNChannelPlugin());
+    const channelInstances = await channelLoader.createAll(config);
+    logger.info(`✓ Created ${channelInstances.length} channel instance(s)`);
+    // 启动迁移：将 sessions.channel 从 channelType 回填为实例名
+    sessionManager.migrateChannelToInstanceName();
     // 创建命令处理器
-    const cmdHandler = new CommandHandler(sessionManager, agentRunner, config, messageCache);
+    const cmdHandler = new CommandHandler(sessionManager, agentMap, config, messageCache, eventBus, defaultAgent);
+    cmdHandler.setPermissionGateway(permissionGateway);
+    cmdHandler.setInteractionRouter(interactionRouter);
+    cmdHandler.setStatsCollector(statsCollector);
     // 创建消息处理器
-    const processor = new MessageProcessor(agentRunner, sessionManager, config, messageCache, (content, channel, channelId, userId, threadId) => {
+    const processor = new MessageProcessor(agentMap, sessionManager, config, messageCache, eventBus, (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);
-    });
+    }, defaultAgent);
     // 回填 processor 和 messageQueue 的引用
     cmdHandler.setProcessor(processor);
-    // 设置 compact 开始回调
-    agentRunner.setCompactStartCallback((sessionId) => {
-        processor.handleCompactStart();
-    });
+    // 设置交互路由器
+    processor.setInteractionRouter(interactionRouter);
+    // 设置 compact 开始回调（对所有支持的 agent）
+    for (const inst of agentInstances) {
+        inst.agent.setCompactStartCallback?.((sessionId) => {
+            processor.handleCompactStart(sessionId);
+        });
+    }
     // 创建消息队列
     const messageQueue = new MessageQueue(async (message) => {
         await processor.processMessage(message);
     });
-    // 设置中断回调
-    messageQueue.setInterruptCallback(async (sessionKey) => {
-        await agentRunner.interrupt(sessionKey);
+    // 设置中断回调（精确中断正在处理的 agent）
+    messageQueue.setInterruptCallback(async (sessionKey, agentId) => {
+        const agent = agentMap.get(agentId || defaultAgent);
+        if (agent?.hasActiveStream(sessionKey)) {
+            await agent.interrupt(sessionKey);
+        }
     });
+    messageQueue.setEventBus(eventBus);
     // 回填 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);
+    // 默认策略
+    const defaultPolicy = {
+        canSwitchProject: (chatType, role) => chatType === 'private' || role === 'owner',
+        canListProjects: (chatType, role) => chatType === 'private' || role === 'owner',
+        canCreateSession: () => true,
+        canDeleteSession: (chatType, role) => chatType === 'private' || role === 'owner',
+        canImportCliSession: (chatType, role) => chatType === 'private' || role === 'owner',
+        messagePrefix: () => '',
+        showMiddleResult: () => true,
+        showIdleMonitor: () => true,
+        accumulateErrors: () => true,
+    };
+    // 注册渠道插件的 adapter 和 policy
+    for (const inst of channelInstances) {
+        // 设置项目路径提供器（如果需要）
+        if (inst.onProjectPathRequest && inst.channel.onProjectPathRequest) {
+            inst.channel.onProjectPathRequest(async (channelId) => {
+                const session = await sessionManager.getOrCreateSession(inst.adapter.channelName, channelId, config.projects?.defaultPath || process.cwd(), undefined, undefined, undefined, undefined);
+                return path.isAbsolute(session.projectPath)
+                    ? session.projectPath
+                    : path.resolve(process.cwd(), session.projectPath);
+            });
+        }
+        // 注册 adapter、policy 和 options（注入 channelType）
+        const opts = inst.channelType
+            ? { ...inst.options, channelType: inst.channelType }
+            : inst.options;
+        processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, opts);
+        cmdHandler.registerAdapter(inst.adapter);
+        cmdHandler.registerChannel(inst.adapter.channelName, inst.channel, inst.channelType);
+        if (inst.policy) {
+            cmdHandler.registerPolicy(inst.adapter.channelName, inst.policy);
+        }
+        // 注册交互回调：渠道收到用户操作后路由到 InteractionRouter
+        if (inst.adapter.onInteraction) {
+            inst.adapter.onInteraction((response) => {
+                interactionRouter.handle(response);
+            });
+        }
     }
-    // ── 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;
-                }
+    // ── MessageBridge：Channel ↔ Core 消息桥梁 ──
+    const msgBridge = new MessageBridge(config, sessionManager, processor, messageQueue, cmdHandler, eventBus);
+    // ── 渠道消息注册 ──
+    // 连接插件系统的渠道
+    for (const inst of channelInstances) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'feishu') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, threadId, rootId, chatType }) => {
+                await handler({
+                    channel: channelType, channelId: chatId, content, images, chatType,
+                    peerId: peerId || '', peerName, messageId, mentions, threadId,
+                    replyContext: rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined,
+                });
+            }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, {
+                replyToMessageId: replyContext?.replyToMessageId,
+                replyInThread: true,
+            }), inst.adapter, channelType);
+            inst.channel.onRecall?.((messageId) => {
+                msgBridge.cancel(messageId);
+            });
+        }
+        if (channelType === 'wechat') {
+            // 注入 EventBus（用于 channel:health 事件）
+            if (inst.channel.setEventBus) {
+                inst.channel.setEventBus(eventBus);
             }
-            // 获取当前项目路径
-            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);
-        });
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (channelId, content, peerId, images, chatType) => {
+                handler({
+                    channel: channelType,
+                    channelId,
+                    content,
+                    images,
+                    chatType: chatType || 'private',
+                    peerId: peerId || '',
+                });
+            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter, channelType);
+        }
+        if (channelType === 'aun') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (opts) => {
+                handler({
+                    channel: channelType,
+                    channelId: opts.channelId,
+                    content: opts.content,
+                    chatType: opts.chatType || 'private',
+                    peerId: opts.peerId || '',
+                    peerName: opts.peerName,
+                    messageId: opts.messageId,
+                    mentions: opts.mentions,
+                    threadId: opts.threadId,
+                    replyContext: opts.replyContext,
+                });
+            }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, replyContext), inst.adapter, channelType);
+        }
     }
-    // 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);
+    // ── 连接所有渠道 ──
+    const connected = await channelLoader.connectAll(channelInstances);
+    // 预填充 Feishu 已知 thread_id（重启后避免误判话题创建）
+    for (const inst of channelInstances) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'feishu' && 'preloadThreads' in inst.channel) {
+            const threadIds = sessionManager.getKnownThreadIds(inst.adapter.channelName);
+            inst.channel.preloadThreads(threadIds);
+        }
+    }
+    for (const name of connected) {
+        // 查找对应实例以获取 channelType
+        const inst = channelInstances.find(i => i.adapter.channelName === name);
+        const type = inst?.channelType || name;
+        eventBus.publish({
+            type: 'channel:connected',
+            channel: type.toLowerCase(),
+            channelName: name,
+            timestamp: Date.now()
         });
     }
-    // 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}`);
+    // AUN 重连失败通知：通过 channel:health 事件
+    for (const inst of channelInstances) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'aun' && inst.channel.setOnChannelDown) {
+            inst.channel.setOnChannelDown(() => {
+                eventBus.publish({
+                    type: 'channel:health',
+                    channel: channelType,
+                    channelName: inst.adapter.channelName,
+                    status: 'auth_error',
+                    message: `⚠️ AUN 渠道 ${inst.adapter.channelName} 断连，自动重试已用尽。\n使用 /check rty aun 手动重连`,
+                    timestamp: Date.now(),
+                });
+            });
+        }
+    }
+    // 统一 channel:health 跨通道通知（仅 auth_error）
+    // 按 (channelType, ownerId) 去重，避免同类型多实例重复通知
+    eventBus.subscribe('channel:health', (event) => {
+        if (event.type !== 'channel:health' || event.status !== 'auth_error')
+            return;
+        const sourceChannelType = event.channel;
+        const sourceChannelName = event.channelName || sourceChannelType;
+        const msg = event.message;
+        logger.error(`[ChannelHealth] ${sourceChannelName} auth_error: ${msg}`);
+        const notified = new Set(); // channelType:ownerId 去重
+        for (const other of channelInstances) {
+            const otherType = other.channelType || other.adapter.channelName;
+            if (otherType === sourceChannelType)
+                continue; // 跳过同类型通道
+            const ownerId = getOwner(config, other.adapter.channelName);
+            if (!ownerId)
+                continue;
+            const key = `${otherType}:${ownerId}`;
+            if (notified.has(key))
+                continue; // 同类型已通知过此 owner
+            notified.add(key);
+            other.adapter.sendText(ownerId, msg).catch(err => {
+                logger.error(`[ChannelHealth] Failed to notify ${other.adapter.channelName} owner:`, err);
+            });
+        }
+    });
+    // 按 channelType 归组显示连接摘要
+    const connectedGroups = new Map();
+    for (const inst of channelInstances) {
+        const name = inst.adapter.channelName;
+        if (!connected.includes(name))
+            continue;
+        const type = inst.channelType || name;
+        if (!connectedGroups.has(type))
+            connectedGroups.set(type, []);
+        connectedGroups.get(type).push(name);
+    }
+    const channelSummary = Array.from(connectedGroups.entries())
+        .map(([type, names]) => names.length === 1 ? names[0] : `${type}[${names.join(', ')}]`)
+        .join(', ');
+    const totalCount = connected.length;
+    logger.info(`\n🚀 EvolClaw is running with ${totalCount} channel(s): ${channelSummary}\n`);
+    eventBus.publish({
+        type: 'system:started',
+        channels: connected.map(c => c.toLowerCase()),
+        timestamp: Date.now()
+    });
+    // 恢复重启前未完成的会话
+    const pendingSessions = sessionManager.getPendingProcessingSessions();
+    if (pendingSessions.length > 0) {
+        logger.info(`[Resume] Found ${pendingSessions.length} pending session(s) from before restart`);
+        for (const session of pendingSessions) {
+            if (!session.agentSessionId) {
+                sessionManager.clearProcessing(session.id);
+                continue;
             }
-            // 命令立即处理，不进入队列
-            if (cmdHandler.isCommand(content)) {
-                const cmdResult = await cmdHandler.handle(content, 'aun', sessionId, undefined, sessionId);
-                if (cmdResult) {
-                    await aun.sendMessage(sessionId, cmdResult);
-                    return;
-                }
+            const agent = agentMap.get(session.agentId) || agentMap.get(defaultAgent);
+            if (!agent) {
+                sessionManager.clearProcessing(session.id);
+                continue;
             }
-            // 获取当前项目路径
-            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);
-        });
+            logger.info(`[Resume] Resuming session: ${session.id} (agent: ${session.agentId})`);
+            const resumeMessage = {
+                channel: session.channel,
+                channelId: session.channelId,
+                content: '服务已重启，请继续之前未完成的任务。',
+                timestamp: Date.now(),
+                peerId: '',
+                threadId: session.threadId || undefined,
+                replyContext: session.metadata?.replyContext,
+            };
+            // 清除状态后入队（processMessage 会重新标记）
+            sessionManager.clearProcessing(session.id);
+            messageQueue.enqueue(session.id, resumeMessage, session.projectPath).catch(err => {
+                logger.error(`[Resume] Failed to resume session ${session.id}:`, err);
+            });
+        }
     }
-    // 连接渠道
-    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) {
+    // 重启通知：通过渠道 adapter 发送（channel-agnostic）
+    const pendingFile = path.join(resolvePaths().dataDir, 'restart-pending.json');
+    if (fs.existsSync(pendingFile)) {
         try {
-            if (timeout) {
-                await Promise.race([
-                    instance.connect(),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), timeout))
-                ]);
-            }
-            else {
-                await instance.connect();
+            const pending = JSON.parse(fs.readFileSync(pendingFile, 'utf-8'));
+            const adapter = cmdHandler.getAdapter(pending.channel);
+            if (adapter) {
+                const replyContext = pending.rootId
+                    ? { replyToMessageId: pending.rootId, replyInThread: true }
+                    : undefined;
+                await adapter.sendText(pending.channelId, '✅ 服务重启成功！', replyContext);
+                logger.info(`[Restart] Notification sent via ${pending.channel}`);
             }
-            logger.info(`✓ ${name} connected`);
-            channels.push(name);
+            fs.unlinkSync(pendingFile);
         }
-        catch (error) {
-            logger.warn(`⚠ ${name} connection failed (will continue without it)`);
-            if (error instanceof Error) {
-                logger.warn(`  Reason: ${error.message}`);
-            }
+        catch (e) {
+            logger.error('[Restart] Failed to send restart notification:', e);
         }
     }
-    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}`);
+    // IPC server — 供 CLI 查询实时状态
+    const ipcServer = new IpcServer(resolvePaths().socket, () => {
+        const channels = {};
+        const channelsByType = {};
+        for (const inst of channelInstances) {
+            const name = inst.adapter.channelName;
+            const status = inst.channel.getStatus?.() ?? { connected: true };
+            const channelType = inst.channelType || name;
+            channels[name] = { ...status, channelType };
+            if (!channelsByType[channelType])
+                channelsByType[channelType] = [];
+            channelsByType[channelType].push(name);
+        }
+        const snap = statsCollector.getSnapshot();
+        return {
+            pid: process.pid,
+            uptime: snap.uptimeMs,
+            channels,
+            channelsByType,
+            queue: {
+                pending: messageQueue.getGlobalQueueLength(),
+                processing: messageQueue.getGlobalProcessingCount(),
+            },
+            stats: {
+                received: snap.lastHour.received,
+                completed: snap.lastHour.completed,
+                errors: snap.lastHour.errors,
+                avgResponseMs: snap.lastHour.avgResponseMs,
+            },
+        };
+    });
+    ipcServer.start();
+    // 运行时配置文件监控
+    const configPath = resolvePaths().config;
+    fs.watchFile(configPath, { interval: 5000 }, (_curr, _prev) => {
+        let newConfig;
+        try {
+            newConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // JSON 解析失败 → 视为坏文件，备份内存中的好副本
+            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+            const backupPath = path.join(resolvePaths().dataDir, `evolclaw-${ts}.json`);
+            fs.writeFileSync(backupPath, JSON.stringify(config, null, 2));
+            logger.warn(`[Config Watch] Config file is not valid JSON. In-memory snapshot saved to ${backupPath}`);
+            eventBus.publish({ type: 'config:corrupted', backupPath, reasons: ['Invalid JSON'] });
+            return;
+        }
+        const result = validateConfigIntegrity(newConfig);
+        if (!result.valid) {
+            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+            const backupPath = path.join(resolvePaths().dataDir, `evolclaw-${ts}.json`);
+            fs.writeFileSync(backupPath, JSON.stringify(config, null, 2));
+            logger.warn(`[Config Watch] Bad config write detected. Reasons: ${result.reasons.join('; ')}. In-memory snapshot saved to ${backupPath}`);
+            eventBus.publish({ type: 'config:corrupted', backupPath, reasons: result.reasons });
+        }
+        else {
+            logger.debug(`[Config Watch] Config file modified, passes integrity check`);
+        }
+    });
     // 优雅关闭
-    const shutdown = async () => {
-        logger.info('\n\nShutting down gracefully...');
-        if (feishu)
-            await feishu.disconnect();
-        if (aun)
-            await aun.disconnect();
-        if (wechat)
-            await wechat.disconnect();
+    let shutdownSignal = 'unknown';
+    const shutdown = async (signal) => {
+        if (signal)
+            shutdownSignal = signal;
+        const pid = process.pid;
+        const ppid = process.ppid;
+        logger.info(`\n\nShutting down gracefully... (signal=${shutdownSignal}, pid=${pid}, ppid=${ppid})`);
+        fs.unwatchFile(configPath);
+        ipcServer.stop();
+        eventBus.publish({
+            type: 'system:shutdown',
+            timestamp: Date.now()
+        });
+        // 断开插件系统的渠道
+        await channelLoader.disconnectAll(channelInstances);
+        for (const inst of channelInstances) {
+            const type = inst.channelType || inst.adapter.channelName;
+            eventBus.publish({ type: 'channel:disconnected', channel: type, channelName: inst.adapter.channelName, reason: 'shutdown' });
+        }
         sessionManager.close();
         logger.info('✓ Shutdown complete');
         process.exit(0);
     };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
 }
 main().catch((error) => {
+    const msg = `Fatal error: ${error?.stack || error}`;
     logger.error('Fatal error:', error);
+    console.error(msg); // ensure it lands in stdout.log for self-heal diagnostics
     process.exit(1);
 });