@wu529778790/open-im 1.11.1-beta.6 → 1.11.1-beta.8

package/dist/adapters/claude-sdk-adapter.d.ts

@@ -1,13 +1,12 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK query() API 实现多轮对话
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
- *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * query() API:
+ * - 返回 AsyncGenerator<SDKMessage>，直接迭代即可
+ * - 支持 resume/cwd/model 等 options，无需 process.chdir hack
+ * - SDK 内部管理 session 生命周期，无需手动维护 session pool
  */
+import type { SDKSessionInfo } from '@anthropic-ai/claude-agent-sdk';
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
 interface ClaudeSessionMeta {
     sessionId: string;
@@ -16,26 +15,19 @@ interface ClaudeSessionMeta {
     size: number;
 }
 /**
- * 扫描 ~/.claude/projects/<encoded-path>/ 找到最新的 CLI session。
- * 只返回 JSONL 文件（排除子目录如 subagents/），按修改时间倒序。
- * @param homeOverride 测试用：覆盖 homedir() 的返回值
- */
-export declare function findLatestClaudeSession(workDir: string, homeOverride?: string): ClaudeSessionMeta | undefined;
-/**
- * 由 initAdapters 根据配置调用。ttlMinutes≤0 时关闭空闲回收（仍受 MAX_ACTIVE_SESSIONS 限制）。
+ * Find the latest CLI session for a work directory using the SDK's listSessions.
  */
-export declare function configureClaudeSdkSessionIdle(ttlMinutes: number): void;
+export declare function findLatestClaudeSession(workDir: string): Promise<ClaudeSessionMeta | undefined>;
 export declare class ClaudeSDKAdapter implements ToolAdapter {
     readonly toolId = "claude-sdk";
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * 清理所有活跃的查询
      */
     static destroy(): void;
     /**
-     * Remove a specific session from the in-memory cache and close it.
-     * Useful when the caller knows a session is corrupted.
+     * List sessions for a directory using the SDK's listSessions API.
      */
-    static removeSession(sessionId: string): void;
+    static listSessionsForDir(workDir: string, limit?: number): Promise<SDKSessionInfo[]>;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }
 export {};

package/dist/adapters/claude-sdk-adapter.js

@@ -1,15 +1,13 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK query() API 实现多轮对话
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
- *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * query() API:
+ * - 返回 AsyncGenerator<SDKMessage>，直接迭代即可
+ * - 支持 resume/cwd/model 等 options，无需 process.chdir hack
+ * - SDK 内部管理 session 生命周期，无需手动维护 session pool
  */
-import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
-import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync } from 'fs';
+import { query, listSessions } from '@anthropic-ai/claude-agent-sdk';
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -53,8 +51,6 @@ loadUserPluginSettings();
  * ~/.claude/projects/-Users-mac-github-open-im/
  */
 function workDirToProjectPath(workDir) {
-    // Claude Code 将路径中的 / 替换为 -，leading - 保留
-    // /Users/mac/github/open-im → -Users-mac-github-open-im
     return workDir.replace(/\//g, '-');
 }
 /**
@@ -71,14 +67,9 @@ function workDirToProjectPath(workDir) {
  */
 function isCliSessionActive(sessionId, sessionFilePath) {
     try {
-        // macOS/Linux: 用 ps 搜索包含该 sessionId 的 claude 进程
-        // 排除 open-im 自己的 SDK 子进程（路径含 claude-agent-sdk），只匹配用户交互式 CLI
-        // -F 固定字符串匹配，避免正则意外；-- 防止 sessionId 被误认为 flag
         const result = execSync(`ps -axo pid,command 2>/dev/null | grep -v grep | grep "claude" | grep -v "claude-agent-sdk" | grep -F -- "${sessionId}" || true`, { encoding: 'utf-8', timeout: 3000 });
         if (result.trim().length === 0)
             return false;
-        // 进程存在，但可能只是 idle 在终端等输入。检查文件 mtime：
-        // 如果 session 文件超过 30 秒未修改，说明 CLI 没在活跃处理。
         if (sessionFilePath) {
             try {
                 const stat = statSync(sessionFilePath);
@@ -99,51 +90,28 @@ function isCliSessionActive(sessionId, sessionFilePath) {
     }
 }
 /**
- * 扫描 ~/.claude/projects/<encoded-path>/ 找到最新的 CLI session。
- * 只返回 JSONL 文件（排除子目录如 subagents/），按修改时间倒序。
- * @param homeOverride 测试用：覆盖 homedir() 的返回值
+ * Find the latest CLI session for a work directory using the SDK's listSessions.
  */
-export function findLatestClaudeSession(workDir, homeOverride) {
-    const projectDir = join(homeOverride ?? homedir(), '.claude', 'projects', workDirToProjectPath(workDir));
-    if (!existsSync(projectDir)) {
-        log.info(`No Claude Code project dir found: ${projectDir}`);
-        return undefined;
-    }
+export async function findLatestClaudeSession(workDir) {
     try {
-        const entries = readdirSync(projectDir, { withFileTypes: true });
-        const sessions = [];
-        for (const entry of entries) {
-            // 只处理 .jsonl 文件，跳过子目录（如 subagents/）和 memory 目录
-            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
-                continue;
-            const sessionId = entry.name.replace('.jsonl', '');
-            // 校验 UUID 格式
-            if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(sessionId))
-                continue;
-            const filePath = join(projectDir, entry.name);
-            try {
-                const stat = statSync(filePath);
-                // 跳过空文件
-                if (stat.size === 0)
-                    continue;
-                sessions.push({ sessionId, mtime: stat.mtimeMs, filePath, size: stat.size });
-            }
-            catch {
-                continue;
-            }
-        }
+        const sessions = await listSessions({ dir: workDir, limit: 1 });
         if (sessions.length === 0) {
-            log.info(`No session files found in ${projectDir}`);
+            log.info(`No sessions found for ${workDir}`);
             return undefined;
         }
-        // 按修改时间倒序，最新的在前
-        sessions.sort((a, b) => b.mtime - a.mtime);
         const latest = sessions[0];
-        log.info(`Found latest Claude Code session: ${latest.sessionId} (mtime: ${new Date(latest.mtime).toISOString()}, size: ${latest.size})`);
-        return latest;
+        const projectDir = join(homedir(), '.claude', 'projects', workDirToProjectPath(workDir));
+        const filePath = join(projectDir, `${latest.sessionId}.jsonl`);
+        log.info(`Found latest session via SDK: ${latest.sessionId} (lastModified: ${new Date(latest.lastModified).toISOString()})`);
+        return {
+            sessionId: latest.sessionId,
+            mtime: latest.lastModified,
+            filePath,
+            size: latest.fileSize ?? 0,
+        };
     }
     catch (err) {
-        log.warn(`Failed to scan Claude Code project dir: ${err}`);
+        log.warn(`Failed to list sessions via SDK: ${err}`);
         return undefined;
     }
 }
@@ -177,104 +145,6 @@ function validateSessionFile(filePath, expectedSessionId) {
         }
     }
 }
-// 存储所有活跃的 SDKSession 对象，key 为 sessionId
-// 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
-const activeSessions = new Map();
-// 记录每个 session 创建/恢复时的 workDir，防止跨 workDir 复用已固定 cwd 的子进程
-const sessionWorkDirs = new Map();
-// 存储正在进行的流式迭代器，用于中断
-const activeStreams = new Set();
-// 空闲会话清理：跟踪最后使用时间，定期清除超时会话
-const sessionLastUsed = new Map();
-// 跟踪正在执行任务的 session ID，防止空闲清理误杀运行中的长任务
-const runningSessions = new Set();
-let sessionIdleTtlMs = 30 * 60 * 1000; // 默认 30 分钟未使用则清理
-let sessionIdleCleanupDisabled = false;
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 每 5 分钟检查一次
-const MAX_ACTIVE_SESSIONS = 100;
-const MAX_CAPTURED_STDERR_CHARS = 4000;
-const MAX_EXPOSED_STDERR_CHARS = 500;
-let sessionSeq = 0;
-/**
- * 由 initAdapters 根据配置调用。ttlMinutes≤0 时关闭空闲回收（仍受 MAX_ACTIVE_SESSIONS 限制）。
- */
-export function configureClaudeSdkSessionIdle(ttlMinutes) {
-    if (ttlMinutes <= 0) {
-        sessionIdleCleanupDisabled = true;
-        log.info('Claude SDK: idle session cleanup disabled (sessionIdleTtlMinutes=0)');
-    }
-    else {
-        sessionIdleCleanupDisabled = false;
-        sessionIdleTtlMs = ttlMinutes * 60 * 1000;
-    }
-}
-const cleanupInterval = setInterval(() => {
-    if (sessionIdleCleanupDisabled)
-        return;
-    const now = Date.now();
-    for (const [id, lastUsed] of sessionLastUsed) {
-        if (runningSessions.has(id))
-            continue; // 跳过正在运行任务的 session
-        if (now - lastUsed > sessionIdleTtlMs) {
-            const session = activeSessions.get(id);
-            if (session) {
-                try {
-                    session.close();
-                }
-                catch { /* ignore */ }
-                activeSessions.delete(id);
-            }
-            sessionLastUsed.delete(id);
-            sessionWorkDirs.delete(id);
-            log.info(`Cleaned up idle session (unused ${Math.round((now - lastUsed) / 60000)}min): ${id}`);
-        }
-    }
-}, CLEANUP_INTERVAL_MS);
-cleanupInterval.unref(); // 不阻止进程退出
-/**
- * 串行化进程级 process.chdir() —— 同一时刻仅一个 chdir 生效。
- *
- * SDK V2 的 createSession/resumeSession 不接受 cwd 参数；且 send()/stream()
- * 会以「调用时的 process.cwd()」派生 Claude Code 子进程。必须用互斥锁串行化
- * 「整个 turn 的 cwd 切换」，否则并发多用户会让工具跑错目录。
- *
- * **TODO:** SDK 支持 cwd 选项后移除此锁。upstream:
- * https://github.com/anthropics/claude-agent-sdk/issues
- */
-let chdirMutex = Promise.resolve();
-function withChdirMutex(fn) {
-    const previous = chdirMutex;
-    let release;
-    chdirMutex = new Promise((r) => { release = r; });
-    return previous.then(async () => {
-        try {
-            return await fn();
-        }
-        finally {
-            release();
-        }
-    });
-}
-/**
- * 在持有全局 chdir 互斥锁期间，把进程 cwd 切到 workDir 执行 fn，结束后恢复。
- * 用于包裹 session.send()+stream()，确保子进程在正确 workDir 派生。
- */
-function runWithWorkDir(workDir, fn) {
-    return withChdirMutex(async () => {
-        const originalCwd = process.cwd();
-        if (workDir && workDir !== originalCwd) {
-            process.chdir(workDir);
-        }
-        try {
-            return await fn();
-        }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-    });
-}
 function isStreamEvent(msg) {
     return msg.type === 'stream_event';
 }
@@ -291,6 +161,8 @@ function isResult(msg) {
 function isSessionCorruptionError(msg) {
     return /session\s*(not found|expired|corrupt)|no\s*conversation\s*found/i.test(msg);
 }
+const MAX_CAPTURED_STDERR_CHARS = 4000;
+const MAX_EXPOSED_STDERR_CHARS = 500;
 function appendStderrSnippet(previous, chunk) {
     const next = previous + chunk;
     if (next.length <= MAX_CAPTURED_STDERR_CHARS)
@@ -320,166 +192,32 @@ function enrichClaudeErrorMessage(message, stderr) {
     }
     return message;
 }
-/**
- * 获取或创建 SDKSession
- * @param sessionId 已有的 sessionId，如果为 undefined 则创建新会话
- * @param workDir 工作目录
- * @param model 模型名称
- * @param permissionMode 权限模式
- * @returns SDKSession 对象和实际的 sessionId
- */
-async function getOrCreateSession(sessionId, workDir, model, permissionMode, onStderr) {
-    // 刷新 Claude 环境变量（支持 cc switch 后无需重启即可生效）
-    refreshClaudeEnvToProcess();
-    const resolvedModel = model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
-    if (activeSessions.size >= MAX_ACTIVE_SESSIONS) {
-        throw new Error(`Session pool is full (${MAX_ACTIVE_SESSIONS}). Cannot create new session.`);
-    }
-    const sessionOptions = {
-        model: resolvedModel,
-        permissionMode,
-        stderr: onStderr,
-    };
-    const baseUrl = process.env.ANTHROPIC_BASE_URL ?? '(default)';
-    log.info(`[V2] getOrCreateSession model param=${String(model ?? '')} resolved=${resolvedModel} baseUrl=${baseUrl} workDir=${workDir}`);
-    // NOTE: process.chdir() 是进程级全局副作用，在并发服务器中不理想。
-    // 但 SDK 的 createSession/resumeSession 不接受 cwd 参数，且这些调用是同步的，
-    // 所以 mutex + try/finally 已是最优方案。如果 SDK 未来支持 cwd 选项，应移除 chdir。
-    return withChdirMutex(() => {
-        let session;
-        const originalCwd = process.cwd();
-        try {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(workDir);
-            }
-            if (sessionId) {
-                // 优先复用内存中已有的 SDKSession，避免每次都启动新进程。
-                // 仅当 workDir 与创建时一致才复用：否则子进程 cwd 已固定在旧目录，
-                // 需走 resume 重新派生（在当前 workDir 启动新子进程）。
-                const existing = activeSessions.get(sessionId);
-                if (existing && sessionWorkDirs.get(sessionId) === workDir) {
-                    log.info(`Reusing existing in-memory session: ${sessionId}`);
-                    sessionLastUsed.set(sessionId, Date.now());
-                    return { session: existing, sessionId };
-                }
-                // 内存中没有（或 workDir 变了），尝试通过 resume 恢复（会启动新 CLI 进程）
-                try {
-                    log.info(`Attempting to resume session: ${sessionId}`);
-                    session = unstable_v2_resumeSession(sessionId, sessionOptions);
-                    activeSessions.set(sessionId, session);
-                    sessionWorkDirs.set(sessionId, workDir);
-                    sessionLastUsed.set(sessionId, Date.now());
-                    log.info(`Successfully resumed session: ${sessionId}`);
-                    return { session, sessionId };
-                }
-                catch (err) {
-                    log.warn(`Failed to resume session ${sessionId}, creating new one: ${err}`);
-                    // 恢复失败，创建新会话
-                }
-            }
-            // 没有指定 sessionId 时，尝试自动恢复 Claude Code CLI 的最新 session
-            // 实现手机/电脑无缝切换：同目录下默认共享同一个对话
-            if (!sessionId) {
-                const latest = findLatestClaudeSession(workDir);
-                if (latest) {
-                    // 检测 CLI 是否正在使用该 session（用于日志，不阻止 resume）
-                    const cliActive = isCliSessionActive(latest.sessionId, latest.filePath);
-                    if (cliActive) {
-                        log.info(`CLI is actively using session ${latest.sessionId}, attempting resume anyway (SDK handles concurrency)`);
-                    }
-                    // 验证文件内容一致性
-                    if (validateSessionFile(latest.filePath, latest.sessionId)) {
-                        try {
-                            log.info(`Auto-resuming latest CLI session: ${latest.sessionId}${cliActive ? ' (CLI active)' : ''}`);
-                            session = unstable_v2_resumeSession(latest.sessionId, sessionOptions);
-                            activeSessions.set(latest.sessionId, session);
-                            sessionWorkDirs.set(latest.sessionId, workDir);
-                            sessionLastUsed.set(latest.sessionId, Date.now());
-                            log.info(`Successfully auto-resumed CLI session: ${latest.sessionId}`);
-                            return { session, sessionId: latest.sessionId };
-                        }
-                        catch (err) {
-                            log.warn(`Failed to auto-resume CLI session ${latest.sessionId}, creating new one: ${err}`);
-                        }
-                    }
-                    else {
-                        log.warn(`Session file validation failed for ${latest.sessionId}, skipping`);
-                    }
-                }
-            }
-            // 创建新会话
-            session = unstable_v2_createSession(sessionOptions);
-            // 新会话的 sessionId 需要从第一个消息中获取
-            // 暂时返回 undefined，稍后在 init 消息中获取
-            const tempId = `pending-${++sessionSeq}`;
-            activeSessions.set(tempId, session);
-            sessionWorkDirs.set(tempId, workDir);
-            sessionLastUsed.set(tempId, Date.now());
-            log.info(`Created new session (tempId: ${tempId})`);
-            return { session, sessionId: tempId, wasReused: false };
-        }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-    });
-}
 export class ClaudeSDKAdapter {
     toolId = 'claude-sdk';
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * 清理所有活跃的查询
      */
     static destroy() {
-        clearInterval(cleanupInterval);
-        for (const stream of activeStreams) {
-            try {
-                if (stream && typeof stream.return === 'function') {
-                    stream.return();
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        activeStreams.clear();
-        for (const session of activeSessions.values()) {
-            try {
-                session.close();
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        activeSessions.clear();
-        sessionLastUsed.clear();
-        sessionWorkDirs.clear();
+        // query() API 的 Query 对象通过 abortController.abort() 清理
+        // 不再需要手动管理 session pool
     }
     /**
-     * Remove a specific session from the in-memory cache and close it.
-     * Useful when the caller knows a session is corrupted.
+     * List sessions for a directory using the SDK's listSessions API.
      */
-    static removeSession(sessionId) {
-        const session = activeSessions.get(sessionId);
-        if (session) {
-            try {
-                session.close();
-            }
-            catch { /* ignore */ }
-            activeSessions.delete(sessionId);
-            sessionLastUsed.delete(sessionId);
-            sessionWorkDirs.delete(sessionId);
-            log.info(`Explicitly removed session: ${sessionId}`);
+    static async listSessionsForDir(workDir, limit = 20) {
+        try {
+            return await listSessions({ dir: workDir, limit });
+        }
+        catch (err) {
+            log.warn(`Failed to list sessions for ${workDir}: ${err}`);
+            return [];
         }
     }
     run(prompt, sessionId, workDir, callbacks, options) {
-        log.info(`[V2] run() entry model=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
+        // 刷新 Claude 环境变量（支持 cc switch 后无需重启即可生效）
+        refreshClaudeEnvToProcess();
         const abortController = new AbortController();
-        let streamClosed = false;
-        let actualSessionId;
-        let pendingTempId; // 记录临时 ID，用于 abort 时清理
         let runSettled = false;
-        let currentStream; // 用于 abort 时立即中断 stream
         let recentStderr = '';
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
@@ -488,79 +226,64 @@ export class ClaudeSDKAdapter {
                 : options?.permissionMode === 'plan'
                     ? 'plan'
                     : 'default';
-        const runSession = async () => {
-            let trackedRunningId; // 用于 finally 中清理 runningSessions
+        const resolvedModel = options?.model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
+        const baseUrl = process.env.ANTHROPIC_BASE_URL ?? '(default)';
+        log.info(`[query] run() entry model=${resolvedModel} baseUrl=${baseUrl} sessionId=${sessionId ?? 'new'} workDir=${workDir}`);
+        const runQuery = async () => {
+            let accumulated = '';
+            let accumulatedThinking = '';
+            const toolStats = {};
+            let actualSessionId;
+            let hadSessionInvalid = false;
             try {
-                // 检查环境变量
-                const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-                const hasAuthToken = !!process.env.ANTHROPIC_AUTH_TOKEN;
-                if (!hasApiKey && !hasAuthToken) {
-                    log.warn('Claude SDK: No API credentials found in environment variables');
-                }
-                log.info(`[V2] Session: ${sessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
-                log.info(`[V2] model param=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
-                // 获取或创建会话
-                const { session, sessionId: returnedId } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode, (data) => {
-                    recentStderr = appendStderrSnippet(recentStderr, data);
-                });
-                if (returnedId.startsWith('pending-')) {
-                    pendingTempId = returnedId;
+                // 先尝试自动恢复 CLI 的最新 session（如果用户没有指定 sessionId）
+                let resumeId = sessionId;
+                if (!resumeId) {
+                    const latest = await findLatestClaudeSession(workDir);
+                    if (latest) {
+                        const cliActive = isCliSessionActive(latest.sessionId, latest.filePath);
+                        if (cliActive) {
+                            log.info(`CLI is actively using session ${latest.sessionId}, attempting resume anyway`);
+                        }
+                        if (validateSessionFile(latest.filePath, latest.sessionId)) {
+                            resumeId = latest.sessionId;
+                            log.info(`Auto-resuming latest CLI session: ${latest.sessionId}${cliActive ? ' (CLI active)' : ''}`);
+                        }
+                        else {
+                            log.warn(`Session file validation failed for ${latest.sessionId}, skipping`);
+                        }
+                    }
                 }
-                runningSessions.add(returnedId);
-                trackedRunningId = returnedId;
-                // 在持有 chdir 锁期间完成 send() + stream() 获取：SDK V2 会以当前
-                // process.cwd() 派生 Claude Code 子进程，必须保证此刻 cwd 为 workDir。
-                // 锁串行化后，并发多用户的子进程不会在错误的目录派生。
-                const stream = await runWithWorkDir(workDir, async () => {
-                    await session.send(prompt);
-                    const s = session.stream();
-                    currentStream = s;
-                    activeStreams.add(s);
-                    return s;
+                const q = query({
+                    prompt,
+                    options: {
+                        cwd: workDir,
+                        model: resolvedModel,
+                        permissionMode,
+                        ...(resumeId ? { resume: resumeId } : {}),
+                        abortController,
+                        stderr: (data) => {
+                            recentStderr = appendStderrSnippet(recentStderr, data);
+                        },
+                    },
                 });
-                let accumulated = '';
-                let accumulatedThinking = '';
-                const toolStats = {};
                 try {
-                    for await (const msg of stream) {
+                    for await (const msg of q) {
                         if (abortController.signal.aborted) {
-                            log.info('Stream aborted by user');
+                            log.info('Query aborted by user');
                             break;
                         }
                         // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
                             const initMsg = msg;
-                            // 记录 session 加载的插件和技能
                             const pluginNames = initMsg.plugins?.map(p => p.name).join(', ') ?? 'none';
                             const skillCount = initMsg.skills?.length ?? 0;
                             const toolCount = initMsg.tools?.length ?? 0;
-                            log.info(`[V2] Init: plugins=[${pluginNames}], skills=${skillCount}, tools=${toolCount}`);
-                            const newSessionId = initMsg.session_id;
-                            if (newSessionId && newSessionId !== actualSessionId) {
-                                // 更新 sessionId 映射
-                                // 清理 pending 临时 ID（actualSessionId 尚未赋值时用 pendingTempId）
-                                const idToClean = actualSessionId ?? pendingTempId;
-                                const inheritedWorkDir = idToClean ? sessionWorkDirs.get(idToClean) : undefined;
-                                if (idToClean?.startsWith('pending-')) {
-                                    activeSessions.delete(idToClean);
-                                }
-                                activeSessions.set(newSessionId, session);
-                                if (inheritedWorkDir !== undefined) {
-                                    sessionWorkDirs.set(newSessionId, inheritedWorkDir);
-                                }
-                                sessionLastUsed.set(newSessionId, Date.now());
-                                if (idToClean) {
-                                    sessionLastUsed.delete(idToClean);
-                                    sessionWorkDirs.delete(idToClean);
-                                }
-                                // 更新 runningSessions：移除旧 ID，添加新 ID
-                                if (idToClean)
-                                    runningSessions.delete(idToClean);
-                                runningSessions.add(newSessionId);
-                                trackedRunningId = newSessionId;
-                                actualSessionId = newSessionId;
-                                log.info(`[V2] Got actual sessionId: ${newSessionId}`);
-                                callbacks.onSessionId?.(newSessionId);
+                            log.info(`[query] Init: plugins=[${pluginNames}], skills=${skillCount}, tools=${toolCount}`);
+                            if (initMsg.session_id) {
+                                actualSessionId = initMsg.session_id;
+                                log.info(`[query] Got sessionId: ${actualSessionId}`);
+                                callbacks.onSessionId?.(actualSessionId);
                             }
                             continue;
                         }
@@ -592,25 +315,21 @@ export class ClaudeSDKAdapter {
                         }
                         // 处理结果消息
                         if (isResult(msg)) {
-                            streamClosed = true;
                             const m = msg;
                             const success = m.subtype === 'success';
                             const errs = m.errors ?? [];
-                            log.info(`[V2] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
-                            // 检查会话错误
+                            // 更新 sessionId（如果 init 消息中没有）
+                            if (m.session_id && !actualSessionId) {
+                                actualSessionId = m.session_id;
+                                callbacks.onSessionId?.(actualSessionId);
+                            }
+                            log.info(`[query] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
                             if (!success) {
                                 runSettled = true;
                                 const noConvErr = errs.find((e) => e.includes('No conversation found') || e.includes('session not found'));
                                 if (noConvErr) {
-                                    log.warn(`Session ${actualSessionId} not found, removing from active sessions`);
-                                    if (actualSessionId) {
-                                        activeSessions.delete(actualSessionId);
-                                        sessionLastUsed.delete(actualSessionId);
-                                        try {
-                                            session.close();
-                                        }
-                                        catch { /* ignore */ }
-                                    }
+                                    log.warn(`Session ${actualSessionId} not found`);
+                                    hadSessionInvalid = true;
                                     callbacks.onSessionInvalid?.();
                                 }
                                 const errMsg = enrichClaudeErrorMessage(errs[0] || '未知错误', recentStderr);
@@ -640,7 +359,7 @@ export class ClaudeSDKAdapter {
                         }
                     }
                     // 如果流正常结束但没有收到 result 消息
-                    if (!streamClosed) {
+                    if (!runSettled) {
                         if (accumulated) {
                             log.info('Stream ended without result message, using accumulated text');
                             runSettled = true;
@@ -655,7 +374,6 @@ export class ClaudeSDKAdapter {
                             });
                         }
                         else {
-                            // 流结束但无 result 也无 accumulated：必须触发回调，否则 Promise 永远挂起
                             log.warn('Stream ended with no result and no accumulated text, calling onError to prevent stuck state');
                             runSettled = true;
                             callbacks.onError(enrichClaudeErrorMessage('AI 响应异常结束（无输出），请重试', recentStderr));
@@ -663,81 +381,41 @@ export class ClaudeSDKAdapter {
                     }
                 }
                 finally {
-                    // 从活跃列表中移除流
-                    activeStreams.delete(stream);
+                    // Query 的 cleanup 由 SDK 内部管理
                 }
             }
             catch (err) {
                 if (abortController.signal.aborted) {
-                    log.info('Session run aborted');
-                    // 清理 pending tempId（abort 可能在 init 消息之前发生）
-                    const idToClean = actualSessionId ?? pendingTempId;
-                    if (idToClean?.startsWith('pending-')) {
-                        activeSessions.delete(idToClean);
-                        log.info(`Cleaned up pending session: ${idToClean}`);
-                    }
+                    log.info('Query run aborted');
                     return;
                 }
                 runSettled = true;
                 const errorObj = err;
                 const msg = enrichClaudeErrorMessage(errorObj.message || String(err), recentStderr);
-                log.error(`Claude SDK V2 error: ${msg}`);
+                log.error(`Claude SDK error: ${msg}`);
                 if (errorObj.stack) {
                     log.error(`Error stack: ${errorObj.stack}`);
                 }
-                // 清理 pending tempId（session 在获取真实 ID 前就失败了）
-                const errIdToClean = actualSessionId ?? pendingTempId;
-                if (errIdToClean?.startsWith('pending-')) {
-                    activeSessions.delete(errIdToClean);
-                    log.warn(`Cleaned up pending session after error: ${errIdToClean}`);
-                }
-                // If error suggests a corrupted session, remove it from cache to prevent reuse
-                if (actualSessionId && isSessionCorruptionError(msg)) {
-                    const corrupted = activeSessions.get(actualSessionId);
-                    activeSessions.delete(actualSessionId);
-                    sessionLastUsed.delete(actualSessionId);
-                    if (corrupted) {
-                        try {
-                            corrupted.close();
-                        }
-                        catch { /* ignore */ }
-                    }
-                    log.warn(`Removed corrupted session ${actualSessionId} after error: ${msg}`);
+                if (isSessionCorruptionError(msg)) {
+                    log.warn(`Session corruption detected: ${msg}`);
                     callbacks.onSessionInvalid?.();
                 }
                 callbacks.onError(msg);
             }
-            finally {
-                // 无论成功、失败还是 abort，都从运行中集合移除
-                if (trackedRunningId) {
-                    runningSessions.delete(trackedRunningId);
-                }
-                // 也清理 actualSessionId（可能在 init 后更新了）
-                if (actualSessionId && actualSessionId !== trackedRunningId) {
-                    runningSessions.delete(actualSessionId);
-                }
-            }
         };
-        // 启动会话（不等待），catch 兜底防止 unhandledRejection 导致用户请求挂起
-        runSession().catch((err) => {
+        // 启动查询（不等待），catch 兜底防止 unhandledRejection
+        runQuery().catch((err) => {
             if (!runSettled) {
                 runSettled = true;
                 const msg = err instanceof Error ? err.message : String(err);
-                log.error(`Unhandled runSession error: ${msg}`);
+                log.error(`Unhandled runQuery error: ${msg}`);
                 callbacks.onError(msg);
             }
         });
         return {
             abort: () => {
-                log.info('Aborting session run');
+                log.info('Aborting query');
                 abortController.abort();
-                // 立即中断 stream，不等下一条消息
-                if (currentStream) {
-                    try {
-                        currentStream.return?.();
-                    }
-                    catch { /* ignore */ }
-                }
             },
         };
     }

package/dist/adapters/registry.js

@@ -1,5 +1,5 @@
 import { getConfiguredAiCommands } from '../config.js';
-import { ClaudeSDKAdapter, configureClaudeSdkSessionIdle } from './claude-sdk-adapter.js';
+import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
 import { OpenCodeAdapter } from './opencode-adapter.js';
@@ -12,7 +12,6 @@ export function initAdapters(config) {
     for (const aiCommand of getConfiguredAiCommands(config)) {
         if (aiCommand === 'claude') {
             log.info('Claude Agent SDK adapter enabled');
-            configureClaudeSdkSessionIdle(config.claudeSessionIdleTtlMinutes);
             adapters.set('claude', new ClaudeSDKAdapter());
             continue;
         }

package/dist/commands/handler.js

@@ -2,6 +2,7 @@ import { resolvePlatformAiCommand } from '../config.js';
 import { escapePathForMarkdown } from '../shared/utils.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { createLogger } from '../logger.js';
+import { ClaudeSDKAdapter } from '../adapters/claude-sdk-adapter.js';
 const log = createLogger('Commands');
 function formatRelativeTime(ts) {
     const sec = Math.floor((Date.now() - ts) / 1000);
@@ -20,10 +21,9 @@ function formatRelativeTime(ts) {
         return `${day}天前`;
     return new Date(ts).toLocaleDateString('zh-CN');
 }
-function truncatePreview(msg, maxLen = 30) {
-    if (!msg)
-        return '新会话';
-    const firstLine = msg.split('\n')[0].trim();
+function truncateSummary(session, maxLen = 30) {
+    const text = session.customTitle || session.summary || session.firstPrompt || '新会话';
+    const firstLine = text.split('\n')[0].trim();
     return firstLine.length > maxLen ? firstLine.slice(0, maxLen) + '...' : firstLine;
 }
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -116,45 +116,36 @@ export class CommandHandler {
         return true;
     }
     async handleSessions(chatId, userId, _platform) {
-        const history = this.deps.sessionManager.listConvHistory(userId);
-        const active = this.deps.sessionManager.getActiveConvInfo(userId);
-        if (history.length === 0 && !active) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        if (sessions.length === 0) {
             await this.replySender().sendTextReply(chatId, '📋 暂无会话记录。');
             return true;
         }
         const lines = ['📋 会话列表:', ''];
-        history.forEach((entry, i) => {
-            const preview = truncatePreview(entry.firstMessage);
-            const time = entry.createdAt ? ` · ${formatRelativeTime(entry.createdAt)}` : '';
-            lines.push(`${i + 1}. ${preview} · ${entry.totalTurns}轮${time}`);
+        sessions.forEach((session, i) => {
+            const preview = truncateSummary(session);
+            const time = session.lastModified ? ` · ${formatRelativeTime(session.lastModified)}` : '';
+            lines.push(`${i + 1}. ${preview}${time}`);
         });
-        if (active) {
-            const num = history.length + 1;
-            const preview = truncatePreview(active.firstMessage);
-            lines.push(`▸ ${num}. ${preview} · ${active.totalTurns}轮（当前）`);
-        }
         lines.push('', '使用 /resume <序号> 恢复，或 /resume 恢复最近一条');
         await this.replySender().sendTextReply(chatId, lines.join('\n'));
         return true;
     }
     async handleResume(chatId, userId, arg, _platform) {
-        const history = this.deps.sessionManager.listConvHistory(userId);
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
         // /resume (no arg) — resume the most recent session
         if (!arg) {
-            if (history.length === 0) {
+            if (sessions.length === 0) {
                 await this.replySender().sendTextReply(chatId, '没有可恢复的历史会话。');
                 return true;
             }
-            const entry = history[history.length - 1];
+            const session = sessions[0];
             this.deps.requestQueue.cancelUser(userId);
-            const ok = this.deps.sessionManager.resumeConv(userId, entry.convId);
-            if (ok) {
-                const preview = truncatePreview(entry.firstMessage);
-                await this.replySender().sendTextReply(chatId, `✅ 已恢复最近会话: ${preview}（${entry.totalTurns}轮）\n继续发消息即可。`);
-            }
-            else {
-                await this.replySender().sendTextReply(chatId, '❌ 恢复会话失败，请重试。');
-            }
+            this.deps.sessionManager.setActiveSessionId(userId, session.sessionId);
+            const preview = truncateSummary(session);
+            await this.replySender().sendTextReply(chatId, `✅ 已恢复最近会话: ${preview}\n继续发消息即可。`);
             return true;
         }
         const index = parseInt(arg, 10);
@@ -162,20 +153,15 @@ export class CommandHandler {
             await this.replySender().sendTextReply(chatId, '用法: /resume [序号]\n\n不带序号则恢复最近一条会话。');
             return true;
         }
-        if (index > history.length) {
-            await this.replySender().sendTextReply(chatId, `序号 ${index} 无效，共 ${history.length} 个历史会话。`);
+        if (index > sessions.length) {
+            await this.replySender().sendTextReply(chatId, `序号 ${index} 无效，共 ${sessions.length} 个历史会话。`);
             return true;
         }
-        const entry = history[index - 1];
+        const session = sessions[index - 1];
         this.deps.requestQueue.cancelUser(userId);
-        const ok = this.deps.sessionManager.resumeConv(userId, entry.convId);
-        if (ok) {
-            const preview = truncatePreview(entry.firstMessage);
-            await this.replySender().sendTextReply(chatId, `✅ 已恢复会话: ${preview}（${entry.totalTurns}轮）\n继续发消息即可。`);
-        }
-        else {
-            await this.replySender().sendTextReply(chatId, '❌ 恢复会话失败，请重试。');
-        }
+        this.deps.sessionManager.setActiveSessionId(userId, session.sessionId);
+        const preview = truncateSummary(session);
+        await this.replySender().sendTextReply(chatId, `✅ 已恢复会话: ${preview}\n继续发消息即可。`);
         return true;
     }
     async handleNew(chatId, userId) {
@@ -224,10 +210,7 @@ export class CommandHandler {
         try {
             this.deps.requestQueue.cancelUser(userId);
             const result = await this.deps.sessionManager.setWorkDir(userId, dir);
-            const msg = result.resumed
-                ? `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n🔄 已恢复该目录的最近会话，继续之前的上下文。`
-                : `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n🆕 该目录暂无历史会话，已创建全新上下文。`;
-            await this.replySender().sendTextReply(chatId, msg);
+            await this.replySender().sendTextReply(chatId, `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n下一条消息将自动查找该目录的最近会话。`);
         }
         catch (err) {
             await this.replySender().sendTextReply(chatId, err instanceof Error ? err.message : String(err));

package/dist/session/session-manager.d.ts

@@ -1,11 +1,4 @@
 type ToolId = 'claude' | 'codex' | 'codebuddy' | 'opencode';
-interface ConvHistoryEntry {
-    convId: string;
-    totalTurns: number;
-    createdAt: number;
-    workDir?: string;
-    firstMessage?: string;
-}
 export declare function resolveWorkDirInput(baseDir: string, targetDir: string): string;
 export declare class SessionManager {
     private sessions;
@@ -31,18 +24,14 @@ export declare class SessionManager {
         resumed: boolean;
     }>;
     newSession(userId: string): boolean;
+    /**
+     * Set the active session to a specific SDK session (used by /resume).
+     * Bridges the SDK sessionId to our internal activeConvId tracking.
+     */
+    setActiveSessionId(userId: string, sessionId: string): void;
     clearActiveToolSession(userId: string, toolId: ToolId): boolean;
-    listConvHistory(userId: string): ConvHistoryEntry[];
-    getActiveConvInfo(userId: string): {
-        convId: string;
-        totalTurns: number;
-        firstMessage?: string;
-    } | undefined;
-    resumeConv(userId: string, convId: string): boolean;
     addTurns(userId: string, turns: number): number;
     addTurnsForThread(userId: string, threadId: string, turns: number): number;
-    /** Save the first message preview for the current conversation (only on first turn). */
-    setConvPreview(userId: string, preview: string): void;
     getModel(userId: string, threadId?: string): string | undefined;
     setModel(userId: string, model: string | undefined, threadId?: string): void;
     private resolveAndValidate;

package/dist/session/session-manager.js

@@ -107,54 +107,16 @@ export class SessionManager {
         const currentDir = this.getWorkDir(userId);
         const realPath = await this.resolveAndValidate(currentDir, workDir);
         const s = this.sessions.get(userId);
-        let oldConvId;
-        let resumed = false;
         if (s) {
             // Same directory — no-op
             if (realPath === currentDir) {
                 return { path: realPath, resumed: false };
             }
-            oldConvId = s.activeConvId;
             this.persistActiveConvSessions(userId, s);
-            // Archive current conversation with its workDir
-            if (oldConvId) {
-                if (!s.convHistory)
-                    s.convHistory = [];
-                s.convHistory.push({
-                    convId: oldConvId,
-                    totalTurns: s.totalTurns ?? 0,
-                    createdAt: Date.now(),
-                    workDir: currentDir,
-                    firstMessage: s.firstMessage,
-                });
-                if (s.convHistory.length > 10)
-                    s.convHistory = s.convHistory.slice(-10);
-            }
-            // Look for a previous conversation in the target directory
-            if (!s.convHistory)
-                s.convHistory = [];
-            const matchIdx = s.convHistory.findIndex((e) => e.workDir === realPath);
-            if (matchIdx !== -1) {
-                const [entry] = s.convHistory.splice(matchIdx, 1);
-                s.activeConvId = entry.convId;
-                s.totalTurns = entry.totalTurns;
-                s.sessionIds = {};
-                for (const toolId of ['claude', 'codex', 'codebuddy', 'opencode']) {
-                    const sessionId = this.convSessionMap.get(this.getConvSessionKey(userId, entry.convId, toolId));
-                    if (sessionId) {
-                        if (!s.sessionIds)
-                            s.sessionIds = {};
-                        s.sessionIds[toolId] = sessionId;
-                    }
-                }
-                resumed = true;
-                log.info(`Resumed session for user ${userId}: convId=${entry.convId}, workDir=${realPath}, turns=${entry.totalTurns}`);
-            }
-            else {
-                s.sessionIds = {};
-                s.activeConvId = randomBytes(4).toString('hex');
-                s.firstMessage = undefined;
-            }
+            // Clear active session IDs; SDK adapter will auto-resume latest CLI session for new dir
+            s.sessionIds = {};
+            s.activeConvId = randomBytes(4).toString('hex');
+            s.totalTurns = 0;
             s.workDir = realPath;
         }
         else {
@@ -164,8 +126,8 @@ export class SessionManager {
             });
         }
         this.flushSync();
-        log.info(`WorkDir changed for user ${userId}: ${realPath}, oldConvId=${oldConvId}, resumed=${resumed}`);
-        return { path: realPath, resumed };
+        log.info(`WorkDir changed for user ${userId}: ${realPath}`);
+        return { path: realPath, resumed: false };
     }
     newSession(userId) {
         const s = this.sessions.get(userId);
@@ -173,31 +135,34 @@ export class SessionManager {
             const oldSessionIds = { ...(s.sessionIds ?? {}) };
             const oldConvId = s.activeConvId;
             this.persistActiveConvSessions(userId, s);
-            // Archive old conversation to history (keep convSessionMap entries for resume)
-            if (oldConvId) {
-                if (!s.convHistory)
-                    s.convHistory = [];
-                s.convHistory.push({
-                    convId: oldConvId,
-                    totalTurns: s.totalTurns ?? 0,
-                    createdAt: Date.now(),
-                    workDir: s.workDir,
-                    firstMessage: s.firstMessage,
-                });
-                // Keep last 10 entries
-                if (s.convHistory.length > 10)
-                    s.convHistory = s.convHistory.slice(-10);
-            }
             s.sessionIds = {};
             s.activeConvId = randomBytes(4).toString('hex');
             s.totalTurns = 0;
-            s.firstMessage = undefined;
             this.flushSync();
             log.info(`New session for user ${userId}: oldConvId=${oldConvId}, oldSessionIds=${JSON.stringify(oldSessionIds)}, newConvId=${s.activeConvId}, sessionIds={}`);
             return true;
         }
         return false;
     }
+    /**
+     * Set the active session to a specific SDK session (used by /resume).
+     * Bridges the SDK sessionId to our internal activeConvId tracking.
+     */
+    setActiveSessionId(userId, sessionId) {
+        let s = this.sessions.get(userId);
+        if (!s) {
+            s = { workDir: this.defaultWorkDir };
+            this.sessions.set(userId, s);
+        }
+        this.persistActiveConvSessions(userId, s);
+        s.activeConvId = randomBytes(4).toString('hex');
+        s.totalTurns = 0;
+        if (!s.sessionIds)
+            s.sessionIds = {};
+        s.sessionIds.claude = sessionId;
+        this.flushSync();
+        log.info(`Set active session for user ${userId}: sessionId=${sessionId}, convId=${s.activeConvId}`);
+    }
     clearActiveToolSession(userId, toolId) {
         const s = this.sessions.get(userId);
         if (!s)
@@ -212,59 +177,6 @@ export class SessionManager {
         log.info(`Cleared active ${toolId} session for user ${userId}, convId=${activeConvId ?? 'none'}`);
         return hadSession;
     }
-    listConvHistory(userId) {
-        const s = this.sessions.get(userId);
-        if (!s)
-            return [];
-        return s.convHistory ?? [];
-    }
-    getActiveConvInfo(userId) {
-        const s = this.sessions.get(userId);
-        if (!s?.activeConvId)
-            return undefined;
-        return { convId: s.activeConvId, totalTurns: s.totalTurns ?? 0, firstMessage: s.firstMessage };
-    }
-    resumeConv(userId, convId) {
-        const s = this.sessions.get(userId);
-        if (!s)
-            return false;
-        // Find target in history
-        const idx = s.convHistory?.findIndex((e) => e.convId === convId) ?? -1;
-        if (idx === -1)
-            return false;
-        // Archive current active session
-        this.persistActiveConvSessions(userId, s);
-        if (s.activeConvId) {
-            if (!s.convHistory)
-                s.convHistory = [];
-            s.convHistory.push({
-                convId: s.activeConvId,
-                totalTurns: s.totalTurns ?? 0,
-                createdAt: Date.now(),
-                workDir: s.workDir,
-                firstMessage: s.firstMessage,
-            });
-        }
-        // Remove target from history
-        const [entry] = s.convHistory.splice(idx, 1);
-        // Restore target as active
-        s.activeConvId = entry.convId;
-        s.totalTurns = entry.totalTurns;
-        s.firstMessage = entry.firstMessage;
-        s.sessionIds = {};
-        // Restore sessionIds from convSessionMap
-        for (const toolId of ['claude', 'codex', 'codebuddy']) {
-            const sessionId = this.convSessionMap.get(this.getConvSessionKey(userId, entry.convId, toolId));
-            if (sessionId) {
-                if (!s.sessionIds)
-                    s.sessionIds = {};
-                s.sessionIds[toolId] = sessionId;
-            }
-        }
-        this.flushSync();
-        log.info(`Resumed session for user ${userId}: convId=${entry.convId}, turns=${entry.totalTurns}`);
-        return true;
-    }
     addTurns(userId, turns) {
         const s = this.sessions.get(userId);
         if (!s)
@@ -286,14 +198,6 @@ export class SessionManager {
         this.save();
         return t.totalTurns;
     }
-    /** Save the first message preview for the current conversation (only on first turn). */
-    setConvPreview(userId, preview) {
-        const s = this.sessions.get(userId);
-        if (!s || (s.totalTurns ?? 0) > 0)
-            return;
-        s.firstMessage = preview;
-        this.save();
-    }
     getModel(userId, threadId) {
         const s = this.sessions.get(userId);
         if (threadId) {
@@ -359,6 +263,9 @@ export class SessionManager {
                         log.warn(`Legacy shared sessionId found for user ${k}; clearing it to avoid cross-tool resume conflicts`);
                     }
                     delete v.sessionId;
+                    // Clean up legacy fields
+                    delete v.firstMessage;
+                    delete v.convHistory;
                     if (v.threads) {
                         for (const thread of Object.values(v.threads)) {
                             if (!thread.sessionIds)

package/dist/shared/ai-task.js

@@ -153,7 +153,6 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
         const aiCommand = resolvePlatformAiCommand(config, ctx.platform);
         const startRun = () => {
             log.info(`[AITask] Starting: userId=${ctx.userId}, initialSessionId=${currentSessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
-            sessionManager.setConvPreview(ctx.userId, prompt.slice(0, 80));
             emitStructuredEvent('AITask', 'ai.task.start', {
                 platform: ctx.platform,
                 taskKey: hashUserId(ctx.taskKey),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.1-beta.6",
+  "version": "1.11.1-beta.8",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",
@@ -51,7 +51,8 @@
     "url": "https://github.com/wu529778790/open-im/issues"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.179",
+    "@anthropic-ai/sdk": "^0.104.2",
     "@aws-sdk/client-s3": "^3.1035.0",
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "centrifuge": "^5.5.3",