evolclaw 2.0.7 → 2.1.1

package/dist/core/command-handler.js

@@ -1,9 +1,48 @@
 import { renameSession as sdkRenameSession, forkSession as sdkForkSession, listSessions as sdkListSessions } from '@anthropic-ai/claude-agent-sdk';
-import { saveConfig, resolvePaths, getPackageRoot } from '../config.js';
+import { resolvePaths, getPackageRoot } 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 = {
+        low: '◆◇◇◇', medium: '◆◆◇◇', high: '◆◆◆◇', max: '◆◆◆◆'
+    };
+    return levels[level] || '◆◆◇◇';
+}
+/**
+ * 写入用户级 ~/.claude/settings.json（与 Claude CLI 行为一致）
+ */
+function writeUserSettings(updates) {
+    try {
+        const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+        let settings = {};
+        if (fs.existsSync(settingsPath)) {
+            settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+        if (updates.model !== undefined)
+            settings.model = updates.model;
+        if (updates.effortLevel !== undefined) {
+            if (updates.effortLevel === null) {
+                delete settings.effortLevel;
+            }
+            else {
+                settings.effortLevel = updates.effortLevel;
+            }
+        }
+        const claudeDir = path.join(os.homedir(), '.claude');
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
+        }
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
 /**
  * 计算两个字符串的 Levenshtein 距离（编辑距离）
  */
@@ -46,7 +85,7 @@ function formatIdleTime(ms) {
     return '刚刚';
 }
 // 支持的命令列表
-const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork'];
+const commands = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/stop', '/clear', '/compact', '/repair', '/safe', '/fork', '/del'];
 // 命令别名映射
 const aliases = {
     '/p': '/project',
@@ -54,8 +93,9 @@ const aliases = {
     '/name': '/rename'
 };
 // 命令快速路径前缀（不进入消息队列的命令）
-// 注意：/stop, /clear, /compact, /safe 故意不在此列表中，它们需要进入队列触发中断机制
-const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/repair', '/fork', '/p ', '/s ', '/name '];
+// 注意：/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 '];
 export class CommandHandler {
     sessionManager;
     agentRunner;
@@ -82,8 +122,24 @@ export class CommandHandler {
     getProjectName(projectPath) {
         return this.getConfiguredProjectName(projectPath) || path.basename(projectPath);
     }
+    /** 获取消息队列 key：话题用 session.id，主会话用 channel-channelId */
+    getQueueKey(session, channel, channelId) {
+        if (session?.threadId)
+            return session.id;
+        return `${channel}-${channelId}`;
+    }
+    /** 从 session 提取话题回复选项 */
+    getThreadSendOpts(session) {
+        const rootId = session.metadata?.feishu?.rootId;
+        return rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined;
+    }
     /** 获取活跃会话，无会话时返回统一错误提示 */
-    async ensureSession(channel, channelId) {
+    async ensureSession(channel, channelId, threadId) {
+        if (threadId) {
+            // 话题会话：按 thread_id 查找
+            const session = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
+            return { session };
+        }
         const session = await this.sessionManager.getActiveSession(channel, channelId);
         if (!session) {
             return { error: '❌ 当前没有活跃会话\n使用 /new 创建新会话' };
@@ -111,7 +167,7 @@ export class CommandHandler {
     /**
      * 主命令处理入口
      */
-    async handle(content, channel, channelId, sendMessage, userId) {
+    async handle(content, channel, channelId, sendMessage, userId, threadId) {
         // 规范化命令（将别名转换为完整命令）
         let normalizedContent = content;
         for (const [alias, full] of Object.entries(aliases)) {
@@ -122,9 +178,16 @@ export class CommandHandler {
         }
         // 权限检查：区分用户级命令和管理级命令
         const { isOwner: checkOwner } = await import('../config.js');
+        // 话题内禁用部分命令
+        if (threadId) {
+            const threadBlocked = ['/new', '/slist', '/plist', '/bind', '/s', '/session', '/project', '/p', '/fork', '/del'];
+            const isBlocked = threadBlocked.some(c => normalizedContent === c || normalizedContent.startsWith(c + ' '));
+            if (isBlocked)
+                return '⚠️ 话题中不支持此命令';
+        }
         const isAdmin = !userId || checkOwner(this.config, channel, userId);
         if (normalizedContent.startsWith('/')) {
-            const userCommands = ['/slist', '/new', '/session', '/rename', '/name', '/status', '/help', '/s '];
+            const userCommands = ['/slist', '/new', '/session', '/rename', '/name', '/status', '/help', '/del', '/s '];
             const isUserCommand = userCommands.some(cmd => normalizedContent === cmd.trimEnd() || normalizedContent.startsWith(cmd));
             if (!isUserCommand && !isAdmin) {
                 return '❌ 无权限：此命令仅限管理员使用';
@@ -159,6 +222,7 @@ export class CommandHandler {
   /slist - 列出当前项目的所有会话
   /s, /session <名称> - 切换到指定会话
   /name, /rename <新名称> - 重命名当前会话
+  /del <名称> - 删除指定会话（仅解绑，不删除文件）
   /status - 显示会话状态
 
 ❓ 帮助：
@@ -176,6 +240,7 @@ export class CommandHandler {
   /slist - 列出当前项目的所有会话
   /s, /session <名称> - 切换到指定会话
   /name, /rename <新名称> - 重命名当前会话
+  /del <名称> - 删除指定会话（仅解绑，不删除文件）
   /fork [名称] - 分支当前会话（从当前对话点创建分支）
   /status - 显示会话状态
   /clear - 清空当前会话的对话历史
@@ -188,37 +253,109 @@ export class CommandHandler {
   /safe - 进入安全模式
 
 🤖 模型管理：
-  /model [model-id] - 查看或切换模型
+  /model [model] [effort] - 查看或切换模型/推理强度
 
 ❓ 帮助：
   /help - 显示此帮助信息`;
         }
-        // /model 命令：查看或切换模型
+        // /model 命令：查看或切换模型/推理强度
         if (normalizedContent.startsWith('/model')) {
             const args = normalizedContent.slice(6).trim();
             if (!args) {
                 const currentModel = this.agentRunner.getModel();
+                const currentEffort = this.agentRunner.getEffort() || 'auto';
+                const effortDisplay = currentEffort === 'auto' ? 'auto (SDK默认)' : `${currentEffort} ${effortBar(currentEffort)}`;
                 const modelList = availableModels.map(m => `- ${m}`).join('\n');
-                return `当前模型: ${currentModel}\n\n可用模型：\n${modelList}\n\n用法: /model <model-id>`;
+                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默认`;
             }
-            if (!availableModels.includes(args)) {
-                const modelList = availableModels.map(m => `- ${m}`).join('\n');
-                return `❌ 无效的模型ID: ${args}\n\n可用模型：\n${modelList}`;
+            const parts = args.split(/\s+/);
+            let newModel;
+            let newEffort;
+            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`;
+                    }
+                    this.agentRunner.setEffort(undefined);
+                    return '✓ 推理强度已恢复为 auto (SDK默认)';
+                }
+                // 单参数：模型 或 effort
+                if (availableEfforts.includes(arg)) {
+                    newEffort = arg;
+                }
+                else if (availableModels.includes(arg)) {
+                    newModel = arg;
+                }
+                else {
+                    const modelList = availableModels.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)) {
+                    return `❌ 无效的模型ID: ${modelArg}`;
+                }
+                if (!availableEfforts.includes(effortArg)) {
+                    return `❌ 无效的推理强度: ${effortArg}\n可选: ${availableEfforts.join(' / ')}`;
+                }
+                newModel = modelArg;
+                newEffort = effortArg;
             }
             if (!this.config.agents)
                 this.config.agents = {};
             if (!this.config.agents.anthropic)
                 this.config.agents.anthropic = {};
-            this.config.agents.anthropic.model = args;
-            saveConfig(this.config);
-            this.agentRunner.setModel(args);
-            return `✓ 已切换到模型: ${args}`;
+            // 获取当前会话的项目路径
+            const result = await this.ensureSession(channel, channelId, threadId);
+            if ('error' in result)
+                return result.error;
+            const { session } = result;
+            const changes = [];
+            const updates = {};
+            if (newModel) {
+                updates.model = newModel;
+                this.agentRunner.setModel(newModel);
+                changes.push(`模型: ${newModel}`);
+            }
+            if (newEffort) {
+                const modelAfterSwitch = newModel ?? this.agentRunner.getModel();
+                if (newEffort === 'max' && !modelAfterSwitch.includes('opus')) {
+                    return '⚠️ max 推理强度仅 Opus 模型支持（opus / claude-opus-4-6）';
+                }
+                updates.effortLevel = newEffort;
+                this.agentRunner.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`;
+            }
+            return `✓ 已切换\n  ${changes.join('\n  ')}`;
         }
         // /stop 命令：中断当前任务
         if (normalizedContent === '/stop') {
-            const sessionKey = `${channel}-${channelId}`;
+            // 话题使用 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 queueLength = this.messageQueue.getQueueLength(sessionKey);
-            if (queueLength === 0) {
+            const hasActive = this.agentRunner.hasActiveStream(sessionKey);
+            if (queueLength === 0 && !hasActive) {
                 return '当前没有正在处理的任务';
             }
             await this.agentRunner.interrupt(sessionKey);
@@ -226,19 +363,19 @@ export class CommandHandler {
         }
         // /clear 命令：通过 SDK /clear 清空会话历史
         if (normalizedContent === '/clear') {
-            const result = await this.ensureSession(channel, channelId);
+            const result = await this.ensureSession(channel, channelId, threadId);
             if ('error' in result)
                 return result.error;
             const { session } = result;
-            if (!session.claudeSessionId) {
+            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.claudeSessionId, projectPath);
+            const cleared = await this.agentRunner.clearSession(session.agentSessionId, projectPath);
             if (cleared) {
-                await this.sessionManager.updateClaudeSessionIdBySessionId(session.id, '');
+                await this.sessionManager.updateAgentSessionIdBySessionId(session.id, '');
                 this.agentRunner.updateSessionId(session.id, '');
                 return '✅ 已清空当前会话的对话历史';
             }
@@ -248,20 +385,20 @@ export class CommandHandler {
         }
         // /compact 命令：手动压缩会话上下文
         if (normalizedContent === '/compact') {
-            const result = await this.ensureSession(channel, channelId);
+            const result = await this.ensureSession(channel, channelId, threadId);
             if ('error' in result)
                 return result.error;
             const { session } = result;
-            if (!session.claudeSessionId) {
+            if (!session.agentSessionId) {
                 return '❌ 当前会话没有历史记录，无需压缩';
             }
             const projectPath = path.isAbsolute(session.projectPath)
                 ? session.projectPath
                 : path.resolve(process.cwd(), session.projectPath);
             if (sendMessage) {
-                await sendMessage(channelId, '⏳ 正在压缩会话上下文...');
+                await sendMessage(channelId, '⏳ 正在压缩会话上下文...', this.getThreadSendOpts(session));
             }
-            const compacted = await this.agentRunner.compactSession(session.id, session.claudeSessionId, projectPath);
+            const compacted = await this.agentRunner.compactSession(session.id, session.agentSessionId, projectPath);
             if (compacted) {
                 return '✅ 会话上下文已压缩';
             }
@@ -269,8 +406,14 @@ export class CommandHandler {
                 return '❌ 会话压缩失败，请稍后重试';
             }
         }
-        // 尝试获取活跃会话（所有命令都尝试获取，但不强制）
-        let session = await this.sessionManager.getActiveSession(channel, channelId);
+        // 尝试获取活跃会话（话题时直接查找话题 session）
+        let session;
+        if (threadId) {
+            session = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
+        }
+        else {
+            session = await this.sessionManager.getActiveSession(channel, channelId);
+        }
         // 对于需要创建会话的命令，如果没有会话则创建
         if (!session && (normalizedContent.startsWith('/new') ||
             normalizedContent.startsWith('/bind') ||
@@ -286,18 +429,11 @@ export class CommandHandler {
 
 提示：发送任意消息或使用 /new 命令创建会话`;
             }
-            const sessionKey = `${channel}-${channelId}`;
+            const sessionKey = this.getQueueKey(session, channel, channelId);
             const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey);
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
-            let activeStatus = session.isActive ? '✓ 活跃' : '休眠';
-            if (session.isActive && isCurrentlyProcessing) {
-                if (queueLength > 0) {
-                    activeStatus += ` [处理中，队列${queueLength}条]`;
-                }
-                else {
-                    activeStatus += ' [处理中]';
-                }
-            }
+            const isThread = !!session.threadId;
+            const sessionStatus = isCurrentlyProcessing ? '处理中' : '空闲';
             const projectName = this.getProjectName(session.projectPath);
             const health = await this.sessionManager.getHealthStatus(session.id);
             const timeSinceSuccess = Date.now() - health.lastSuccessTime;
@@ -306,8 +442,8 @@ export class CommandHandler {
                     `${Math.floor(timeSinceSuccess / 3600000)}小时前`;
             // 获取会话文件信息并同步 name
             let sessionTurns = 0;
-            if (session.claudeSessionId) {
-                const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.claudeSessionId);
+            if (session.agentSessionId) {
+                const fileInfo = this.sessionManager.getSessionFileInfo(session.projectPath, session.agentSessionId);
                 sessionTurns = fileInfo.turns;
                 if (fileInfo.title && fileInfo.title !== session.name) {
                     await this.sessionManager.renameSession(session.id, fileInfo.title);
@@ -316,10 +452,10 @@ export class CommandHandler {
             }
             const lines = [];
             if (isAdmin) {
-                lines.push('📊 会话状态：', `渠道: ${channel} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `活跃状态: ${activeStatus}`, `会话轮数: ${sessionTurns}`, `异常计数: ${health.consecutiveErrors}`, `安全模式: ${health.safeMode ? '是 ⚠️' : '否 ✓'}`, `最后成功: ${timeStr}`, `Claude会话: ${session.claudeSessionId || '(未初始化)'}`, `创建时间: ${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}`, `异常计数: ${health.consecutiveErrors}`, `安全模式: ${health.safeMode ? '是 ⚠️' : '否 ✓'}`, `最后成功: ${timeStr}`, `Claude会话: ${session.agentSessionId || '(未初始化)'}`, `创建时间: ${new Date(session.createdAt).toLocaleString('zh-CN')}`, `更新时间: ${new Date(session.updatedAt).toLocaleString('zh-CN')}`);
             }
             else {
-                lines.push('📊 会话状态：', `会话: ${session.name || '(未命名)'}`, `状态: ${activeStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `会话: ${session.name || '(未命名)'}`, `状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
             }
             if (health.safeMode) {
                 lines.push('');
@@ -380,10 +516,17 @@ export class CommandHandler {
                     return sessionsWithMessages.join('\n') + '\n再次输入 /restart 将强制重启。';
                 }
             }
+            // 话题中 restart 时保存 rootId 用于重启后回复到话题
+            let rootId;
+            if (threadId) {
+                const threadSession = await this.sessionManager.getOrCreateSession(channel, channelId, this.config.projects?.defaultPath || process.cwd(), threadId);
+                rootId = threadSession.metadata?.feishu?.rootId;
+            }
             const restartInfo = {
                 channel,
                 channelId,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                ...(rootId ? { rootId } : {})
             };
             fs.writeFileSync(path.join(resolvePaths().dataDir, 'restart-pending.json'), JSON.stringify(restartInfo));
             const { spawn } = await import('child_process');
@@ -508,7 +651,7 @@ export class CommandHandler {
             }
             const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath);
             const cachedEvents = this.messageCache.getEvents(newSession.id);
-            const hasExistingSession = newSession.claudeSessionId ? '（恢复已有会话）' : '（新建会话）';
+            const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
             let response = `✓ 已切换到项目: ${projectName}\n  路径: ${projectPath}\n  ${hasExistingSession}`;
             if (cachedEvents.length > 0 && sendMessage) {
                 for (const event of cachedEvents) {
@@ -544,7 +687,7 @@ export class CommandHandler {
             }
             const newSession = await this.sessionManager.switchProject(channel, channelId, projectPath);
             const cachedEvents = this.messageCache.getEvents(newSession.id);
-            const hasExistingSession = newSession.claudeSessionId ? '（恢复已有会话）' : '（新建会话）';
+            const hasExistingSession = newSession.agentSessionId ? '（恢复已有会话）' : '（新建会话）';
             let response = `✓ 已绑定项目目录: ${projectPath}\n  ${hasExistingSession}`;
             if (cachedEvents.length > 0) {
                 response += `\n\n后台任务结果:`;
@@ -585,7 +728,7 @@ export class CommandHandler {
                     const sdkName = sdkSession.customTitle || undefined;
                     if (!sdkName)
                         continue;
-                    const dbSession = currentProjectSessions.find(s => s.claudeSessionId === sdkSession.sessionId);
+                    const dbSession = currentProjectSessions.find(s => s.agentSessionId === sdkSession.sessionId);
                     if (dbSession && sdkName !== dbSession.name) {
                         await this.sessionManager.renameSession(dbSession.id, sdkName);
                         dbSession.name = sdkName;
@@ -599,19 +742,22 @@ export class CommandHandler {
             const cliSessions = (isGroup || !isAdmin)
                 ? []
                 : await this.sessionManager.scanCliSessions(session.projectPath);
-            const dbSessionIds = new Set(currentProjectSessions.map(s => s.claudeSessionId).filter(Boolean));
+            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);
             if (currentProjectSessions.length > 0) {
                 lines.push('【EvolClaw 会话】');
-                for (const s of currentProjectSessions) {
+                for (let i = 0; i < currentProjectSessions.length; i++) {
+                    const s = currentProjectSessions[i];
                     const prefix = s.isActive ? '  ✓' : '   ';
+                    const num = `${i + 1}.`;
+                    const threadTag = s.threadId ? '[话题] ' : '';
                     const name = s.name || '(未命名)';
-                    const uuid = s.claudeSessionId ? `(${s.claudeSessionId.substring(0, 8)})` : '';
+                    const uuid = s.agentSessionId ? `(${s.agentSessionId.substring(0, 8)})` : '';
                     const idleTime = formatIdleTime(Date.now() - s.updatedAt);
-                    if (s.claudeSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.claudeSessionId)) {
-                        lines.push(`${prefix} ❌ ${name} ${uuid} - ${idleTime} [会话文件缺失]`);
+                    if (s.agentSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.agentSessionId)) {
+                        lines.push(`${prefix} ${num} ${threadTag}❌ ${name} ${uuid} - ${idleTime} [会话文件缺失]`);
                     }
                     else {
                         let status = '[空闲]';
@@ -621,7 +767,7 @@ export class CommandHandler {
                         else if (s.isActive) {
                             status = '[活跃]';
                         }
-                        lines.push(`${prefix} ${name} ${uuid} - ${idleTime} ${status}`);
+                        lines.push(`${prefix} ${num} ${threadTag}${name} ${uuid} - ${idleTime} ${status}`);
                     }
                 }
                 lines.push('');
@@ -637,20 +783,32 @@ export class CommandHandler {
                 }
                 lines.push('');
             }
-            lines.push('使用 /s <name或8位uuid> 切换会话');
+            lines.push('使用 /s <序号、name或8位uuid> 切换会话');
             return lines.join('\n');
         }
         // /session 或 /s 命令：切换会话
         if (normalizedContent.startsWith('/session ')) {
             const sessionName = normalizedContent.slice(9).trim();
             if (!sessionName)
-                return '用法: /s <会话名称或前8位UUID>';
+                return '用法: /s <序号、会话名称或前8位UUID>';
             const sessionKey = `${channel}-${channelId}`;
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
             if (queueLength > 0) {
                 return `⚠️ 当前正在处理消息，无法切换会话\n请等待当前任务完成后再试`;
             }
             let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
+            // 序号切换：纯数字时按当前项目会话列表序号匹配
+            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];
+                }
+                else {
+                    return `❌ 序号超出范围 (1-${projectSessions.length})\n使用 /slist 查看可用会话`;
+                }
+            }
             if (!targetSession && sessionName.length === 8) {
                 targetSession = await this.sessionManager.getSessionByUuidPrefix(channel, channelId, sessionName);
             }
@@ -673,8 +831,8 @@ export class CommandHandler {
             if (!targetSession) {
                 return `❌ 会话不存在: ${sessionName}\n使用 /slist 查看可用会话`;
             }
-            const lastInput = targetSession.claudeSessionId
-                ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.claudeSessionId)
+            const lastInput = targetSession.agentSessionId
+                ? this.sessionManager.readSessionLastUserMessage(targetSession.projectPath, targetSession.agentSessionId)
                 : null;
             const lastInputLine = lastInput ? `\n  最后输入: "${lastInput}"` : '';
             if (!session) {
@@ -687,11 +845,16 @@ export class CommandHandler {
             if (targetSession.id === session.id) {
                 return `当前已在会话: ${targetSession.name || sessionName}`;
             }
+            // 阻止从主会话切换到话题会话
+            if (!session.threadId && targetSession.threadId) {
+                return `❌ 无法从主会话切换到话题会话\n话题会话仅在对应话题内可用`;
+            }
             const switched = await this.sessionManager.switchToSession(channel, channelId, targetSession.id);
             if (!switched) {
                 return `❌ 切换会话失败`;
             }
-            return `✓ 已切换到会话: ${targetSession.name || sessionName}\n  将继续之前的对话历史${lastInputLine}`;
+            const continueHint = lastInput ? '\n  将继续之前的对话历史' : '\n  当前会话未有发言';
+            return `✓ 已切换到会话: ${targetSession.name || sessionName}${continueHint}${lastInputLine}`;
         }
         // /rename 或 /name 命令：重命名当前会话
         if (normalizedContent.startsWith('/rename ')) {
@@ -711,9 +874,9 @@ export class CommandHandler {
                 return `❌ 会话名称 "${newName}" 已存在，请使用其他名称`;
             }
             // 双写：SDK + 数据库
-            if (session.claudeSessionId) {
+            if (session.agentSessionId) {
                 try {
-                    await sdkRenameSession(session.claudeSessionId, newName, { dir: session.projectPath });
+                    await sdkRenameSession(session.agentSessionId, newName, { dir: session.projectPath });
                 }
                 catch (error) {
                     logger.warn(`[CommandHandler] SDK renameSession failed (continuing with db update):`, error);
@@ -725,17 +888,59 @@ export class CommandHandler {
             }
             return `✓ 已将当前会话重命名为: ${newName}`;
         }
+        // /del 命令：删除指定会话（仅解绑，不删除文件）
+        if (normalizedContent.startsWith('/del ')) {
+            const sessionName = normalizedContent.slice(5).trim();
+            if (!sessionName)
+                return '用法: /del <序号、会话名称或前8位UUID>';
+            if (!session) {
+                return `❌ 当前没有活跃会话`;
+            }
+            // 群聊权限检查：只有管理员可以删除
+            const isGroup = await this.isGroupChat(channel, channelId);
+            if (isGroup && !isAdmin) {
+                return `❌ 无权限：群聊中仅管理员可删除会话`;
+            }
+            let targetSession = await this.sessionManager.getSessionByName(channel, channelId, sessionName);
+            // 序号删除
+            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];
+                }
+                else {
+                    return `❌ 序号超出范围 (1-${projectSessions.length})\n使用 /slist 查看可用会话`;
+                }
+            }
+            if (!targetSession && sessionName.length === 8) {
+                targetSession = await this.sessionManager.getSessionByUuidPrefix(channel, channelId, sessionName);
+            }
+            if (!targetSession) {
+                return `❌ 会话不存在: ${sessionName}\n使用 /slist 查看可用会话`;
+            }
+            if (targetSession.id === session.id) {
+                return `❌ 无法删除当前活跃会话\n请先切换到其他会话`;
+            }
+            const success = await this.sessionManager.unbindSession(targetSession.id);
+            if (!success) {
+                return `❌ 删除失败`;
+            }
+            await this.agentRunner.closeSession(targetSession.id);
+            return `✓ 已删除会话: ${targetSession.name || sessionName}\n会话文件已保留，可通过 CLI 访问`;
+        }
         // /fork 命令：分支当前会话
         if (normalizedContent === '/fork' || normalizedContent.startsWith('/fork ')) {
             const forkName = normalizedContent.slice(5).trim() || undefined;
             if (!session) {
                 return `❌ 当前没有活跃会话，无法分支`;
             }
-            if (!session.claudeSessionId) {
+            if (!session.agentSessionId) {
                 return `❌ 当前会话尚未初始化 Claude 对话，无法分支\n\n请先发送一条消息，然后再使用 /fork`;
             }
             try {
-                const forkResult = await sdkForkSession(session.claudeSessionId, { dir: session.projectPath, title: forkName });
+                const forkResult = await sdkForkSession(session.agentSessionId, { dir: session.projectPath, title: forkName });
                 const newSession = await this.sessionManager.createForkedSession(session, forkResult.sessionId, forkName);
                 return `✅ 会话已分支: ${newSession.name}\n新会话已激活，可以继续对话\n\n使用 /slist 查看所有会话，/s <名称> 切换回原会话`;
             }
@@ -757,7 +962,7 @@ export class CommandHandler {
             const fsPromises = await import('fs/promises');
             try {
                 const backupDir = await backupClaudeDir(session.projectPath);
-                if (!session.claudeSessionId) {
+                if (!session.agentSessionId) {
                     await this.sessionManager.resetHealthStatus(session.id);
                     return `✓ 修复完成，已退出安全模式
 
@@ -768,11 +973,11 @@ export class CommandHandler {
 
 备份位置：${backupDir}`;
                 }
-                const healthCheck = await checkSessionFileHealth(session.projectPath, session.claudeSessionId);
+                const healthCheck = await checkSessionFileHealth(session.projectPath, session.agentSessionId);
                 if (healthCheck.corrupt) {
-                    const sessionFile = path.join(session.projectPath, '.claude', `${session.claudeSessionId}.jsonl`);
+                    const sessionFile = path.join(session.projectPath, '.claude', `${session.agentSessionId}.jsonl`);
                     await fsPromises.unlink(sessionFile);
-                    await this.sessionManager.updateClaudeSessionId(session.channel, session.channelId, '');
+                    await this.sessionManager.updateAgentSessionId(session.channel, session.channelId, '');
                     await this.sessionManager.resetHealthStatus(session.id);
                     return `✓ 修复完成，已退出安全模式