evolclaw 2.2.0 → 2.3.0

package/dist/core/session/adapters/gemini-session-file-adapter.js

@@ -0,0 +1,177 @@
+/**
+ * Gemini SessionFileAdapter
+ *
+ * Reads Gemini CLI session files from ~/.gemini/tmp/{project}/chats/.
+ * Gemini stores sessions as JSON files with naming convention:
+ *   session-{YYYY-MM-DDTHH-mm}-{uuid-prefix}.json
+ *
+ * Each file contains:
+ *   { sessionId, projectHash, startTime, lastUpdated, messages, kind }
+ *
+ * Messages have type: 'user' | 'gemini' (not 'role').
+ */
+import { logger } from '../../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class GeminiSessionFileAdapter {
+    agentId = 'gemini';
+    getGeminiHome() {
+        return path.join(os.homedir(), '.gemini');
+    }
+    /**
+     * Resolve Gemini project key for a project path.
+     * Priority:
+     * 1. ~/.gemini/projects.json explicit mapping
+     * 2. .project_root file content match under ~/.gemini/tmp/<project-key>/
+     * 3. basename(projectPath) fallback
+     */
+    resolveProjectKey(projectPath) {
+        const geminiHome = this.getGeminiHome();
+        const projectsPath = path.join(geminiHome, 'projects.json');
+        try {
+            if (fs.existsSync(projectsPath)) {
+                const data = JSON.parse(fs.readFileSync(projectsPath, 'utf-8'));
+                const mapped = data?.projects?.[projectPath];
+                if (typeof mapped === 'string' && mapped.trim())
+                    return mapped;
+            }
+        }
+        catch (error) {
+            logger.debug('[GeminiAdapter] Failed to read projects.json:', error);
+        }
+        const tmpDir = path.join(geminiHome, 'tmp');
+        if (fs.existsSync(tmpDir)) {
+            try {
+                for (const entry of fs.readdirSync(tmpDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const rootFile = path.join(tmpDir, entry.name, '.project_root');
+                    if (!fs.existsSync(rootFile))
+                        continue;
+                    try {
+                        const content = fs.readFileSync(rootFile, 'utf-8').trim();
+                        if (content === projectPath)
+                            return entry.name;
+                    }
+                    catch {
+                        // ignore broken .project_root
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug('[GeminiAdapter] Failed to scan tmp project roots:', error);
+            }
+        }
+        return path.basename(projectPath);
+    }
+    /**
+     * Resolve the Gemini chats directory for a given project path.
+     */
+    resolveChatsDir(projectPath) {
+        const geminiHome = this.getGeminiHome();
+        const projectKey = this.resolveProjectKey(projectPath);
+        return path.join(geminiHome, 'tmp', projectKey, 'chats');
+    }
+    /**
+     * Find the session file matching a given session UUID.
+     * Gemini files are named session-{date}-{uuid-prefix}.json where
+     * uuid-prefix is the first 8 chars of the session UUID.
+     */
+    findSessionFile(projectPath, agentSessionId) {
+        const chatsDir = this.resolveChatsDir(projectPath);
+        if (!fs.existsSync(chatsDir))
+            return null;
+        const uuidPrefix = agentSessionId.substring(0, 8);
+        try {
+            const files = fs.readdirSync(chatsDir);
+            const match = files.find(f => f.includes(uuidPrefix) && f.endsWith('.json'));
+            return match ? path.join(chatsDir, match) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    readSessionData(projectPath, agentSessionId) {
+        const filePath = this.findSessionFile(projectPath, agentSessionId);
+        if (!filePath)
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch (error) {
+            logger.warn(`[GeminiAdapter] Failed to read session file: ${filePath}`, error);
+            return null;
+        }
+    }
+    checkExists(projectPath, agentSessionId) {
+        return this.findSessionFile(projectPath, agentSessionId) !== null;
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        const data = this.readSessionData(projectPath, agentSessionId);
+        if (!data)
+            return { turns: 0 };
+        const msgs = data.messages || [];
+        const userTurns = msgs.filter((m) => m.type === 'user').length;
+        // Extract title from first user message
+        let title;
+        const firstUser = msgs.find((m) => m.type === 'user');
+        if (firstUser) {
+            const text = Array.isArray(firstUser.content)
+                ? firstUser.content[0]?.text || ''
+                : String(firstUser.content || '');
+            title = text.substring(0, 50).trim() || undefined;
+        }
+        return { turns: userTurns, title };
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        return this.readUserMessage(projectPath, agentSessionId, 'first');
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        return this.readUserMessage(projectPath, agentSessionId, 'last');
+    }
+    scanCliSessions(projectPath) {
+        const chatsDir = this.resolveChatsDir(projectPath);
+        if (!fs.existsSync(chatsDir))
+            return [];
+        try {
+            const files = fs.readdirSync(chatsDir)
+                .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+                .map(f => {
+                const filePath = path.join(chatsDir, f);
+                const stat = fs.statSync(filePath);
+                // Extract UUID from filename: session-{date}-{uuid-prefix}.json
+                // Read the file to get full UUID
+                try {
+                    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    return { uuid: data.sessionId, mtime: stat.mtimeMs };
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((e) => e !== null)
+                .sort((a, b) => b.mtime - a.mtime)
+                .slice(0, 10);
+            return files;
+        }
+        catch (error) {
+            logger.warn('[GeminiAdapter] scanCliSessions failed:', error);
+            return [];
+        }
+    }
+    readUserMessage(projectPath, agentSessionId, which) {
+        const data = this.readSessionData(projectPath, agentSessionId);
+        if (!data)
+            return null;
+        const msgs = (data.messages || []).filter((m) => m.type === 'user');
+        if (msgs.length === 0)
+            return null;
+        const msg = which === 'first' ? msgs[0] : msgs[msgs.length - 1];
+        const text = Array.isArray(msg.content)
+            ? msg.content[0]?.text || ''
+            : String(msg.content || '');
+        const trimmed = text.trim().replace(/\s+/g, ' ');
+        return trimmed.substring(0, 50) + (trimmed.length > 50 ? '...' : '');
+    }
+}

package/dist/{utils → core/session}/session-file-health.js

@@ -1,5 +1,5 @@
 import fsPromises from 'fs/promises';
-import { logger } from './logger.js';
+import { logger } from '../../utils/logger.js';
 /**
  * 检查会话文件健康度（接收完整文件路径）
  */

package/dist/core/{session-manager.js → session/session-manager.js}

@@ -1,10 +1,9 @@
 import { DatabaseSync } from 'node:sqlite';
-import { ensureDir } from '../config.js';
-import { resolvePaths } from '../paths.js';
-import { logger } from '../utils/logger.js';
-import { encodePath } from '../utils/cross-platform.js';
+import { ensureDir } from '../../config.js';
+import { resolvePaths } from '../../paths.js';
+import { logger } from '../../utils/logger.js';
+import { encodePath } from '../../utils/cross-platform.js';
 import path from 'path';
-import fs from 'fs';
 import os from 'os';
 export class SessionManager {
     db;
@@ -93,12 +92,10 @@ export class SessionManager {
         const agentId = row.agent_id || 'claude';
         const adapter = this.getFileAdapter(agentId);
         if (!adapter) {
-            // 无适配器时回退到 Claude 路径检查
-            const sessionFile = this.getSessionFilePath(row.project_path, agentSessionId);
-            if (fs.existsSync(sessionFile))
-                return agentSessionId;
+            // 无适配器：无法验证文件，信任 DB 记录
+            return agentSessionId;
         }
-        else if (adapter.checkExists(row.project_path, agentSessionId)) {
+        if (adapter.checkExists(row.project_path, agentSessionId)) {
             return agentSessionId;
         }
         logger.warn(`Session file not found for ${agentId}: ${agentSessionId}, clearing session ID`);
@@ -348,6 +345,29 @@ export class SessionManager {
       CREATE INDEX IF NOT EXISTS idx_session_health_safe_mode ON session_health(safe_mode);
     `);
     }
+    /**
+     * 启动时迁移：将 sessions.channel 从 channelType 回填为实例名（channelName）。
+     * 读取每行 metadata.channelName，若与 channel 列不同则更新。
+     */
+    migrateChannelToInstanceName() {
+        const rows = this.db.prepare(`SELECT id, channel, metadata FROM sessions WHERE metadata IS NOT NULL AND metadata != ''`).all();
+        let migrated = 0;
+        for (const row of rows) {
+            try {
+                const meta = JSON.parse(row.metadata);
+                if (meta.channelName && meta.channelName !== row.channel) {
+                    this.db.prepare(`UPDATE sessions SET channel = ?, updated_at = ? WHERE id = ?`)
+                        .run(meta.channelName, Date.now(), row.id);
+                    migrated++;
+                    logger.info(`[Migration] Restored channel '${row.channel}' -> '${meta.channelName}' (session ${row.id})`);
+                }
+            }
+            catch { /* skip invalid metadata */ }
+        }
+        if (migrated > 0) {
+            logger.info(`Channel instance name migration completed (${migrated} sessions updated)`);
+        }
+    }
     /**
      * 获取指定渠道所有已知的 thread_id（用于重启后预填充 seenThreads）
      */
@@ -402,6 +422,12 @@ export class SessionManager {
         if (threadId) {
             const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId);
             session.identity = this.resolveIdentity(channel, userId);
+            // 新话题会话补写默认权限模式
+            if (session.metadata && !session.metadata.permissionMode) {
+                session.metadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+                this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
+                    .run(JSON.stringify(session.metadata), Date.now(), session.id);
+            }
             return session;
         }
         // 主会话：查找活跃会话
@@ -413,7 +439,7 @@ export class SessionManager {
             const validSessionId = this.validateSessionFile(active);
             const session = { ...this.rowToSession(active), agentSessionId: validSessionId };
             session.identity = this.resolveIdentity(channel, userId);
-            // 补写 peerId/peerName（私聊 session 可能在此字段引入前创建）
+            // 补写 peerId/peerName/channelName（旧 session 可能在这些字段引入前创建）
             if (chatType === 'private' && userId) {
                 const activeMeta = active.metadata ? JSON.parse(active.metadata) : {};
                 let updated = false;
@@ -425,12 +451,26 @@ export class SessionManager {
                     activeMeta.peerName = metadata.peerName;
                     updated = true;
                 }
+                if (metadata?.channelName && activeMeta.channelName !== metadata.channelName) {
+                    activeMeta.channelName = metadata.channelName;
+                    updated = true;
+                }
                 if (updated) {
                     this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
                         .run(JSON.stringify(activeMeta), Date.now(), active.id);
                     session.metadata = activeMeta;
                 }
             }
+            // 补写 channelName（非私聊时也需要）
+            if (metadata?.channelName && chatType !== 'private') {
+                const activeMeta = active.metadata ? JSON.parse(active.metadata) : {};
+                if (activeMeta.channelName !== metadata.channelName) {
+                    activeMeta.channelName = metadata.channelName;
+                    this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
+                        .run(JSON.stringify(activeMeta), Date.now(), active.id);
+                    session.metadata = activeMeta;
+                }
+            }
             return session;
         }
         // 查找默认项目的主会话
@@ -474,6 +514,10 @@ export class SessionManager {
             updatedAt: Date.now()
         };
         session.identity = this.resolveIdentity(channel, userId);
+        // 写入默认权限模式（基于角色，只在首次创建时设置）
+        if (!sessionMetadata.permissionMode) {
+            sessionMetadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+        }
         this.insertSession(session);
         this.eventBus.publish({
             type: 'session:created',
@@ -966,6 +1010,8 @@ export class SessionManager {
       VALUES (?, 0, 0, ?, ?, ?)
       ON CONFLICT(session_id) DO UPDATE SET
         consecutive_errors = 0,
+        last_error = NULL,
+        last_error_type = NULL,
         last_success_time = ?,
         updated_at = ?
     `).run(sessionId, now, now, now, now, now);

package/dist/index.js

@@ -1,23 +1,26 @@
-import { ClaudeSessionFileAdapter } from './core/adapters/claude-session-file-adapter.js';
-import { CodexSessionFileAdapter } from './core/adapters/codex-session-file-adapter.js';
-import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, validateConfigIntegrity } from './config.js';
-import { SessionManager } from './core/session-manager.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-processor.js';
-import { MessageQueue } from './core/message-queue.js';
-import { MessageBridge } from './core/message-bridge.js';
-import { MessageCache } from './utils/message-cache.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 './core/stats-collector.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 './core/ipc-server.js';
+import { IpcServer } from './ipc.js';
 import { logger } from './utils/logger.js';
 import path from 'path';
 import fs from 'fs';
@@ -54,6 +57,8 @@ async function main() {
     }
     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}`);
     }
@@ -70,10 +75,12 @@ async function main() {
     // 注册会话文件适配器（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);
@@ -93,6 +100,8 @@ async function main() {
     // 权限审批网关
     const permissionGateway = new PermissionGateway();
     permissionGateway.setEventBus(eventBus);
+    // 交互路由器
+    const interactionRouter = new InteractionRouter();
     // 为所有支持权限的 agent 设置 gateway
     for (const inst of agentInstances) {
         inst.agent.setPermissionGateway?.(permissionGateway);
@@ -111,9 +120,12 @@ async function main() {
     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, agentMap, config, messageCache, eventBus, defaultAgent);
     cmdHandler.setPermissionGateway(permissionGateway);
+    cmdHandler.setInteractionRouter(interactionRouter);
     cmdHandler.setStatsCollector(statsCollector);
     // 创建消息处理器
     const processor = new MessageProcessor(agentMap, sessionManager, config, messageCache, eventBus, (content, channel, channelId, userId, threadId) => {
@@ -129,6 +141,8 @@ async function main() {
     }, defaultAgent);
     // 回填 processor 和 messageQueue 的引用
     cmdHandler.setProcessor(processor);
+    // 设置交互路由器
+    processor.setInteractionRouter(interactionRouter);
     // 设置 compact 开始回调（对所有支持的 agent）
     for (const inst of agentInstances) {
         inst.agent.setCompactStartCallback?.((sessionId) => {
@@ -166,18 +180,27 @@ async function main() {
         // 设置项目路径提供器（如果需要）
         if (inst.onProjectPathRequest && inst.channel.onProjectPathRequest) {
             inst.channel.onProjectPathRequest(async (channelId) => {
-                const session = await sessionManager.getOrCreateSession(inst.adapter.name, channelId, config.projects?.defaultPath || process.cwd(), undefined, undefined, undefined, undefined);
+                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
-        processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, inst.options);
+        // 注册 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.name, inst.channel);
+        cmdHandler.registerChannel(inst.adapter.channelName, inst.channel, inst.channelType);
         if (inst.policy) {
-            cmdHandler.registerPolicy(inst.adapter.name, inst.policy);
+            cmdHandler.registerPolicy(inst.adapter.channelName, inst.policy);
+        }
+        // 注册交互回调：渠道收到用户操作后路由到 InteractionRouter
+        if (inst.adapter.onInteraction) {
+            inst.adapter.onInteraction((response) => {
+                interactionRouter.handle(response);
+            });
         }
     }
     // ── MessageBridge：Channel ↔ Core 消息桥梁 ──
@@ -185,86 +208,134 @@ async function main() {
     // ── 渠道消息注册 ──
     // 连接插件系统的渠道
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'feishu') {
-            msgBridge.register('feishu', (handler) => inst.channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, threadId, rootId, chatType }) => {
-                handler({
-                    channel: 'feishu', channelId: chatId, content, images, chatType,
+        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);
+            }), inst.adapter, channelType);
             inst.channel.onRecall?.((messageId) => {
                 msgBridge.cancel(messageId);
             });
         }
-        if (inst.adapter.name === 'wechat') {
-            msgBridge.register('wechat', (handler) => inst.channel.onMessage(async (channelId, content, peerId, images, chatType) => {
+        if (channelType === 'wechat') {
+            // 注入 EventBus（用于 channel:health 事件）
+            if (inst.channel.setEventBus) {
+                inst.channel.setEventBus(eventBus);
+            }
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (channelId, content, peerId, images, chatType) => {
                 handler({
-                    channel: 'wechat',
+                    channel: channelType,
                     channelId,
                     content,
                     images,
                     chatType: chatType || 'private',
                     peerId: peerId || '',
                 });
-            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter);
+            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter, channelType);
         }
-        if (inst.adapter.name === 'aun') {
-            msgBridge.register('aun', (handler) => inst.channel.onMessage(async (opts) => {
+        if (channelType === 'aun') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (opts) => {
                 handler({
-                    channel: 'aun',
+                    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);
+            }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, replyContext), inst.adapter, channelType);
         }
     }
     // ── 连接所有渠道 ──
     const connected = await channelLoader.connectAll(channelInstances);
     // 预填充 Feishu 已知 thread_id（重启后避免误判话题创建）
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'feishu' && 'preloadThreads' in inst.channel) {
-            const threadIds = sessionManager.getKnownThreadIds('feishu');
+        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: name.toLowerCase(),
+            channel: type.toLowerCase(),
+            channelName: name,
             timestamp: Date.now()
         });
     }
-    // AUN 重连失败通知：通过其他渠道给 owner 发消息
+    // AUN 重连失败通知：通过 channel:health 事件
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'aun' && inst.channel.setOnChannelDown) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'aun' && inst.channel.setOnChannelDown) {
             inst.channel.setOnChannelDown(() => {
-                logger.error('[AUN] All reconnect attempts exhausted, notifying owners');
-                const msg = '⚠️ AUN 渠道断连，自动重试已用尽。\n使用 /check reconnect 手动重连';
-                for (const other of channelInstances) {
-                    if (other.adapter.name === inst.adapter.name)
-                        continue;
-                    const ownerCfg = config.channels?.[other.adapter.name];
-                    const ownerId = ownerCfg?.owner;
-                    if (ownerId) {
-                        other.adapter.sendText(ownerId, msg).catch(err => {
-                            logger.error(`[AUN] Failed to notify ${other.adapter.name} owner:`, err);
-                        });
-                    }
-                }
+                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);
     }
-    logger.info(`\n🚀 EvolClaw is running with ${connected.length} channel(s): ${connected.join(', ')}\n`);
+    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()),
@@ -327,15 +398,22 @@ async function main() {
     // IPC server — 供 CLI 查询实时状态
     const ipcServer = new IpcServer(resolvePaths().socket, () => {
         const channels = {};
+        const channelsByType = {};
         for (const inst of channelInstances) {
-            const name = inst.adapter.name;
-            channels[name] = inst.channel.getStatus?.() ?? { connected: true };
+            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(),
@@ -378,8 +456,13 @@ async function main() {
         }
     });
     // 优雅关闭
-    const shutdown = async () => {
-        logger.info('\n\nShutting down gracefully...');
+    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({
@@ -389,14 +472,15 @@ async function main() {
         // 断开插件系统的渠道
         await channelLoader.disconnectAll(channelInstances);
         for (const inst of channelInstances) {
-            eventBus.publish({ type: 'channel:disconnected', channel: inst.adapter.name, reason: 'shutdown' });
+            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}`;