evolclaw 2.1.2 → 2.2.0

package/dist/core/command-handler.js

@@ -1,10 +1,9 @@
-import { renameSession as sdkRenameSession, forkSession as sdkForkSession, listSessions as sdkListSessions } from '@anthropic-ai/claude-agent-sdk';
-import { resolvePaths, getPackageRoot } from '../config.js';
+import { hasModelSwitcher, hasPermissionController } from '../agents/claude-runner.js';
+import { saveConfig, resolvePaths, getPackageRoot, getOwner } from '../config.js';
 import { logger } from '../utils/logger.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
-const availableModels = ['opus', 'sonnet', 'haiku', 'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001'];
 const availableEfforts = ['low', 'medium', 'high', 'max'];
 function effortBar(level) {
     const levels = {
@@ -85,30 +84,48 @@ function formatIdleTime(ms) {
     return '刚刚';
 }
 // 支持的命令列表
-const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork', '/del'];
+const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/agent', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork', '/del', '/perm', '/send', '/check'];
 // 命令别名映射
 const aliases = {
     '/p': '/project',
     '/s': '/session',
     '/name': '/rename'
 };
-// 命令快速路径前缀（不进入消息队列的命令）
-// 注意：/clear, /compact, /safe 故意不在此列表中，它们需要进入队列触发中断机制
-// /stop 是快速命令：直接调用 agentRunner.interrupt()，不走队列（否则队列自动中断后 /stop 检测不到活跃任务）
-const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/repair', '/fork', '/stop', '/del', '/p ', '/s ', '/name '];
+// 命令快速路径前缀（所有命令都不进入消息队列）
+const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/agent', '/slist', '/session', '/rename', '/repair', '/fork', '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/send', '/check', '/p ', '/s ', '/name '];
 export class CommandHandler {
     sessionManager;
-    agentRunner;
     config;
     messageCache;
+    eventBus;
     adapters = new Map();
+    policies = new Map();
+    channelObjects = new Map(); // name → actual channel instance (for /check)
     processor;
     messageQueue;
-    constructor(sessionManager, agentRunner, config, messageCache) {
+    permissionGateway;
+    statsCollector;
+    agentMap;
+    defaultAgentId;
+    /** 按 agentId 获取 agent，回退到默认 */
+    getAgent(agentId) {
+        if (agentId && this.agentMap.has(agentId))
+            return this.agentMap.get(agentId);
+        return this.agentMap.get(this.defaultAgentId) || this.agentMap.values().next().value;
+    }
+    constructor(sessionManager, agentRunnerOrMap, config, messageCache, eventBus, defaultAgentId) {
         this.sessionManager = sessionManager;
-        this.agentRunner = agentRunner;
         this.config = config;
         this.messageCache = messageCache;
+        this.eventBus = eventBus;
+        if (agentRunnerOrMap instanceof Map) {
+            this.agentMap = agentRunnerOrMap;
+            this.defaultAgentId = defaultAgentId || 'claude';
+        }
+        else {
+            this.agentMap = new Map([[agentRunnerOrMap.name, agentRunnerOrMap]]);
+            this.defaultAgentId = agentRunnerOrMap.name;
+        }
     }
     /** 项目列表快捷访问 */
     get projects() {
@@ -122,22 +139,37 @@ export class CommandHandler {
     getProjectName(projectPath) {
         return this.getConfiguredProjectName(projectPath) || path.basename(projectPath);
     }
+    /** 格式化运行时间 */
+    formatUptime(ms) {
+        const sec = Math.floor(ms / 1000);
+        const d = Math.floor(sec / 86400);
+        const h = Math.floor((sec % 86400) / 3600);
+        const m = Math.floor((sec % 3600) / 60);
+        const parts = [];
+        if (d > 0)
+            parts.push(`${d}天`);
+        if (h > 0)
+            parts.push(`${h}时`);
+        parts.push(`${m}分`);
+        return parts.join('');
+    }
     /** 获取消息队列 key：话题用 session.id，主会话用 channel-channelId */
-    getQueueKey(session, channel, channelId) {
-        if (session?.threadId)
-            return session.id;
-        return `${channel}-${channelId}`;
+    getQueueKey(session, _channel, _channelId) {
+        // 队列和 agent 均使用 session.id 作为 key
+        return session?.id || '';
     }
-    /** 从 session 提取话题回复选项 */
-    getThreadSendOpts(session) {
-        const rootId = session.metadata?.feishu?.rootId;
-        return rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined;
+    /** 从 session 提取渠道预构建的回复上下文 */
+    getReplyContext(session) {
+        return session.metadata?.replyContext;
     }
     /** 获取活跃会话，无会话时返回统一错误提示 */
     async ensureSession(channel, channelId, threadId) {
         if (threadId) {
-            // 话题会话：按 thread_id 查找
-            const session = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
+            // 话题会话：仅查询，不创建
+            const session = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+            if (!session) {
+                return { error: '❌ 话题中尚未创建会话\n发送消息后自动创建' };
+            }
             return { session };
         }
         const session = await this.sessionManager.getActiveSession(channel, channelId);
@@ -152,12 +184,112 @@ export class CommandHandler {
     setMessageQueue(messageQueue) {
         this.messageQueue = messageQueue;
     }
+    setPermissionGateway(gateway) {
+        this.permissionGateway = gateway;
+    }
+    setStatsCollector(collector) {
+        this.statsCollector = collector;
+    }
     registerAdapter(adapter) {
         this.adapters.set(adapter.name, adapter);
     }
+    registerChannel(name, channel) {
+        this.channelObjects.set(name, channel);
+    }
+    registerPolicy(channelName, policy) {
+        this.policies.set(channelName, policy);
+    }
     getAdapter(channelName) {
         return this.adapters.get(channelName);
     }
+    getPolicy(channel) {
+        return this.policies.get(channel) || {
+            canSwitchProject: () => true,
+            canListProjects: () => true,
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: () => true,
+            messagePrefix: () => '',
+            showMiddleResult: () => true,
+            showIdleMonitor: () => true,
+            accumulateErrors: () => true,
+        };
+    }
+    /**
+     * 返回结构化命令菜单（供 menu.query 使用）
+     * admin 看到全部命令分组，guest 仅看到用户级命令
+     */
+    getMenuItems(isAdmin) {
+        const items = [];
+        if (isAdmin) {
+            items.push({
+                group: '项目管理',
+                commands: [
+                    { cmd: '/pwd', label: '显示当前项目路径' },
+                    { cmd: '/plist', label: '列出所有配置的项目' },
+                    { cmd: '/p', args: '<name|path>', label: '切换项目' },
+                    { cmd: '/bind', args: '<path>', label: '绑定新项目目录' },
+                ]
+            });
+        }
+        items.push({
+            group: '会话管理',
+            commands: [
+                { cmd: '/new', args: '[name]', label: '创建新会话' },
+                { cmd: '/slist', label: '列出当前项目的所有会话' },
+                { cmd: '/s', args: '<name|index|uuid>', label: '切换到指定会话' },
+                { cmd: '/name', args: '<name>', label: '重命名当前会话' },
+                { cmd: '/del', args: '<name>', label: '删除指定会话' },
+                ...(isAdmin ? [
+                    { cmd: '/fork', args: '[name]', label: '分支当前会话' },
+                    { cmd: '/clear', label: '清空会话对话历史' },
+                    { cmd: '/compact', label: '压缩会话上下文' },
+                ] : []),
+            ]
+        });
+        if (isAdmin) {
+            items.push({
+                group: 'Agent 与模型',
+                commands: [
+                    { cmd: '/agent', args: '[name]', label: '查看或切换 Agent 后端' },
+                    { cmd: '/model', args: '[model] [effort]', label: '查看或切换模型' },
+                ]
+            });
+            items.push({
+                group: '权限管理',
+                commands: [
+                    { cmd: '/perm', args: '[mode|allow|deny]', label: '权限模式管理' },
+                ]
+            });
+            items.push({
+                group: '运维',
+                commands: [
+                    { cmd: '/status', label: '显示会话状态' },
+                    { cmd: '/stop', label: '中断当前任务' },
+                    { cmd: '/restart', label: '重启服务' },
+                    { cmd: '/repair', label: '检查并修复会话' },
+                    { cmd: '/safe', label: '进入安全模式' },
+                    { cmd: '/send', args: '[渠道] <path>', label: '发送项目内文件' },
+                    { cmd: '/check', args: '[rty <channel>]', label: '检查渠道状态或重连指定渠道' },
+                ]
+            });
+        }
+        else {
+            items.push({
+                group: '其他',
+                commands: [
+                    { cmd: '/status', label: '显示会话状态' },
+                ]
+            });
+        }
+        items.push({
+            group: '帮助',
+            commands: [
+                { cmd: '/help', label: '显示帮助信息' },
+            ]
+        });
+        return items;
+    }
     /**
      * 快速判断是否为命令（不进队列的命令）
      */
@@ -168,6 +300,12 @@ export class CommandHandler {
      * 主命令处理入口
      */
     async handle(content, channel, channelId, sendMessage, userId, threadId) {
+        // 解析身份
+        const identity = this.sessionManager.resolveIdentity(channel, userId);
+        const policy = this.getPolicy(channel);
+        // 按当前会话选择 agent 后端
+        const activeSession = await this.sessionManager.getActiveSession(channel, channelId);
+        const agent = this.getAgent(activeSession?.agentId);
         // 规范化命令（将别名转换为完整命令）
         let normalizedContent = content;
         for (const [alias, full] of Object.entries(aliases)) {
@@ -176,16 +314,19 @@ export class CommandHandler {
                 break;
             }
         }
-        // 权限检查：区分用户级命令和管理级命令
-        const { isOwner: checkOwner } = await import('../config.js');
+        if (normalizedContent !== content) {
+            logger.debug(`[CommandHandler] normalized: "${content}" -> "${normalizedContent}"`);
+        }
         // 话题内禁用部分命令
         if (threadId) {
-            const threadBlocked = ['/new', '/slist', '/plist', '/bind', '/s', '/session', '/project', '/p', '/fork', '/del'];
+            const threadBlocked = ['/new', '/slist', '/plist', '/bind', '/s', '/session', '/project', '/p', '/fork', '/del', '/agent'];
             const isBlocked = threadBlocked.some(c => normalizedContent === c || normalizedContent.startsWith(c + ' '));
-            if (isBlocked)
+            if (isBlocked) {
                 return '⚠️ 话题中不支持此命令';
+            }
         }
-        const isAdmin = !userId || checkOwner(this.config, channel, userId);
+        // 权限检查：区分用户级命令和管理级命令
+        const isAdmin = identity.role === 'owner';
         if (normalizedContent.startsWith('/')) {
             const userCommands = ['/slist', '/new', '/session', '/rename', '/name', '/status', '/help', '/del', '/s '];
             const isUserCommand = userCommands.some(cmd => normalizedContent === cmd.trimEnd() || normalizedContent.startsWith(cmd));
@@ -193,6 +334,23 @@ export class CommandHandler {
                 return '❌ 无权限：此命令仅限管理员使用';
             }
         }
+        // 空闲检查：某些命令需要等待当前会话空闲
+        const requiresIdle = ['/new', '/clear', '/compact', '/safe', '/repair', '/fork', '/bind'];
+        if (requiresIdle.some(cmd => normalizedContent === cmd || normalizedContent.startsWith(cmd + ' '))) {
+            if (threadId) {
+                // 话题中：检查话题 session 是否在处理（不创建）
+                const threadSession = await this.sessionManager.getThreadSession(channel, channelId, threadId);
+                if (threadSession) {
+                    const threadAgent = this.getAgent(threadSession.agentId);
+                    if (threadAgent.hasActiveStream(threadSession.id)) {
+                        return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+                    }
+                }
+            }
+            else if (activeSession && agent.hasActiveStream(activeSession.id)) {
+                return '⚠️ 当前正在处理消息，请稍后再试\n使用 /stop 中断当前任务后重试';
+            }
+        }
         // 检查是否以 / 开头（可能是命令）
         if (normalizedContent.startsWith('/')) {
             const inputCmd = normalizedContent.split(' ')[0];
@@ -216,56 +374,171 @@ export class CommandHandler {
         // /help 命令不需要会话
         if (normalizedContent === '/help') {
             if (!isAdmin) {
-                return `可用命令：
-🔄 会话管理：
-  /new [名称] - 创建新会话（可选命名）
-  /slist - 列出当前项目的所有会话
-  /s, /session <名称> - 切换到指定会话
-  /name, /rename <新名称> - 重命名当前会话
-  /del <名称> - 删除指定会话（仅解绑，不删除文件）
-  /status - 显示会话状态
-
-❓ 帮助：
-  /help - 显示此帮助信息`;
-            }
-            return `可用命令：
-📁 项目管理：
-  /pwd - 显示当前项目路径
-  /plist - 列出所有配置的项目
-  /p, /project <name|path> - 切换项目
-  /bind <path> - 绑定新项目目录
-
-🔄 会话管理：
-  /new [名称] - 创建新会话（可选命名）
-  /slist - 列出当前项目的所有会话
-  /s, /session <名称> - 切换到指定会话
-  /name, /rename <新名称> - 重命名当前会话
-  /del <名称> - 删除指定会话（仅解绑，不删除文件）
-  /fork [名称] - 分支当前会话（从当前对话点创建分支）
-  /status - 显示会话状态
-  /clear - 清空当前会话的对话历史
-  /compact - 压缩会话上下文（减少 token 用量）
-  /stop - 中断当前任务
-  /restart - 重启服务
-
-🛠️ 会话修复：
-  /repair - 检查并修复会话
-  /safe - 进入安全模式
-
-🤖 模型管理：
-  /model [model] [effort] - 查看或切换模型/推理强度
-
-❓ 帮助：
-  /help - 显示此帮助信息`;
+                const lines = [
+                    '可用命令：',
+                    '',
+                    '🔄 会话管理：',
+                    '  /new [名称] - 创建新会话（可选命名）',
+                    '  /slist - 列出当前项目的所有会话',
+                    '  /s, /session <名称|序号|uuid> - 切换到指定会话',
+                    '  /name, /rename <新名称> - 重命名当前会话',
+                    '  /del <名称> - 删除指定会话（仅解绑，不删除文件）',
+                    '  /status - 显示会话状态',
+                    '',
+                    '❓ 帮助：',
+                    '  /help - 显示此帮助信息',
+                ];
+                return lines.join('\n');
+            }
+            const lines = [
+                '可用命令：',
+                '',
+                '📁 项目管理：',
+                '  /pwd - 显示当前项目路径',
+                '  /plist - 列出所有配置的项目',
+                '  /p, /project <name|path> - 切换项目',
+                '  /bind <path> - 绑定新项目目录',
+                '',
+                '🔄 会话管理：',
+                '  /new [名称] - 创建新会话（可选命名）',
+                '  /slist - 列出当前项目的所有会话',
+                '  /s, /session <名称> - 切换到指定会话',
+                '  /name, /rename <新名称> - 重命名当前会话',
+                '  /del <名称> - 删除指定会话（仅解绑，不删除文件）',
+                '  /fork [名称] - 分支当前会话（从当前对话点创建分支）',
+                '  /clear - 清空当前会话的对话历史',
+                '  /compact - 压缩会话上下文（减少 token 用量）',
+                '',
+                '🤖 Agent 与模型：',
+                '  /agent [name] - 查看或切换 Agent 后端',
+                '  /model [model] [effort] - 查看或切换模型/推理强度',
+                '',
+                '🔐 权限管理：',
+                '  /perm - 查看当前权限模式',
+                '  /perm <default|request|edit|plan|noask> - 切换权限模式',
+                '  /perm allow|deny - 审批权限请求',
+                '',
+                '🛠️ 运维：',
+                '  /status - 显示会话状态',
+                '  /stop - 中断当前任务',
+                '  /restart - 重启服务',
+                '  /repair - 检查并修复会话',
+                '  /safe - 进入安全模式',
+                '  /send [渠道] <路径> - 发送项目内文件',
+                '',
+                '❓ 帮助：',
+                '  /help - 显示此帮助信息',
+            ];
+            return lines.join('\n');
+        }
+        // /perm 命令：权限模式切换 + 权限审批（快速路径，不进入消息队列）
+        if (normalizedContent.startsWith('/perm')) {
+            const args = normalizedContent.slice(5).trim();
+            // 先获取正确的 session 和 agent（话题可能用不同 agent）
+            const permResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in permResult)
+                return permResult.error;
+            const { session: permSession } = permResult;
+            const permAgent = this.getAgent(permSession.agentId);
+            // /perm（无参数）：显示当前模式和可选模式
+            if (!args) {
+                if (!hasPermissionController(permAgent)) {
+                    return '❌ 权限控制不可用';
+                }
+                const currentMode = permSession.metadata?.permissionMode || 'default';
+                const modes = permAgent.listModes();
+                const modeList = modes.map(m => {
+                    const prefix = m.key === currentMode ? '▶' : ' ';
+                    const suffix = m.available ? '' : ' ⚠️ 不可用';
+                    return `  ${prefix} ${m.key} (${m.nameZh}) - ${m.description}${suffix}`;
+                }).join('\n');
+                return `🔐 当前权限模式: ${currentMode}\n\n${modeList}\n\n用法:\n  /perm <模式>       切换权限模式\n  /perm allow|deny   审批权限请求`;
+            }
+            const parts = args.split(/\s+/);
+            // /perm <mode> 或 /perm allow|deny：切换模式 / 快捷审批
+            if (parts.length === 1) {
+                const arg = parts[0];
+                // /perm allow|deny：快捷审批（自动找当前 session 唯一的 pending 请求）
+                if (arg === 'allow' || arg === 'deny') {
+                    if (!this.permissionGateway) {
+                        return '❌ 权限审批未启用';
+                    }
+                    const pendingIds = this.permissionGateway.getPendingRequests(permSession.id);
+                    if (pendingIds.length === 0) {
+                        return '❌ 当前没有待审批的权限请求';
+                    }
+                    if (pendingIds.length > 1) {
+                        return `❌ 当前有 ${pendingIds.length} 个待审批请求，请指定 requestId：\n${pendingIds.map(id => `  /perm ${id} ${arg}`).join('\n')}`;
+                    }
+                    const requestId = pendingIds[0];
+                    this.permissionGateway.resolvePermission(permSession.id, requestId, arg === 'allow');
+                    return arg === 'allow' ? `✓ 已授权，继续执行……` : `✓ 已拒绝`;
+                }
+                // /perm <mode>：切换权限模式
+                if (hasPermissionController(permAgent)) {
+                    const modes = permAgent.listModes();
+                    const matched = modes.find(m => m.key === arg);
+                    if (matched) {
+                        if (!matched.available) {
+                            return `❌ ${matched.key} 模式当前不可用：${matched.unavailableReason}`;
+                        }
+                        const metadata = permSession.metadata || {};
+                        metadata.permissionMode = arg;
+                        await this.sessionManager.updateSession(permSession.id, { metadata });
+                        return `✓ 权限模式已切换为: ${matched.key} (${matched.nameZh})\n${matched.description}`;
+                    }
+                }
+                // 不是已知模式名也不是 allow/deny
+                const modeKeys = hasPermissionController(permAgent) ? permAgent.listModes().map(m => m.key).join('|') : 'default|request|edit|plan|noask';
+                return `❌ 未知参数: ${arg}\n用法: /perm <${modeKeys}> 或 /perm allow|deny`;
+            }
+            // 双参数不再支持，提示正确用法
+            const allModeKeys = hasPermissionController(permAgent) ? permAgent.listModes().map(m => m.key).join('|') : 'default|request|edit|plan|noask';
+            return `❌ 未知参数: ${args}\n用法: /perm <${allModeKeys}> 或 /perm allow|deny`;
+        }
+        // /agent 命令：查看或切换 Agent 后端
+        if (normalizedContent.startsWith('/agent')) {
+            if (!isAdmin)
+                return '❌ 无权限：此命令仅限管理员使用';
+            const args = normalizedContent.slice(6).trim();
+            const available = [...this.agentMap.keys()];
+            if (!args) {
+                const currentAgent = activeSession?.agentId || this.defaultAgentId;
+                const list = available.map(a => `${a === currentAgent ? '✓' : '-'} ${a}`).join('\n');
+                return `当前 Agent: ${currentAgent}\n\n可用:\n${list}\n\n用法: /agent <name>`;
+            }
+            if (!this.agentMap.has(args)) {
+                return `❌ 未知 Agent: ${args}\n可用: ${available.join(', ')}`;
+            }
+            const result = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in result)
+                return result.error;
+            const { session } = result;
+            // 取消原会话的 pending 权限请求
+            if (this.permissionGateway) {
+                this.permissionGateway.cancelAll(session.id);
+            }
+            // 切换到目标 agent（恢复已有会话或创建新会话）
+            const newSession = await this.sessionManager.switchAgent(channel, channelId, session.projectPath, args);
+            const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
+            const projectName = this.getProjectName(session.projectPath);
+            return `✓ 已切换 Agent: ${args}\n  项目: ${projectName}\n  会话: ${newSession.name || '(未命名)'}\n  ${hasExistingSession}`;
         }
         // /model 命令：查看或切换模型/推理强度
         if (normalizedContent.startsWith('/model')) {
             const args = normalizedContent.slice(6).trim();
+            // 获取当前会话（话题会话可能绑定不同 agent）
+            const modelResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in modelResult)
+                return modelResult.error;
+            const { session: modelSession } = modelResult;
+            const modelAgent = this.getAgent(modelSession.agentId);
+            const models = hasModelSwitcher(modelAgent) ? modelAgent.listModels() : [];
             if (!args) {
-                const currentModel = this.agentRunner.getModel();
-                const currentEffort = this.agentRunner.getEffort() || 'auto';
+                const currentModel = hasModelSwitcher(modelAgent) ? modelAgent.getModel() : modelAgent.name;
+                const currentEffort = modelAgent.getEffort?.() || 'auto';
                 const effortDisplay = currentEffort === 'auto' ? 'auto (SDK默认)' : `${currentEffort} ${effortBar(currentEffort)}`;
-                const modelList = availableModels.map(m => `- ${m}`).join('\n');
+                const modelList = models.map((m) => `- ${m}`).join('\n');
                 return `当前模型: ${currentModel}\n推理强度: ${effortDisplay}\n\n可用模型：\n${modelList}\n\n推理强度: ${availableEfforts.join(' / ')} / auto\n\n用法:\n  /model <model>           切换模型\n  /model <model> <effort>  切换模型+推理强度\n  /model <effort>          仅切换推理强度\n  /model auto              恢复SDK默认`;
             }
             const parts = args.split(/\s+/);
@@ -274,34 +547,49 @@ export class CommandHandler {
             if (parts.length === 1) {
                 const arg = parts[0];
                 if (arg === 'auto') {
-                    // 清除 effort，恢复 SDK 默认
-                    const result = await this.ensureSession(channel, channelId, threadId);
-                    if ('error' in result)
-                        return result.error;
-                    const { session } = result;
-                    const writeResult = writeUserSettings({ effortLevel: null });
-                    if (!writeResult.success) {
-                        return `⚠️ 写入用户配置失败: ${writeResult.error}\n已更新运行时配置，但未持久化到 ~/.claude/settings.json`;
+                    modelAgent.setEffort?.(undefined);
+                    // 写回来源
+                    const isCodex = modelAgent.name === 'codex';
+                    if (isCodex) {
+                        if (this.config.agents?.openai?.reasoning) {
+                            delete this.config.agents.openai.reasoning;
+                            try {
+                                saveConfig(this.config);
+                            }
+                            catch { }
+                        }
+                    }
+                    else {
+                        const configuredInEvolclaw = !!this.config.agents?.anthropic?.effort;
+                        if (configuredInEvolclaw) {
+                            delete this.config.agents.anthropic.effort;
+                            try {
+                                saveConfig(this.config);
+                            }
+                            catch { }
+                        }
+                        else {
+                            writeUserSettings({ effortLevel: null });
+                        }
                     }
-                    this.agentRunner.setEffort(undefined);
                     return '✓ 推理强度已恢复为 auto (SDK默认)';
                 }
                 // 单参数：模型 或 effort
                 if (availableEfforts.includes(arg)) {
                     newEffort = arg;
                 }
-                else if (availableModels.includes(arg)) {
+                else if (models.includes(arg)) {
                     newModel = arg;
                 }
                 else {
-                    const modelList = availableModels.map(m => `- ${m}`).join('\n');
+                    const modelList = models.map((m) => `- ${m}`).join('\n');
                     return `❌ 无效参数: ${arg}\n\n可用模型：\n${modelList}\n\n推理强度: ${availableEfforts.join(' / ')}`;
                 }
             }
             else {
                 // 双参数：model effort
                 const [modelArg, effortArg] = parts;
-                if (!availableModels.includes(modelArg)) {
+                if (!models.includes(modelArg)) {
                     return `❌ 无效的模型ID: ${modelArg}`;
                 }
                 if (!availableEfforts.includes(effortArg)) {
@@ -312,53 +600,109 @@ export class CommandHandler {
             }
             if (!this.config.agents)
                 this.config.agents = {};
-            if (!this.config.agents.anthropic)
-                this.config.agents.anthropic = {};
-            // 获取当前会话的项目路径
-            const result = await this.ensureSession(channel, channelId, threadId);
-            if ('error' in result)
-                return result.error;
-            const { session } = result;
+            const isCodexAgent = modelAgent.name === 'codex';
             const changes = [];
-            const updates = {};
             if (newModel) {
-                updates.model = newModel;
-                this.agentRunner.setModel(newModel);
+                modelAgent.setModel?.(newModel);
+                this.eventBus.publish({
+                    type: 'agent:model-changed',
+                    sessionId: modelSession.id,
+                    model: newModel,
+                    timestamp: Date.now()
+                });
                 changes.push(`模型: ${newModel}`);
             }
             if (newEffort) {
-                const modelAfterSwitch = newModel ?? this.agentRunner.getModel();
+                const modelAfterSwitch = newModel ?? (hasModelSwitcher(modelAgent) ? modelAgent.getModel() : modelAgent.name);
                 if (newEffort === 'max' && !modelAfterSwitch.includes('opus')) {
                     return '⚠️ max 推理强度仅 Opus 模型支持（opus / claude-opus-4-6）';
                 }
-                updates.effortLevel = newEffort;
-                this.agentRunner.setEffort(newEffort);
+                modelAgent.setEffort?.(newEffort);
                 changes.push(`推理强度: ${newEffort} ${effortBar(newEffort)}`);
             }
-            // 写入用户级 ~/.claude/settings.json（与 Claude CLI 行为一致）
-            const writeResult = writeUserSettings(updates);
-            if (!writeResult.success) {
-                return `⚠️ 写入用户配置失败: ${writeResult.error}\n已更新运行时配置，但未持久化到 ~/.claude/settings.json`;
+            // 持久化：写回来源（就近原则）
+            // evolclaw.json 配了 → 写 evolclaw.json
+            // evolclaw.json 没配 → 写 agent 全局配置
+            if (isCodexAgent) {
+                const configuredInEvolclaw = !!(this.config.agents?.openai?.model || this.config.agents?.openai?.reasoning);
+                if (configuredInEvolclaw) {
+                    if (!this.config.agents.openai)
+                        this.config.agents.openai = {};
+                    if (newModel)
+                        this.config.agents.openai.model = newModel;
+                    if (newEffort)
+                        this.config.agents.openai.reasoning = newEffort;
+                    try {
+                        saveConfig(this.config);
+                    }
+                    catch (error) {
+                        return `⚠️ 写入 evolclaw.json 失败: ${error.message}\n已更新运行时配置，但未持久化`;
+                    }
+                }
+                else {
+                    // Codex 全局配置（~/.codex/config.toml）目前不支持写入，回退到 evolclaw.json
+                    if (!this.config.agents.openai)
+                        this.config.agents.openai = {};
+                    if (newModel)
+                        this.config.agents.openai.model = newModel;
+                    if (newEffort)
+                        this.config.agents.openai.reasoning = newEffort;
+                    try {
+                        saveConfig(this.config);
+                    }
+                    catch (error) {
+                        return `⚠️ 写入 evolclaw.json 失败: ${error.message}\n已更新运行时配置，但未持久化`;
+                    }
+                }
+            }
+            else {
+                const configuredInEvolclaw = !!(this.config.agents?.anthropic?.model || this.config.agents?.anthropic?.effort);
+                if (configuredInEvolclaw) {
+                    if (!this.config.agents.anthropic)
+                        this.config.agents.anthropic = {};
+                    if (newModel)
+                        this.config.agents.anthropic.model = newModel;
+                    if (newEffort)
+                        this.config.agents.anthropic.effort = newEffort;
+                    try {
+                        saveConfig(this.config);
+                    }
+                    catch (error) {
+                        return `⚠️ 写入 evolclaw.json 失败: ${error.message}\n已更新运行时配置，但未持久化`;
+                    }
+                }
+                else {
+                    const updates = {};
+                    if (newModel)
+                        updates.model = newModel;
+                    if (newEffort)
+                        updates.effortLevel = newEffort;
+                    const writeResult = writeUserSettings(updates);
+                    if (!writeResult.success) {
+                        return `⚠️ 写入用户配置失败: ${writeResult.error}\n已更新运行时配置，但未持久化到 ~/.claude/settings.json`;
+                    }
+                }
             }
             return `✓ 已切换\n  ${changes.join('\n  ')}`;
         }
         // /stop 命令：中断当前任务
         if (normalizedContent === '/stop') {
-            // 话题使用 session.id 作为队列 key，主会话使用 channel-channelId
-            let sessionKey;
-            if (threadId) {
-                const threadSession = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
-                sessionKey = threadSession.id;
-            }
-            else {
-                sessionKey = `${channel}-${channelId}`;
-            }
+            const stopResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in stopResult)
+                return '当前没有正在处理的任务';
+            const { session: stopSession } = stopResult;
+            const stopAgent = this.getAgent(stopSession.agentId);
+            const sessionKey = stopSession.id;
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
-            const hasActive = this.agentRunner.hasActiveStream(sessionKey);
+            const hasActive = stopAgent.hasActiveStream(sessionKey);
             if (queueLength === 0 && !hasActive) {
                 return '当前没有正在处理的任务';
             }
-            await this.agentRunner.interrupt(sessionKey);
+            await stopAgent.interrupt(sessionKey);
+            // 发布中断事件，让 MessageProcessor 标记为 interrupted（而非 done）
+            this.eventBus.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'stop' });
+            // 强制清除 processing_state
+            this.sessionManager.clearProcessing(sessionKey);
             return '✓ 已发送中断信号，任务将尽快停止';
         }
         // /clear 命令：通过 SDK /clear 清空会话历史
@@ -367,20 +711,30 @@ export class CommandHandler {
             if ('error' in result)
                 return result.error;
             const { session } = result;
+            const sessionAgent = this.getAgent(session.agentId);
+            if (!sessionAgent.capabilities?.clear) {
+                return `❌ 当前 Agent (${sessionAgent.name}) 不支持 /clear\n\n可使用 /new 创建新会话替代`;
+            }
             if (!session.agentSessionId) {
                 return '❌ 当前会话没有历史记录，无需清空';
             }
             const projectPath = path.isAbsolute(session.projectPath)
                 ? session.projectPath
                 : path.resolve(process.cwd(), session.projectPath);
-            const cleared = await this.agentRunner.clearSession(session.agentSessionId, projectPath);
-            if (cleared) {
-                await this.sessionManager.updateAgentSessionIdBySessionId(session.id, '');
-                this.agentRunner.updateSessionId(session.id, '');
-                return '✅ 已清空当前会话的对话历史';
+            const releaseLock = this.messageQueue.acquireLock(session.id);
+            try {
+                const cleared = await sessionAgent.clearSession(session.id, session.agentSessionId, projectPath);
+                if (cleared) {
+                    await this.sessionManager.updateAgentSessionIdBySessionId(session.id, '');
+                    sessionAgent.updateSessionId(session.id, '');
+                    return '✅ 已清空当前会话的对话历史';
+                }
+                else {
+                    return '❌ 清空会话失败，请稍后重试';
+                }
             }
-            else {
-                return '❌ 清空会话失败，请稍后重试';
+            finally {
+                releaseLock();
             }
         }
         // /compact 命令：手动压缩会话上下文
@@ -389,21 +743,31 @@ export class CommandHandler {
             if ('error' in result)
                 return result.error;
             const { session } = result;
+            const sessionAgent = this.getAgent(session.agentId);
+            if (!sessionAgent.capabilities?.compact) {
+                return `❌ 当前 Agent (${sessionAgent.name}) 不支持 /compact`;
+            }
             if (!session.agentSessionId) {
                 return '❌ 当前会话没有历史记录，无需压缩';
             }
             const projectPath = path.isAbsolute(session.projectPath)
                 ? session.projectPath
                 : path.resolve(process.cwd(), session.projectPath);
-            if (sendMessage) {
-                await sendMessage(channelId, '⏳ 正在压缩会话上下文...', this.getThreadSendOpts(session));
-            }
-            const compacted = await this.agentRunner.compactSession(session.id, session.agentSessionId, projectPath);
-            if (compacted) {
-                return '✅ 会话上下文已压缩';
+            const releaseLock = this.messageQueue.acquireLock(session.id);
+            try {
+                if (sendMessage) {
+                    await sendMessage(channelId, '⏳ 正在压缩会话上下文...', this.getReplyContext(session));
+                }
+                const compacted = await sessionAgent.compactSession(session.id, session.agentSessionId, projectPath);
+                if (compacted) {
+                    return '✅ 会话上下文已压缩';
+                }
+                else {
+                    return '❌ 会话压缩失败，请稍后重试';
+                }
             }
-            else {
-                return '❌ 会话压缩失败，请稍后重试';
+            finally {
+                releaseLock();
             }
         }
         // 尝试获取活跃会话（话题时直接查找话题 session）
@@ -414,26 +778,37 @@ export class CommandHandler {
         else {
             session = await this.sessionManager.getActiveSession(channel, channelId);
         }
-        // 对于需要创建会话的命令，如果没有会话则创建
+        // 对于需要会话的命令，如果没有会话则使用默认项目创建临时会话
+        // 这样 /pwd、/status 等命令可以在没有活跃会话时返回默认项目信息
         if (!session && (normalizedContent.startsWith('/new') ||
             normalizedContent.startsWith('/bind') ||
-            normalizedContent.startsWith('/project'))) {
+            normalizedContent.startsWith('/project') ||
+            normalizedContent === '/pwd' ||
+            normalizedContent === '/status')) {
             session = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd());
         }
         // /status 命令：显示会话状态
         if (normalizedContent === '/status') {
+            // session 现在总是存在（上面已自动创建）
             if (!session) {
-                return `📊 会话状态：
-
-❌ 当前未创建会话
-
-提示：发送任意消息或使用 /new 命令创建会话`;
+                return `❌ 无法创建会话，请检查配置`;
             }
             const sessionKey = this.getQueueKey(session, channel, channelId);
-            const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey);
+            const sessionAgent = this.getAgent(session.agentId);
+            const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey) || sessionAgent.hasActiveStream(sessionKey);
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
             const isThread = !!session.threadId;
-            const sessionStatus = isCurrentlyProcessing ? '处理中' : '空闲';
+            let sessionStatus = isCurrentlyProcessing ? '处理中' : '空闲';
+            // 处理中时显示时长
+            if (isCurrentlyProcessing) {
+                const elapsed = Date.now() - parseInt(session.processingState, 10);
+                if (!isNaN(elapsed) && elapsed > 0) {
+                    const sec = Math.floor(elapsed / 1000);
+                    sessionStatus = sec < 60 ? `处理中 (${sec}秒)` :
+                        sec < 3600 ? `处理中 (${Math.floor(sec / 60)}分钟)` :
+                            `处理中 (${Math.floor(sec / 3600)}小时)`;
+                }
+            }
             const projectName = this.getProjectName(session.projectPath);
             const health = await this.sessionManager.getHealthStatus(session.id);
             const timeSinceSuccess = Date.now() - health.lastSuccessTime;
@@ -443,7 +818,7 @@ export class CommandHandler {
             // 获取会话文件信息并同步 name
             let sessionTurns = 0;
             if (session.agentSessionId) {
-                const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.agentSessionId);
+                const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.agentSessionId, session.agentId);
                 sessionTurns = fileInfo.turns;
                 if (fileInfo.title && fileInfo.title !== session.name) {
                     await this.sessionManager.renameSession(session.id, fileInfo.title);
@@ -452,10 +827,17 @@ export class CommandHandler {
             }
             const lines = [];
             if (isAdmin) {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `异常计数: ${health.consecutiveErrors}`, `安全模式: ${health.safeMode ? '是 ⚠️' : '否 ✓'}`, `最后成功: ${timeStr}`, `Claude会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `会话状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`);
+                if (health.consecutiveErrors > 0) {
+                    lines.push(`异常计数: ${health.consecutiveErrors}`);
+                }
+                if (health.safeMode) {
+                    lines.push(`安全模式: 是 ⚠️`);
+                }
+                lines.push(`最后成功: ${timeStr}`, `${session.agentId}会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
             }
             else {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `会话: ${session.name || '(未命名)'}`, `状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / ${session.agentId}会话`, `状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
             }
             if (health.safeMode) {
                 lines.push('');
@@ -482,12 +864,90 @@ export class CommandHandler {
                 }
             }
             const projectPath = session?.projectPath || this.config.projects?.defaultPath || process.cwd();
-            const newSession = await this.sessionManager.createNewSession(channel, channelId, projectPath, sessionName);
+            const newSession = await this.sessionManager.createNewSession(channel, channelId, projectPath, sessionName, session?.agentId || this.defaultAgentId);
+            this.eventBus.publish({
+                type: 'session:created',
+                sessionId: newSession.id,
+                channel,
+                channelId,
+                projectPath,
+                name: sessionName,
+                timestamp: Date.now()
+            });
             if (session) {
-                await this.agentRunner.closeSession(session.id);
+                await agent.closeSession(session.id);
             }
             return `✓ 已创建新会话${sessionName ? `: ${sessionName}` : ''}\n  之前的对话历史已保留，可通过 /slist 查看`;
         }
+        // /check 命令：检查渠道状态 / 手动重连指定渠道
+        if (normalizedContent === '/check' || normalizedContent.startsWith('/check ')) {
+            if (!isAdmin)
+                return '❌ 无权限：此命令仅限管理员使用';
+            const subCmd = normalizedContent.slice('/check'.length).trim();
+            // /check rty <channel> — 重连指定渠道
+            if (subCmd.startsWith('rty')) {
+                const target = subCmd.slice('rty'.length).trim();
+                if (!target) {
+                    return '❌ 请指定渠道名称，例如：/check rty feishu';
+                }
+                const ch = this.channelObjects.get(target);
+                if (!ch) {
+                    const available = [...this.channelObjects.keys()].join(', ') || '无';
+                    return `❌ 未找到渠道 "${target}"，可用渠道：${available}`;
+                }
+                if (!ch.reconnect) {
+                    return `❌ 渠道 "${target}" 不支持重连`;
+                }
+                const result = await ch.reconnect();
+                return `🔄 ${target} 重连: ${result}`;
+            }
+            // Default: show full system health check
+            const lines = ['📡 渠道状态：'];
+            for (const [name] of this.adapters) {
+                const ch = this.channelObjects.get(name);
+                if (ch?.getStatus) {
+                    const s = ch.getStatus();
+                    const status = s.connected ? '✓ 已连接' : s.reconnectAttempt > 0 ? `⏳ 重连中 (${s.reconnectAttempt}/${s.maxAttempts})` : '✗ 断开';
+                    lines.push(`  ${name}: ${status}`);
+                }
+                else {
+                    lines.push(`  ${name}: ✓ 已注册`);
+                }
+            }
+            // 队列状态
+            lines.push('', '📬 队列状态：');
+            lines.push(`  待处理消息: ${this.messageQueue.getGlobalQueueLength()}`);
+            lines.push(`  处理中队列: ${this.messageQueue.getGlobalProcessingCount()}`);
+            // 运行概况
+            lines.push('', '🖥️ 运行概况：');
+            const uptimeMs = this.statsCollector
+                ? this.statsCollector.getSnapshot().uptimeMs
+                : process.uptime() * 1000;
+            lines.push(`  运行时间: ${this.formatUptime(uptimeMs)}`);
+            lines.push(`  当前安全模式会话: ${this.sessionManager.getSafeModeSessionCount()}`);
+            // 近 1 小时统计
+            if (this.statsCollector) {
+                const snap = this.statsCollector.getSnapshot();
+                const h = snap.lastHour;
+                lines.push('', '📊 近 1 小时统计：');
+                lines.push(`  收到消息: ${h.received}`);
+                lines.push(`  完成处理: ${h.completed}`);
+                if (h.errors > 0) {
+                    const breakdown = Object.entries(h.errorsByType).map(([t, c]) => `${t}: ${c}`).join(', ');
+                    lines.push(`  处理出错: ${h.errors} (${breakdown})`);
+                }
+                else {
+                    lines.push(`  处理出错: 0`);
+                }
+                lines.push(`  被中断: ${h.interrupts}`);
+                lines.push(`  进入安全模式: ${h.safeModeEntries}`);
+                if (h.completed > 0) {
+                    lines.push(`  平均响应耗时: ${(h.avgResponseMs / 1000).toFixed(1)}s`);
+                }
+            }
+            lines.push('', '💡 /check rty <channel> — 重连指定渠道');
+            return lines.join('\n');
+        }
         // /restart 命令：重启服务
         if (normalizedContent === '/restart') {
             const allSessions = await this.sessionManager.listSessions(channel, channelId);
@@ -516,17 +976,17 @@ export class CommandHandler {
                     return sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。';
                 }
             }
-            // 话题中 restart 时保存 rootId 用于重启后回复到话题
-            let rootId;
+            // 话题中 restart 时保存 replyContext 用于重启后回复到话题
+            let replyContext;
             if (threadId) {
                 const threadSession = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
-                rootId = threadSession.metadata?.feishu?.rootId;
+                replyContext = this.getReplyContext(threadSession);
             }
             const restartInfo = {
                 channel,
                 channelId,
                 timestamp: Date.now(),
-                ...(rootId ? { rootId } : {})
+                ...(replyContext?.replyToMessageId ? { rootId: replyContext.replyToMessageId } : {}),
             };
             fs.writeFileSync(path.join(resolvePaths().dataDir, 'restart-pending.json'), JSON.stringify(restartInfo));
             const { spawn } = await import('child_process');
@@ -535,6 +995,7 @@ export class CommandHandler {
                 stdio: 'ignore',
                 env: { ...process.env, EVOLCLAW_HOME: resolvePaths().root }
             }).unref();
+            this.eventBus.publish({ type: 'system:restart', channel, channelId });
             setTimeout(() => {
                 logger.info('[System] Restarting by user command...');
                 process.exit(0);
@@ -543,10 +1004,9 @@ export class CommandHandler {
         }
         // /pwd 命令：显示当前项目路径
         if (normalizedContent === '/pwd') {
+            // session 现在总是存在（上面已自动创建）
             if (!session) {
-                return `❌ 当前没有活跃会话
-
-提示：发送任意消息或使用 /new 命令创建会话`;
+                return `❌ 无法创建会话，请检查配置`;
             }
             const configName = this.getConfiguredProjectName(session.projectPath);
             if (configName) {
@@ -554,33 +1014,140 @@ export class CommandHandler {
             }
             return `当前项目: ${session.projectPath}`;
         }
+        // /send 命令：发送项目内文件，支持 /send path 和 /send channel path
+        if (normalizedContent.startsWith('/send')) {
+            // 飞书会将 .md 等后缀自动转为 Markdown 链接: foo.md → [foo.md](http://foo.md/)
+            // 还原: 将 [text](url) 替换为 text
+            const rawArg = normalizedContent.slice(5).trim().replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+            if (!rawArg) {
+                return '用法: /send <相对路径> 或 /send <渠道> <相对路径>\n示例: /send src/index.ts\n示例: /send feishu report.md';
+            }
+            // 解析目标通道：第一个 token 若匹配已注册通道名则为目标通道
+            const tokens = rawArg.split(/\s+/);
+            const knownChannels = [...this.adapters.keys()];
+            let targetChannel = channel;
+            let filePath = rawArg;
+            if (tokens.length >= 2 && knownChannels.includes(tokens[0])) {
+                targetChannel = tokens[0];
+                filePath = tokens.slice(1).join(' ');
+            }
+            // 跨通道仅限 owner
+            if (targetChannel !== channel && identity.role !== 'owner') {
+                return '❌ 跨通道发送仅限管理员';
+            }
+            // 找目标 adapter
+            const targetAdapter = this.adapters.get(targetChannel);
+            if (!targetAdapter) {
+                return `❌ 通道 ${targetChannel} 未启用或不存在`;
+            }
+            if (!targetAdapter.sendFile) {
+                return `❌ 通道 ${targetChannel} 不支持文件发送`;
+            }
+            // 获取 session（需要 projectPath）
+            const sendResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in sendResult)
+                return sendResult.error;
+            const sendSession = sendResult.session;
+            // 路径安全校验
+            if (path.isAbsolute(filePath)) {
+                return '❌ 不支持绝对路径\n请使用项目内的相对路径';
+            }
+            if (filePath.split(path.sep).includes('..') || filePath.split('/').includes('..')) {
+                return '❌ 不支持 .. 路径穿越';
+            }
+            const resolvedPath = path.resolve(sendSession.projectPath, filePath);
+            // 存在性检查
+            if (!fs.existsSync(resolvedPath)) {
+                return `❌ 文件不存在: ${filePath}`;
+            }
+            // 符号链接安全：realpath 后验证仍在项目目录内
+            const realPath = fs.realpathSync(resolvedPath);
+            const realProjectPath = fs.realpathSync(sendSession.projectPath);
+            if (!realPath.startsWith(realProjectPath + path.sep) && realPath !== realProjectPath) {
+                return '❌ 路径不允许: 文件不在项目目录内';
+            }
+            const stat = fs.statSync(resolvedPath);
+            if (stat.isDirectory()) {
+                return '❌ 暂不支持发送目录\n目录打包发送将在后续版本支持';
+            }
+            const MAX_SIZE = 10 * 1024 * 1024;
+            if (stat.size > MAX_SIZE) {
+                return `❌ 文件过大: ${(stat.size / 1024 / 1024).toFixed(1)} MB (限制 10 MB)`;
+            }
+            // 找目标 channelId
+            let targetChannelId = channelId;
+            if (targetChannel !== channel) {
+                const ownerPeerId = getOwner(this.config, targetChannel);
+                targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannel, ownerPeerId) ?? '') : '';
+                if (!targetChannelId) {
+                    return `❌ 未找到 ${targetChannel} 的私聊会话，请先在该通道发送一条消息`;
+                }
+            }
+            // 发送文件
+            try {
+                const replyCtx = targetChannel === channel ? this.getReplyContext(sendSession) : undefined;
+                await targetAdapter.sendFile(targetChannelId, realPath, replyCtx);
+                const sizeStr = stat.size < 1024 ? `${stat.size} B`
+                    : stat.size < 1024 * 1024 ? `${(stat.size / 1024).toFixed(1)} KB`
+                        : `${(stat.size / 1024 / 1024).toFixed(1)} MB`;
+                return targetChannel !== channel
+                    ? `📎 文件已通过 ${targetChannel} 发送: ${filePath} (${sizeStr})`
+                    : `✅ 已发送: ${filePath} (${sizeStr})`;
+            }
+            catch (error) {
+                logger.error('[CommandHandler] /send failed:', error);
+                return `❌ 文件发送失败: ${error.message || error}`;
+            }
+        }
         // /plist 命令：列出所有项目
         if (normalizedContent === '/plist') {
-            const isGroup = await this.isGroupChat(channel, channelId);
-            if (isGroup) {
+            if (!policy.canListProjects(session?.chatType || 'private', identity.role)) {
                 if (!session) {
                     return `❌ 当前群聊未绑定项目
 
 请使用 /bind <项目路径> 绑定项目`;
                 }
                 const projectName = this.getProjectName(session.projectPath);
-                const sessionKey = `${channel}-${channelId}`;
-                const queueLength = this.messageQueue.getQueueLength(sessionKey);
-                const status = queueLength > 0 ? '[处理中]' : '[空闲]';
+                const isProcessing = !!session.processingState;
+                const status = isProcessing ? '[处理中]' : '[空闲]';
                 return `当前群聊绑定的项目：
   ${projectName} (${session.projectPath}) - ${status}
 
 提示：群聊不支持切换项目`;
             }
             const lines = ['可用项目:'];
-            const sessionKey = `${channel}-${channelId}`;
-            const processingProject = this.messageQueue.getProcessingProject(sessionKey);
-            const queueLength = this.messageQueue.getQueueLength(sessionKey);
-            const normalizePath = (p) => p.replace(/[/\\]+$/, '');
+            // 收集项目信息并按最近活跃排序
+            const entries = [];
+            const configuredPaths = new Set();
             for (const [name, projectPath] of Object.entries(this.projects)) {
+                configuredPaths.add(projectPath);
                 const isCurrent = session?.projectPath === projectPath;
-                const prefix = isCurrent ? '  ✓' : '   ';
                 const projectSession = await this.sessionManager.getSessionByProjectPath(channel, channelId, projectPath);
+                entries.push({
+                    name, projectPath, projectSession, isCurrent,
+                    updatedAt: projectSession?.updatedAt ?? 0,
+                });
+            }
+            // Include bound projects not in config (created via /bind)
+            const allSessions = await this.sessionManager.listSessions(channel, channelId);
+            for (const s of allSessions) {
+                if (!configuredPaths.has(s.projectPath)) {
+                    configuredPaths.add(s.projectPath);
+                    const isCurrent = session?.projectPath === s.projectPath;
+                    entries.push({
+                        name: path.basename(s.projectPath), projectPath: s.projectPath, projectSession: s, isCurrent,
+                        updatedAt: s.updatedAt ?? 0,
+                    });
+                }
+            }
+            // 当前活跃项目置顶，其余按 updatedAt 降序
+            entries.sort((a, b) => {
+                if (a.isCurrent !== b.isCurrent)
+                    return a.isCurrent ? -1 : 1;
+                return b.updatedAt - a.updatedAt;
+            });
+            for (const { name, projectPath, projectSession, isCurrent } of entries) {
+                const prefix = isCurrent ? '  ✓' : '   ';
                 if (!projectSession) {
                     lines.push(`${prefix} ${name} (${projectPath}) - 无会话`);
                     continue;
@@ -593,9 +1160,12 @@ export class CommandHandler {
                     const idleMs = Date.now() - projectSession.updatedAt;
                     statusParts.push(formatIdleTime(idleMs));
                 }
-                if (processingProject && normalizePath(processingProject) === normalizePath(projectPath)) {
-                    if (queueLength > 1) {
-                        statusParts.push(`[处理中，队列${queueLength - 1}条]`);
+                // 用 DB processingState 判断处理状态
+                const isProcessing = !!projectSession.processingState;
+                if (isProcessing) {
+                    const queueLength = this.messageQueue.getQueueLength(projectSession.id);
+                    if (queueLength > 0) {
+                        statusParts.push(`[处理中，队列${queueLength}条]`);
                     }
                     else {
                         statusParts.push('[处理中]');
@@ -605,7 +1175,7 @@ export class CommandHandler {
                 if (unreadCount > 0) {
                     statusParts.push(`[${unreadCount}条新消息]`);
                 }
-                else if (!processingProject || normalizePath(processingProject) !== normalizePath(projectPath)) {
+                else if (!isProcessing && !isCurrent) {
                     statusParts.push('[空闲]');
                 }
                 lines.push(`${prefix} ${name} (${projectPath}) - ${statusParts.join(' ')}`);
@@ -614,15 +1184,19 @@ export class CommandHandler {
         }
         // /project 命令：切换项目（支持名称或路径）
         if (normalizedContent.startsWith('/project ')) {
-            const isGroup = await this.isGroupChat(channel, channelId);
-            if (isGroup) {
+            if (!policy.canSwitchProject(session?.chatType || 'private', identity.role)) {
                 return `❌ 群聊不支持切换项目
 
 群聊只能绑定一个项目。如需更换项目，请联系管理员重新配置。`;
             }
-            const arg = normalizedContent.slice(9).trim();
+            let arg = normalizedContent.slice(9).trim();
             if (!arg)
                 return '用法: /p <name|path> 或 /project <name|path>';
+            // 检查确认标志
+            const hasConfirm = arg.endsWith(' --confirm');
+            if (hasConfirm) {
+                arg = arg.slice(0, -10).trim();
+            }
             let projectPath;
             let projectName;
             if (arg.includes('/')) {
@@ -649,10 +1223,33 @@ export class CommandHandler {
                     return `当前已在项目: ${projectName}\n  路径: ${projectPath}`;
                 }
             }
-            const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath);
+            // 群聊切换项目需要确认
+            const isGroupChat = session?.chatType === 'group';
+            if (isGroupChat && !hasConfirm) {
+                return `⚠️ 群聊切换项目风险提示：
+
+切换项目将影响所有群成员的对话上下文，可能导致：
+  • 当前项目的会话历史被切换
+  • 正在处理的任务被中断
+  • 其他成员的工作受到影响
+
+确认切换请执行：
+  /p ${projectName} --confirm`;
+            }
+            const currentAgentId = activeSession?.agentId || this.defaultAgentId;
+            const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath, currentAgentId);
+            this.eventBus.publish({
+                type: 'project:switched',
+                sessionId: newSession.id,
+                channel,
+                channelId,
+                projectPath,
+                timestamp: Date.now()
+            });
             const cachedEvents = this.messageCache.getEvents(newSession.id);
             const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
-            let response = `✓ 已切换到项目: ${projectName}\n  路径: ${projectPath}\n  ${hasExistingSession}`;
+            const currentAgent = newSession.agentId || this.defaultAgentId;
+            let response = `✓ 已切换到项目: ${projectName}\n  路径: ${projectPath}\n  Agent: ${currentAgent}\n  ${hasExistingSession}`;
             if (cachedEvents.length > 0 && sendMessage) {
                 for (const event of cachedEvents) {
                     if (event.type === 'completed') {
@@ -674,40 +1271,41 @@ export class CommandHandler {
             }
             return response;
         }
-        // /bind 命令：绑定新项目目录
+        // /bind 命令：持久化项目到配置（不切换）
         if (normalizedContent.startsWith('/bind ')) {
             const projectPath = normalizedContent.slice(6).trim();
             if (!projectPath)
-                return '用法: /bind <path>';
+                return '用法: /bind <路径>';
             if (!path.isAbsolute(projectPath)) {
                 return '❌ 项目路径必须是绝对路径';
             }
             if (!fs.existsSync(projectPath)) {
                 return `❌ 路径不存在: ${projectPath}`;
             }
-            const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath);
-            const cachedEvents = this.messageCache.getEvents(newSession.id);
-            const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
-            let response = `✓ 已绑定项目目录: ${projectPath}\n  ${hasExistingSession}`;
-            if (cachedEvents.length > 0) {
-                response += `\n\n后台任务结果:`;
-                for (const event of cachedEvents) {
-                    if (event.type === 'completed') {
-                        response += `\n✓ 任务完成`;
-                        if (event.metadata?.duration) {
-                            response += ` (耗时: ${Math.round(event.metadata.duration / 1000)}s)`;
-                        }
-                        const summary = event.message.substring(0, 200);
-                        response += `\n${summary}${event.message.length > 200 ? '...' : ''}`;
-                    }
-                    else if (event.type === 'error') {
-                        response += `\n❌ 任务失败: ${event.metadata?.errorType || '未知错误'}`;
-                        response += `\n${event.message}`;
-                    }
+            // 生成项目名称（使用目录名）
+            const projectName = path.basename(projectPath);
+            // 检查是否已存在
+            if (this.projects[projectName]) {
+                const existingPath = this.projects[projectName];
+                if (existingPath === projectPath) {
+                    return `项目 "${projectName}" 已存在\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目`;
                 }
-                this.messageCache.clearEvents(newSession.id);
-            }
-            return response;
+                return `❌ 项目名称 "${projectName}" 已被占用\n  现有路径: ${existingPath}\n  新路径: ${projectPath}\n\n请重命名目录或手动编辑配置文件`;
+            }
+            // 添加到配置
+            if (!this.config.projects) {
+                this.config.projects = { defaultPath: process.cwd(), autoCreate: false, list: {} };
+            }
+            if (!this.config.projects.list) {
+                this.config.projects.list = {};
+            }
+            this.config.projects.list[projectName] = projectPath;
+            // 保存配置
+            const { saveConfig } = await import('../config.js');
+            saveConfig(this.config);
+            // 更新内存中的项目列表
+            this.projects[projectName] = projectPath;
+            return `✓ 已添加项目: ${projectName}\n  路径: ${projectPath}\n\n使用 /p ${projectName} 切换到该项目`;
         }
         // /slist 命令：列出当前项目的所有会话
         if (normalizedContent === '/slist') {
@@ -720,56 +1318,74 @@ export class CommandHandler {
 3. /project <项目> - 切换到指定项目`;
             }
             const sessions = await this.sessionManager.listSessions(channel, channelId);
-            const currentProjectSessions = sessions.filter(s => s.projectPath === session.projectPath);
+            const currentProjectSessions = sessions.filter(s => s.projectPath === session.projectPath && s.agentId === session.agentId);
             // 从 SDK 同步会话名称（发现 CLI 改名）
             try {
-                const sdkSessions = await sdkListSessions({ dir: session.projectPath });
+                const sdkSessions = await this.sessionManager.listSdkSessions(session.projectPath, session.agentId);
                 for (const sdkSession of sdkSessions) {
-                    const sdkName = sdkSession.customTitle || undefined;
-                    if (!sdkName)
+                    if (!sdkSession.title)
                         continue;
                     const dbSession = currentProjectSessions.find(s => s.agentSessionId === sdkSession.sessionId);
-                    if (dbSession && sdkName !== dbSession.name) {
-                        await this.sessionManager.renameSession(dbSession.id, sdkName);
-                        dbSession.name = sdkName;
+                    if (dbSession && sdkSession.title !== dbSession.name) {
+                        await this.sessionManager.renameSession(dbSession.id, sdkSession.title);
+                        dbSession.name = sdkSession.title;
                     }
                 }
             }
             catch (error) {
                 logger.debug('[CommandHandler] SDK listSessions sync failed (non-critical):', error);
             }
-            const isGroup = await this.isGroupChat(channel, channelId);
-            const cliSessions = (isGroup || !isAdmin)
-                ? []
-                : await this.sessionManager.scanCliSessions(session.projectPath);
+            const canImportCli = policy.canImportCliSession(session.chatType || 'private', identity.role);
+            const cliSessions = canImportCli
+                ? await this.sessionManager.scanCliSessions(session.projectPath, session.agentId)
+                : [];
             const dbSessionIds = new Set(currentProjectSessions.map(s => s.agentSessionId).filter(Boolean));
-            const lines = [`当前项目 ${path.basename(session.projectPath)} 的会话列表:\n`];
-            const sessionKey = `${channel}-${channelId}`;
-            const isProcessing = this.messageQueue.isProcessing(sessionKey);
+            const lines = [`当前项目 ${path.basename(session.projectPath)} 的 [${session.agentId}] 会话列表:`, ''];
             if (currentProjectSessions.length > 0) {
+                // 超过10个会话时隐藏话题会话（/slist 只能在主会话调用，话题内已禁用）
+                const hideTopics = currentProjectSessions.length > 10;
+                const topicCount = hideTopics ? currentProjectSessions.filter(s => s.threadId).length : 0;
+                const maxDisplay = 10;
                 lines.push('【EvolClaw 会话】');
+                let displayIndex = 0;
                 for (let i = 0; i < currentProjectSessions.length; i++) {
                     const s = currentProjectSessions[i];
-                    const prefix = s.isActive ? '  ✓' : '   ';
-                    const num = `${i + 1}.`;
+                    if (hideTopics && s.threadId)
+                        continue;
+                    if (displayIndex >= maxDisplay)
+                        break;
+                    const isActive = s.metadata?.isActive === true;
+                    displayIndex++;
+                    const prefix = isActive ? '  ✓' : '   ';
+                    const num = `${displayIndex}.`;
                     const threadTag = s.threadId ? '[话题] ' : '';
                     const name = s.name || '(未命名)';
                     const uuid = s.agentSessionId ? `(${s.agentSessionId.substring(0, 8)})` : '';
                     const idleTime = formatIdleTime(Date.now() - s.updatedAt);
-                    if (s.agentSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.agentSessionId)) {
+                    if (s.agentSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.agentSessionId, s.agentId)) {
                         lines.push(`${prefix} ${num} ${threadTag}❌ ${name} ${uuid} - ${idleTime} [会话文件缺失]`);
                     }
                     else {
+                        const sIsProcessing = !!s.processingState;
                         let status = '[空闲]';
-                        if (s.isActive && isProcessing) {
+                        if (sIsProcessing) {
                             status = '[处理中]';
                         }
-                        else if (s.isActive) {
+                        else if (isActive) {
                             status = '[活跃]';
                         }
                         lines.push(`${prefix} ${num} ${threadTag}${name} ${uuid} - ${idleTime} ${status}`);
                     }
                 }
+                const hiddenCount = currentProjectSessions.length - displayIndex - topicCount;
+                if (topicCount > 0 || hiddenCount > 0) {
+                    const parts = [];
+                    if (hiddenCount > 0)
+                        parts.push(`${hiddenCount} 个更早的会话`);
+                    if (topicCount > 0)
+                        parts.push(`${topicCount} 个话题会话`);
+                    lines.push(`\n  (已隐藏 ${parts.join('、')})`);
+                }
                 lines.push('');
             }
             const orphanCliSessions = cliSessions.filter(c => !dbSessionIds.has(c.uuid)).slice(0, 5);
@@ -777,7 +1393,7 @@ export class CommandHandler {
                 lines.push('【CLI 会话】(最新5个)');
                 for (const c of orphanCliSessions) {
                     const time = new Date(c.mtime).toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' });
-                    const message = this.sessionManager.readSessionFirstMessage(session.projectPath, c.uuid) || '(无消息)';
+                    const message = this.sessionManager.readSessionFirstMessage(session.projectPath, c.uuid, session.agentId) || '(无消息)';
                     const uuid = c.uuid.substring(0, 8);
                     lines.push(`  ${time}  (${uuid})  "${message}"`);
                 }
@@ -791,38 +1407,44 @@ export class CommandHandler {
             const sessionName = normalizedContent.slice(9).trim();
             if (!sessionName)
                 return '用法: /s <序号、会话名称或前8位UUID>';
-            const sessionKey = `${channel}-${channelId}`;
-            const queueLength = this.messageQueue.getQueueLength(sessionKey);
-            if (queueLength > 0) {
+            const isProcessing = !!session?.processingState;
+            if (isProcessing) {
                 return `⚠️ 当前正在处理消息，无法切换会话\n请等待当前任务完成后再试`;
             }
             let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
-            // 序号切换：纯数字时按当前项目会话列表序号匹配
+            // 序号切换：纯数字时按 /slist 显示的序号匹配（超过10个时隐藏非活跃话题会话）
             if (!targetSession && /^\d+$/.test(sessionName) && session) {
                 const idx = parseInt(sessionName, 10);
                 const allSessions = await this.sessionManager.listSessions(channel, channelId);
-                const projectSessions = allSessions.filter(s => s.projectPath === session.projectPath);
-                if (idx >= 1 && idx <= projectSessions.length) {
-                    targetSession = projectSessions[idx - 1];
+                const projectSessions = allSessions.filter(s => s.projectPath === session.projectPath && s.agentId === session.agentId);
+                // 与 /slist 显示逻辑一致：超过10个时隐藏非活跃话题会话
+                const hideTopics = projectSessions.length > 10;
+                const visibleSessions = hideTopics
+                    ? projectSessions.filter(s => !s.threadId)
+                    : projectSessions;
+                if (idx >= 1 && idx <= visibleSessions.length) {
+                    targetSession = visibleSessions[idx - 1];
                 }
                 else {
-                    return `❌ 序号超出范围 (1-${projectSessions.length})\n使用 /slist 查看可用会话`;
+                    return `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /slist 查看可用会话`;
                 }
             }
             if (!targetSession && sessionName.length === 8) {
                 targetSession = await this.sessionManager.getSessionByUuidPrefix(channel, channelId, sessionName);
             }
-            const isGroup = await this.isGroupChat(channel, channelId);
-            if (!targetSession && sessionName.length === 8 && !isGroup && isAdmin) {
+            const canImport = policy.canImportCliSession(session?.chatType || 'private', identity.role);
+            if (!targetSession && sessionName.length === 8 && canImport) {
                 const projectPaths = Object.values(this.projects);
                 if (session) {
                     projectPaths.unshift(session.projectPath);
                 }
                 for (const projectPath of projectPaths) {
-                    const cliSessions = await this.sessionManager.scanCliSessions(projectPath);
+                    const currentAgentId = session?.agentId || this.defaultAgentId;
+                    const cliSessions = await this.sessionManager.scanCliSessions(projectPath, currentAgentId);
                     const cliSession = cliSessions.find(c => c.uuid.startsWith(sessionName));
                     if (cliSession) {
-                        const imported = await this.sessionManager.importCliSession(channel, channelId, projectPath, cliSession.uuid);
+                        const imported = await this.sessionManager.importCliSession(channel, channelId, projectPath, cliSession.uuid, currentAgentId);
+                        this.eventBus.publish({ type: 'session:imported', sessionId: imported.id, agentSessionId: cliSession.uuid, projectPath });
                         const projectName = this.getProjectName(projectPath);
                         return `✓ 已导入 CLI 会话: ${imported.name}\n  项目: ${projectName}\n  将继续之前的对话历史`;
                     }
@@ -832,7 +1454,7 @@ export class CommandHandler {
                 return `❌ 会话不存在: ${sessionName}\n使用 /slist 查看可用会话`;
             }
             const lastInput = targetSession.agentSessionId
-                ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.agentSessionId)
+                ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.agentSessionId, targetSession.agentId)
                 : null;
             const lastInputLine = lastInput ? `\n  最后输入: "${lastInput}"` : '';
             if (!session) {
@@ -853,6 +1475,7 @@ export class CommandHandler {
             if (!switched) {
                 return `❌ 切换会话失败`;
             }
+            this.eventBus.publish({ type: 'session:switched', sessionId: targetSession.id, fromSessionId: session.id, toSessionId: targetSession.id });
             const continueHint = lastInput ? '\n  将继续之前的对话历史' : '\n  当前会话未有发言';
             return `✓ 已切换到会话: ${targetSession.name || sessionName}${continueHint}${lastInputLine}`;
         }
@@ -873,19 +1496,12 @@ export class CommandHandler {
             if (existing && existing.id !== session.id) {
                 return `❌ 会话名称 "${newName}" 已存在，请使用其他名称`;
             }
-            // 双写：SDK + 数据库
-            if (session.agentSessionId) {
-                try {
-                    await sdkRenameSession(session.agentSessionId, newName, { dir: session.projectPath });
-                }
-                catch (error) {
-                    logger.warn(`[CommandHandler] SDK renameSession failed (continuing with db update):`, error);
-                }
-            }
+            const oldName = session.name || '(未命名)';
             const success = await this.sessionManager.renameSession(session.id, newName);
             if (!success) {
                 return `❌ 重命名失败`;
             }
+            this.eventBus.publish({ type: 'session:renamed', sessionId: session.id, oldName, newName });
             return `✓ 已将当前会话重命名为: ${newName}`;
         }
         // /del 命令：删除指定会话（仅解绑，不删除文件）
@@ -896,22 +1512,25 @@ export class CommandHandler {
             if (!session) {
                 return `❌ 当前没有活跃会话`;
             }
-            // 群聊权限检查：只有管理员可以删除
-            const isGroup = await this.isGroupChat(channel, channelId);
-            if (isGroup && !isAdmin) {
+            // 权限检查：policy 控制谁可以删除会话
+            if (!policy.canDeleteSession(session.chatType || 'private', identity.role)) {
                 return `❌ 无权限：群聊中仅管理员可删除会话`;
             }
             let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
-            // 序号删除
+            // 序号删除（与 /slist 显示序号一致）
             if (!targetSession && /^\d+$/.test(sessionName)) {
                 const idx = parseInt(sessionName, 10);
                 const allSessions = await this.sessionManager.listSessions(channel, channelId);
-                const projectSessions = allSessions.filter(s => s.projectPath === session.projectPath);
-                if (idx >= 1 && idx <= projectSessions.length) {
-                    targetSession = projectSessions[idx - 1];
+                const projectSessions = allSessions.filter(s => s.projectPath === session.projectPath && s.agentId === session.agentId);
+                const hideTopics = projectSessions.length > 10;
+                const visibleSessions = hideTopics
+                    ? projectSessions.filter(s => !s.threadId)
+                    : projectSessions;
+                if (idx >= 1 && idx <= visibleSessions.length) {
+                    targetSession = visibleSessions[idx - 1];
                 }
                 else {
-                    return `❌ 序号超出范围 (1-${projectSessions.length})\n使用 /slist 查看可用会话`;
+                    return `❌ 序号超出范围 (1-${visibleSessions.length})\n使用 /slist 查看可用会话`;
                 }
             }
             if (!targetSession && sessionName.length === 8) {
@@ -927,7 +1546,9 @@ export class CommandHandler {
             if (!success) {
                 return `❌ 删除失败`;
             }
-            await this.agentRunner.closeSession(targetSession.id);
+            this.eventBus.publish({ type: 'session:deleted', sessionId: targetSession.id });
+            const targetAgent = this.getAgent(targetSession.agentId);
+            await targetAgent.closeSession(targetSession.id);
             return `✓ 已删除会话: ${targetSession.name || sessionName}\n会话文件已保留，可通过 CLI 访问`;
         }
         // /fork 命令：分支当前会话
@@ -937,11 +1558,16 @@ export class CommandHandler {
                 return `❌ 当前没有活跃会话，无法分支`;
             }
             if (!session.agentSessionId) {
-                return `❌ 当前会话尚未初始化 Claude 对话，无法分支\n\n请先发送一条消息，然后再使用 /fork`;
+                return `❌ 当前会话尚未初始化对话，无法分支\n\n请先发送一条消息，然后再使用 /fork`;
+            }
+            const forkAgent = this.getAgent(session.agentId);
+            if (!forkAgent.capabilities?.fork) {
+                return `❌ 当前 Agent (${forkAgent.name}) 不支持 /fork\n\n可使用 /new 创建新会话替代`;
             }
             try {
-                const forkResult = await sdkForkSession(session.agentSessionId, { dir: session.projectPath, title: forkName });
-                const newSession = await this.sessionManager.createForkedSession(session, forkResult.sessionId, forkName);
+                const forkedSessionId = await forkAgent.forkSession(session.agentSessionId, session.projectPath, forkName);
+                const newSession = await this.sessionManager.createForkedSession(session, forkedSessionId, forkName);
+                this.eventBus.publish({ type: 'session:forked', sessionId: newSession.id, sourceSessionId: session.id, name: forkName });
                 return `✅ 会话已分支: ${newSession.name}\n新会话已激活，可以继续对话\n\n使用 /slist 查看所有会话，/s <名称> 切换回原会话`;
             }
             catch (error) {
@@ -951,66 +1577,49 @@ export class CommandHandler {
         }
         // /repair 命令：检查并修复会话
         if (normalizedContent === '/repair') {
-            if (!session) {
-                return `❌ 当前未创建会话，无需修复`;
-            }
-            const health = await this.sessionManager.getHealthStatus(session.id);
+            const repairResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in repairResult)
+                return repairResult.error;
+            const { session: repairSession } = repairResult;
+            const health = await this.sessionManager.getHealthStatus(repairSession.id);
             if (!health.safeMode) {
                 return `当前不在安全模式，无需修复\n\n如需进入安全模式，请使用 /safe`;
             }
-            const { checkSessionFileHealth, backupClaudeDir } = await import('../utils/session-file-health.js');
-            const fsPromises = await import('fs/promises');
+            const repairAgent = this.getAgent(repairSession.agentId);
+            const { checkSessionFile, backupSessionFile } = await import('../utils/session-file-health.js');
             try {
-                const backupDir = await backupClaudeDir(session.projectPath);
-                if (!session.agentSessionId) {
-                    await this.sessionManager.resetHealthStatus(session.id);
-                    return `✓ 修复完成，已退出安全模式
-
-修复内容：
-- 未发现问题（新会话）
-- 已重置异常计数器
-- 已恢复正常会话模式
-
-备份位置：${backupDir}`;
+                if (!repairSession.agentSessionId) {
+                    await this.sessionManager.resetHealthStatus(repairSession.id);
+                    this.eventBus.publish({ type: 'session:safe-mode-exited', sessionId: repairSession.id, method: 'repair' });
+                    return `✓ 修复完成，已退出安全模式\n\n修复内容：\n- 未发现问题（新会话）\n- 已重置异常计数器\n- 已恢复正常会话模式`;
+                }
+                // 通过 agent 定位 session 文件
+                const sessionFile = repairAgent.resolveSessionFile?.(repairSession.agentSessionId, repairSession.projectPath) ?? null;
+                if (!sessionFile) {
+                    // 文件不存在（已被删除或从未创建），直接重置
+                    await this.sessionManager.resetHealthStatus(repairSession.id);
+                    this.eventBus.publish({ type: 'session:safe-mode-exited', sessionId: repairSession.id, method: 'repair' });
+                    return `✓ 修复完成，已退出安全模式\n\n修复内容：\n- 会话文件不存在（可能已被清理）\n- 已重置异常计数器\n- 已恢复正常会话模式`;
                 }
-                const healthCheck = await checkSessionFileHealth(session.projectPath, session.agentSessionId);
+                const healthCheck = await checkSessionFile(sessionFile);
                 if (healthCheck.corrupt) {
-                    const sessionFile = path.join(session.projectPath, '.claude', `${session.agentSessionId}.jsonl`);
+                    const backupPath = await backupSessionFile(sessionFile);
+                    const fsPromises = await import('fs/promises');
                     await fsPromises.unlink(sessionFile);
-                    await this.sessionManager.updateAgentSessionId(session.channel, session.channelId, '');
-                    await this.sessionManager.resetHealthStatus(session.id);
-                    return `✓ 修复完成，已退出安全模式
-
-检测到问题：
-${healthCheck.issues.map((i) => `- ${i}`).join('\n')}
-
-修复操作：
-- 已删除损坏文件
-- 已创建新会话
-- 已重置异常计数器
-
-备份位置：${backupDir}`;
+                    await this.sessionManager.updateAgentSessionIdBySessionId(repairSession.id, '');
+                    repairAgent.updateSessionId(repairSession.id, '');
+                    await this.sessionManager.resetHealthStatus(repairSession.id);
+                    this.eventBus.publish({ type: 'session:safe-mode-exited', sessionId: repairSession.id, method: 'repair' });
+                    return `✓ 修复完成，已退出安全模式\n\n检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n修复操作：\n- 已备份损坏文件\n- 已删除损坏文件\n- 已重置异常计数器\n\n备份位置：${backupPath}`;
                 }
                 if (healthCheck.issues.length > 0) {
-                    await this.sessionManager.resetHealthStatus(session.id);
-                    return `⚠️ 检测到问题：
-${healthCheck.issues.map((i) => `- ${i}`).join('\n')}
-
-建议：
-1. 使用 /new 创建新会话
-2. 旧会话已备份到：${backupDir}
-
-已重置异常计数器，可继续使用当前会话。`;
+                    await this.sessionManager.resetHealthStatus(repairSession.id);
+                    this.eventBus.publish({ type: 'session:safe-mode-exited', sessionId: repairSession.id, method: 'repair' });
+                    return `⚠️ 检测到问题：\n${healthCheck.issues.map((i) => `- ${i}`).join('\n')}\n\n建议使用 /new 创建新会话\n\n已重置异常计数器，可继续使用当前会话。`;
                 }
-                await this.sessionManager.resetHealthStatus(session.id);
-                return `✓ 修复完成，已退出安全模式
-
-修复内容：
-- 未发现问题
-- 已重置异常计数器
-- 已恢复正常会话模式
-
-备份位置：${backupDir}`;
+                await this.sessionManager.resetHealthStatus(repairSession.id);
+                this.eventBus.publish({ type: 'session:safe-mode-exited', sessionId: repairSession.id, method: 'repair' });
+                return `✓ 修复完成，已退出安全模式\n\n修复内容：\n- 未发现问题\n- 已重置异常计数器\n- 已恢复正常会话模式`;
             }
             catch (error) {
                 logger.error('[Repair] Failed:', error);
@@ -1019,10 +1628,12 @@ ${healthCheck.issues.map((i) => `- ${i}`).join('\n')}
         }
         // /safe 命令：手动进入安全模式
         if (normalizedContent === '/safe') {
-            if (!session) {
-                return `❌ 当前未创建会话`;
-            }
-            await this.sessionManager.setSafeMode(session.id, true);
+            const safeResult = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in safeResult)
+                return safeResult.error;
+            const { session: safeSession } = safeResult;
+            await this.sessionManager.setSafeMode(safeSession.id, true);
+            this.eventBus.publish({ type: 'session:safe-mode-entered', sessionId: safeSession.id, reason: 'manual' });
             return `✓ 已进入安全模式
 
 当前行为：
@@ -1036,11 +1647,4 @@ ${healthCheck.issues.map((i) => `- ${i}`).join('\n')}
         }
         return null;
     }
-    /**
-     * 通过 adapter 查询是否为群聊
-     */
-    async isGroupChat(channel, channelId) {
-        const adapter = this.adapters.get(channel);
-        return await adapter?.isGroupChat?.(channelId) ?? false;
-    }
 }