evolclaw 2.1.0 → 2.1.1

package/README.md

@@ -128,10 +128,10 @@ evolclaw init wechat
   },
   "idleMonitor": {
     "enabled": true,                            // 任务超时监控开关
-    "timeout": 120000,                          // 超时阈值（ms），默认 2 分钟
+    "timeout": 120,                             // 超时阈值（秒），默认 120 秒
     "safeModeThreshold": 3                      // 连续超时 N 次后进入安全模式（设为 0 禁用安全模式）
   },
-  "flushDelay": 4000                            // 工具活动消息聚合发送间隔（ms），默认 4 秒
+  "flushDelay": 4                               // 工具活动消息聚合发送间隔（秒），默认 4 秒
 }
 ```
 
@@ -139,6 +139,7 @@ evolclaw init wechat
 - `apiKey`：配置文件 → `ANTHROPIC_AUTH_TOKEN` 环境变量 → `~/.claude/settings.json`
 - `baseUrl`：配置文件 → `ANTHROPIC_BASE_URL` 环境变量 → `~/.claude/settings.json`
 - `model`：配置文件 → `~/.claude/settings.json` → 默认 `sonnet`
+- `effort`：配置文件 → `~/.claude/settings.json` → SDK 默认值（`auto`）
 
 ### 3. 运行
 
@@ -192,6 +193,7 @@ evolclaw/
 - `/slist` - 列出当前项目的所有会话
 - `/s <名称>` - 切换到指定会话
 - `/name <新名称>` - 重命名当前会话
+- `/del <名称>` - 删除指定会话（仅解绑，不删除文件）
 - `/status` - 显示会话状态
 - `/help` - 显示所有命令
 
@@ -212,8 +214,11 @@ evolclaw/
 - `/safe` - 进入安全模式
 
 **模型管理**：
-- `/model` - 显示当前模型和可用列表
-- `/model <model-id>` - 切换模型
+- `/model` - 显示当前模型和推理强度
+- `/model <model>` - 切换模型
+- `/model <effort>` - 切换推理强度（low / medium / high / max）
+- `/model <model> <effort>` - 同时切换模型和推理强度
+- `/model auto` - 恢复 SDK 默认推理强度
 
 ## 技术栈
 

package/dist/channels/feishu.js

@@ -228,7 +228,8 @@ export class FeishuChannel {
                         logger.error('[Feishu] Failed to process message:', error);
                     }
                 },
-                'im.message.message_read_v1': async () => { }
+                'im.message.message_read_v1': async () => { },
+                'im.message.reaction.created_v1': async () => { }
             });
             this.wsClient = new lark.WSClient({
                 appId: this.config.appId,
@@ -336,6 +337,11 @@ export class FeishuChannel {
             logger.debug(`[Feishu] Sent message as ${useMarkdown ? 'post (Markdown)' : 'text'}`);
         }
         catch (error) {
+            // 230011: 消息已被撤回，降级为普通消息重试
+            if (error.response?.data?.code === 230011 && options?.replyToMessageId) {
+                logger.warn('[Feishu] Message withdrawn (230011), retrying without reply');
+                return this.sendMessage(chatId, content, { ...options, replyToMessageId: undefined });
+            }
             logger.error('[Feishu] Failed to send message:', error);
             throw error;
         }

package/dist/cli.js

@@ -537,8 +537,9 @@ async function cmdRestartMonitor() {
     for (let attempt = 1; attempt <= MAX_HEAL_ATTEMPTS; attempt++) {
         log(`Self-heal attempt ${attempt}/${MAX_HEAL_ATTEMPTS}`);
         await notifyChannel(p, pendingInfo, `🔧 自动修复中（第 ${attempt}/${MAX_HEAL_ATTEMPTS} 次）...`, log);
-        // 调用 claude CLI 修复
-        const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, log);
+        // 调用 claude CLI 修复（递增超时：3/4/5 分钟）
+        const timeout = (2 + attempt) * 60 * 1000;
+        const healed = await invokeClaude(p, attempt, MAX_HEAL_ATTEMPTS, timeout, log);
         if (!healed) {
             log(`Self-heal attempt ${attempt} failed (claude invocation error)`);
             continue;
@@ -633,7 +634,7 @@ async function spawnAndWaitReady(p, log, timeout) {
 /**
  * 调用 claude CLI 进行自动修复
  */
-async function invokeClaude(p, attempt, maxAttempts, log) {
+async function invokeClaude(p, attempt, maxAttempts, timeout, log) {
     const projectDir = getPackageRoot();
     const selfHealLog = p.selfHealLog;
     const stdoutLog = path.join(p.logs, 'stdout.log');
@@ -659,26 +660,31 @@ async function invokeClaude(p, attempt, maxAttempts, log) {
 
 注意：只修复导致启动失败的问题，不要做额外的重构或优化。`;
     try {
-        log(`Invoking claude CLI (attempt ${attempt})...`);
+        log(`Invoking claude CLI (attempt ${attempt}, timeout ${timeout / 60000}min)...`);
         const { stdout, stderr } = await execFileAsync('claude', [
             '-p', prompt,
             '--allowedTools', 'Read,Write,Edit,Bash,Glob,Grep',
             '--output-format', 'text',
         ], {
             cwd: projectDir,
-            timeout: 5 * 60 * 1000, // 5 分钟超时
+            timeout,
             env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'cli' },
             maxBuffer: 10 * 1024 * 1024,
         });
         if (stdout)
             log(`Claude output: ${stdout.slice(0, 500)}`);
         if (stderr)
-            log(`Claude stderr: ${stderr.slice(0, 200)}`);
+            log(`Claude stderr: ${stderr.slice(0, 500)}`);
         log(`Claude CLI completed (attempt ${attempt})`);
         return true;
     }
     catch (error) {
-        log(`Claude CLI error: ${error.message?.slice(0, 300) || error}`);
+        const msg = error.message || String(error);
+        log(`Claude CLI error: ${msg.slice(0, 800)}`);
+        if (error.stdout)
+            log(`Stdout: ${String(error.stdout).slice(0, 500)}`);
+        if (error.stderr)
+            log(`Stderr: ${String(error.stderr).slice(0, 500)}`);
         return false;
     }
 }

package/dist/config.js

@@ -37,7 +37,10 @@ export function resolveAnthropicConfig(config) {
     const model = config.agents?.anthropic?.model
         || settings.model
         || 'sonnet';
-    return { apiKey, baseUrl, model };
+    const effort = config.agents?.anthropic?.effort
+        || settings.effortLevel
+        || undefined;
+    return { apiKey, baseUrl, model, effort };
 }
 export function loadConfig(configPath = resolvePaths().config) {
     if (!fs.existsSync(configPath)) {

package/dist/core/agent-runner.js

@@ -10,6 +10,7 @@ import { encodePath } from '../utils/platform.js';
 export class AgentRunner {
     apiKey;
     model;
+    effort;
     baseUrl;
     config;
     activeSessions = new Map();
@@ -19,6 +20,7 @@ export class AgentRunner {
     constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
         this.apiKey = apiKey;
         this.model = model || 'sonnet';
+        this.effort = undefined;
         this.baseUrl = baseUrl;
         this.config = config;
         this.onSessionIdUpdate = onSessionIdUpdate;
@@ -38,10 +40,38 @@ export class AgentRunner {
     getModel() {
         return this.model;
     }
+    setEffort(effort) {
+        this.effort = effort;
+    }
+    getEffort() {
+        return this.effort;
+    }
+    syncFromUserSettings() {
+        try {
+            const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return;
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (settings.model && settings.model !== this.model) {
+                logger.info(`[AgentRunner] Synced model from ~/.claude/settings.json: ${settings.model}`);
+                this.model = settings.model;
+            }
+            const newEffort = settings.effortLevel || undefined;
+            if (newEffort !== this.effort) {
+                logger.info(`[AgentRunner] Synced effort from ~/.claude/settings.json: ${newEffort ?? 'auto'}`);
+                this.effort = newEffort;
+            }
+        }
+        catch (error) {
+            logger.debug(`[AgentRunner] Failed to sync from ~/.claude/settings.json:`, error);
+        }
+    }
     setCompactStartCallback(callback) {
         this.onCompactStart = callback;
     }
     async runQuery(sessionId, prompt, projectPath, initialClaudeSessionId, images, systemPromptAppend, sessionManager) {
+        // 同步用户级配置到内存
+        this.syncFromUserSettings();
         ensureDir(projectPath);
         ensureDir(path.join(projectPath, '.claude'));
         // 优先使用传入的 agentSessionId（从数据库恢复），否则使用内存中的
@@ -117,9 +147,11 @@ export class AgentRunner {
         const useSettingSources = this.config?.agents?.anthropic?.useSettingSources !== false;
         const enableSummaries = this.config?.agents?.anthropic?.agentProgressSummaries !== false;
         // 公共 options（新旧模式共用）
+        logger.info(`[AgentRunner] runQuery model=${this.model} effort=${this.effort ?? 'auto'}`);
         const commonOptions = {
             cwd: projectPath,
             model: this.model,
+            ...(this.effort ? { effort: this.effort } : {}),
             canUseTool,
             permissionMode: 'default',
             persistSession: true,

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',
@@ -56,7 +95,7 @@ const aliases = {
 // 命令快速路径前缀（不进入消息队列的命令）
 // 注意：/clear, /compact, /safe 故意不在此列表中，它们需要进入队列触发中断机制
 // /stop 是快速命令：直接调用 agentRunner.interrupt()，不走队列（否则队列自动中断后 /stop 检测不到活跃任务）
-const quickCommandPrefixes = ['/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart', '/model', '/slist', '/session', '/rename', '/repair', '/fork', '/stop', '/p ', '/s ', '/name '];
+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;
@@ -89,6 +128,11 @@ export class CommandHandler {
             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, threadId) {
         if (threadId) {
@@ -136,14 +180,14 @@ export class CommandHandler {
         const { isOwner: checkOwner } = await import('../config.js');
         // 话题内禁用部分命令
         if (threadId) {
-            const threadBlocked = ['/new', '/slist', '/plist', '/bind', '/s', '/session', '/project', '/p', '/fork'];
+            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 '❌ 无权限：此命令仅限管理员使用';
@@ -178,6 +222,7 @@ export class CommandHandler {
   /slist - 列出当前项目的所有会话
   /s, /session <名称> - 切换到指定会话
   /name, /rename <新名称> - 重命名当前会话
+  /del <名称> - 删除指定会话（仅解绑，不删除文件）
   /status - 显示会话状态
 
 ❓ 帮助：
@@ -195,6 +240,7 @@ export class CommandHandler {
   /slist - 列出当前项目的所有会话
   /s, /session <名称> - 切换到指定会话
   /name, /rename <新名称> - 重命名当前会话
+  /del <名称> - 删除指定会话（仅解绑，不删除文件）
   /fork [名称] - 分支当前会话（从当前对话点创建分支）
   /status - 显示会话状态
   /clear - 清空当前会话的对话历史
@@ -207,31 +253,94 @@ 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默认`;
+            }
+            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(' / ')}`;
+                }
             }
-            if (!availableModels.includes(args)) {
-                const modelList = availableModels.map(m => `- ${m}`).join('\n');
-                return `❌ 无效的模型ID: ${args}\n\n可用模型：\n${modelList}`;
+            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') {
@@ -287,7 +396,7 @@ export class CommandHandler {
                 ? 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.agentSessionId, projectPath);
             if (compacted) {
@@ -324,15 +433,7 @@ export class CommandHandler {
             const isCurrentlyProcessing = this.messageQueue.isProcessing(sessionKey);
             const queueLength = this.messageQueue.getQueueLength(sessionKey);
             const isThread = !!session.threadId;
-            let activeStatus = isThread ? '话题' : (session.isActive ? '✓ 活跃' : '休眠');
-            if ((isThread || session.isActive) && isCurrentlyProcessing) {
-                if (queueLength > 0) {
-                    activeStatus += ` [处理中，队列${queueLength}条]`;
-                }
-                else {
-                    activeStatus += ' [处理中]';
-                }
-            }
+            const sessionStatus = isCurrentlyProcessing ? '处理中' : '空闲';
             const projectName = this.getProjectName(session.projectPath);
             const health = await this.sessionManager.getHealthStatus(session.id);
             const timeSinceSuccess = Date.now() - health.lastSuccessTime;
@@ -351,10 +452,10 @@ export class CommandHandler {
             }
             const lines = [];
             if (isAdmin) {
-                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `渠道: ${channel} / 项目: ${projectName} / 会话: ${session.name || '(未命名)'}`, `会话ID: ${session.id}`, `项目路径: ${session.projectPath}`, `活跃状态: ${activeStatus}`, `会话轮数: ${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}`, `异常计数: ${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(`📊 ${isThread ? '话题' : '会话'}状态：`, `会话: ${session.name || '(未命名)'}`, `状态: ${activeStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
+                lines.push(`📊 ${isThread ? '话题' : '会话'}状态：`, `会话: ${session.name || '(未命名)'}`, `状态: ${sessionStatus}`, `会话轮数: ${sessionTurns}`, `最后活跃: ${timeStr}`);
             }
             if (health.safeMode) {
                 lines.push('');
@@ -647,13 +748,16 @@ export class CommandHandler {
             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.agentSessionId ? `(${s.agentSessionId.substring(0, 8)})` : '';
                     const idleTime = formatIdleTime(Date.now() - s.updatedAt);
                     if (s.agentSessionId && !this.sessionManager.checkSessionFileExists(s.projectPath, s.agentSessionId)) {
-                        lines.push(`${prefix} ❌ ${name} ${uuid} - ${idleTime} [会话文件缺失]`);
+                        lines.push(`${prefix} ${num} ${threadTag}❌ ${name} ${uuid} - ${idleTime} [会话文件缺失]`);
                     }
                     else {
                         let status = '[空闲]';
@@ -663,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('');
@@ -679,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);
             }
@@ -729,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 ')) {
@@ -767,6 +888,48 @@ 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;