@wu529778790/open-im 1.11.1-beta.2 → 1.11.1-beta.21

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, getSessionMessages, deleteSession, renameSession, forkSession } 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';
@@ -17,6 +15,17 @@ import { createLogger } from '../logger.js';
 import { refreshClaudeEnvToProcess } from '../config/file-io.js';
 import { toReplyPlainText } from '../shared/utils.js';
 const log = createLogger('ClaudeSDK');
+/**
+ * 注入交互式上下文指令，让 Claude 认为这是交互式终端会话。
+ * 解决 query() 非交互环境下 Claude 跳过用户选择、直接自主决策的问题。
+ */
+const INTERACTIVE_CONTEXT = `[SYSTEM: You are in an interactive chat session via instant messenger. The user CAN and WILL respond to your messages — treat this like an interactive terminal session. Rules:
+1. When you need to make a decision involving user preference (choosing an approach, selecting between options, deciding what to do next), ALWAYS present clearly numbered options and WAIT for the user's response.
+2. Do NOT proceed autonomously when user input would be valuable.
+3. Only proceed autonomously for obvious single-path tasks (e.g. reading a file, running a simple command).
+4. When presenting options, format them as a numbered list and end with a question.
+]
+`;
 function loadUserPluginSettings() {
     try {
         const settingsPath = join(homedir(), '.claude', 'settings.json');
@@ -53,8 +62,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 +78,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 +101,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 +156,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 +172,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 +203,163 @@ 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.`);
+export class ClaudeSDKAdapter {
+    toolId = 'claude-sdk';
+    /**
+     * 清理所有活跃的查询
+     */
+    static destroy() {
+        // query() API 的 Query 对象通过 abortController.abort() 清理
     }
-    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();
+    /**
+     * List sessions for a directory using the SDK's listSessions API.
+     */
+    static async listSessionsForDir(workDir, limit = 20) {
         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 };
+            return await listSessions({ dir: workDir, limit });
         }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
+        catch (err) {
+            log.warn(`Failed to list sessions for ${workDir}: ${err}`);
+            return [];
         }
-    });
-}
-export class ClaudeSDKAdapter {
-    toolId = 'claude-sdk';
+    }
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * Get session messages for a given session ID.
      */
-    static destroy() {
-        clearInterval(cleanupInterval);
-        for (const stream of activeStreams) {
-            try {
-                if (stream && typeof stream.return === 'function') {
-                    stream.return();
+    static async getSessionMessagesForId(sessionId, workDir, limit = 50) {
+        try {
+            return await getSessionMessages(sessionId, { dir: workDir, limit });
+        }
+        catch (err) {
+            log.warn(`Failed to get session messages for ${sessionId}: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Delete a session by ID.
+     */
+    static async deleteSessionById(sessionId, workDir) {
+        try {
+            await deleteSession(sessionId, { dir: workDir });
+            return true;
+        }
+        catch (err) {
+            log.warn(`Failed to delete session ${sessionId}: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Rename a session.
+     */
+    static async renameSessionById(sessionId, title, workDir) {
+        try {
+            await renameSession(sessionId, title, { dir: workDir });
+            return true;
+        }
+        catch (err) {
+            log.warn(`Failed to rename session ${sessionId}: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Fork a session.
+     */
+    static async forkSessionById(sessionId, workDir) {
+        try {
+            const result = await forkSession(sessionId, { dir: workDir });
+            return result.sessionId;
+        }
+        catch (err) {
+            log.warn(`Failed to fork session ${sessionId}: ${err}`);
+            return undefined;
+        }
+    }
+    /**
+     * Create a short-lived query for fetching session info (models, context, etc).
+     * The caller must close the returned query when done.
+     */
+    static async createInfoQuery(workDir, model) {
+        const resolvedModel = model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
+        return query({
+            prompt: '',
+            options: {
+                cwd: workDir,
+                model: resolvedModel,
+                permissionMode: 'default',
+            },
+        });
+    }
+    /**
+     * Get available models for a work directory.
+     */
+    static async getSupportedModels(workDir, model) {
+        let q;
+        try {
+            q = await this.createInfoQuery(workDir, model);
+            return await q.supportedModels();
+        }
+        catch (err) {
+            log.warn(`Failed to get supported models: ${err}`);
+            return [];
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
                 }
-            }
-            catch {
-                /* ignore */
+                catch { /* ignore */ }
             }
         }
-        activeStreams.clear();
-        for (const session of activeSessions.values()) {
-            try {
-                session.close();
-            }
-            catch {
-                /* ignore */
+    }
+    /**
+     * Get context usage for a work directory.
+     */
+    static async getContextUsage(workDir, model) {
+        let q;
+        try {
+            q = await this.createInfoQuery(workDir, model);
+            return await q.getContextUsage();
+        }
+        catch (err) {
+            log.warn(`Failed to get context usage: ${err}`);
+            return undefined;
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
+                }
+                catch { /* ignore */ }
             }
         }
-        activeSessions.clear();
-        sessionLastUsed.clear();
-        sessionWorkDirs.clear();
     }
     /**
-     * Remove a specific session from the in-memory cache and close it.
-     * Useful when the caller knows a session is corrupted.
+     * Get account info for a work directory.
      */
-    static removeSession(sessionId) {
-        const session = activeSessions.get(sessionId);
-        if (session) {
-            try {
-                session.close();
+    static async getAccountInfo(workDir, model) {
+        let q;
+        try {
+            q = await this.createInfoQuery(workDir, model);
+            return await q.accountInfo();
+        }
+        catch (err) {
+            log.warn(`Failed to get account info: ${err}`);
+            return undefined;
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
+                }
+                catch { /* ignore */ }
             }
-            catch { /* ignore */ }
-            activeSessions.delete(sessionId);
-            sessionLastUsed.delete(sessionId);
-            sessionWorkDirs.delete(sessionId);
-            log.info(`Explicitly removed session: ${sessionId}`);
         }
     }
     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 +368,70 @@ 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: INTERACTIVE_CONTEXT + prompt,
+                    options: {
+                        cwd: workDir,
+                        model: resolvedModel,
+                        permissionMode,
+                        // 启用完整工具集，与 cc 终端一致
+                        tools: { type: 'preset', preset: 'claude_code' },
+                        // 启用所有技能（superpowers, playwright 等），与 cc 终端一致
+                        skills: 'all',
+                        ...(resumeId ? { resume: resumeId } : {}),
+                        ...(options?.fallbackModel ? { fallbackModel: options.fallbackModel } : {}),
+                        ...(options?.disallowedTools?.length ? { disallowedTools: options.disallowedTools } : {}),
+                        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 +463,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 +507,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 +522,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 +529,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 */ }
-                }
             },
         };
     }