@winmatrix/agent-sdk 1.0.3 → 1.0.5

package/dist/adapters/claude/ClaudeAdapter.js

@@ -7,11 +7,16 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFile
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
 import { parseSkillMd } from '../../utils/parseSkillMd.js';
 import { waitForExit, killProcess } from '../../utils/processUtils.js';
+import { sanitizeTaskEnv } from '../../utils/envSanitizer.js';
+import { executeWithResumeFallback } from '../../utils/resumeFallback.js';
+import { classifyAdapterError } from '../../utils/errorClassification.js';
 export { parseSkillMd };
 import { isLocalTool } from '../../core/AgentAdapter.js';
-import { parseClaudeLine, splitLines, } from './ClaudeStreamParser.js';
+import { parseClaudeLine, parseClaudeInvocationUsageFrame, splitLines, } from './ClaudeStreamParser.js';
+import { ClaudeInvocationUsageTracker } from './ClaudeInvocationUsageTracker.js';
 import { resolveClaudeCommand } from './claudeCommand.js';
 const CLAUDE_BASE_ARGS = [
     '--print',
@@ -20,6 +25,20 @@ const CLAUDE_BASE_ARGS = [
     '--output-format', 'stream-json',
     '--include-partial-messages',
 ];
+/**
+ * 权限默认档（harden-external-computer-daemon P1/D4）。
+ *
+ * 优先级：task 显式声明 > daemon 环境变量 > 'acceptEdits'（安全默认）。
+ * 交互确认通道（TASK_INTERACTION_RESPOND）当前未接通，print 模式下权限
+ * 提示会被自动拒绝——acceptEdits 下 Bash 等未预批工具将被拒；需要旧行为
+ * 的部署显式设 WINMATRIX_DAEMON_CLAUDE_PERMISSION_MODE=bypassPermissions，
+ * 或在任务配置里声明 permissionMode/allowedTools。
+ */
+function resolvePermissionMode(task) {
+    return task.claude?.permissionMode
+        ?? process.env.WINMATRIX_DAEMON_CLAUDE_PERMISSION_MODE
+        ?? 'acceptEdits';
+}
 export class ClaudeAdapter {
     meta = {
         agentType: 'claude-code',
@@ -28,7 +47,9 @@ export class ClaudeAdapter {
             streaming: true,
             toolCall: true,
             session: true,
-            cancellation: false,
+            cancellation: true,
+            supportsCancel: true,
+            supportsResume: true,
         },
         tools: ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task', 'Agent', 'NotebookEdit', 'EnterPlanMode'],
         skills: [],
@@ -42,22 +63,48 @@ export class ClaudeAdapter {
     claudePath;
     mcpBridgeUrl;
     mcpApiKey;
+    /** steer 递话队列与当前 run 的 stdin 句柄（P2.1/D5） */
+    steerQueue = [];
+    activeStdin = null;
+    workstationId;
+    tokenUsageRecorder;
     mcpConfigWritten = new Map();
     constructor(config) {
-        this.claudePath = config?.claudePath ?? 'claude';
-        this.mcpBridgeUrl = config?.mcpBridgeUrl;
-        this.mcpApiKey = config?.mcpApiKey;
+        const options = config;
+        this.claudePath = options?.claudePath ?? 'claude';
+        this.mcpBridgeUrl = options?.mcpBridgeUrl;
+        this.mcpApiKey = options?.mcpApiKey;
+        this.workstationId = options?.workstationId;
+        this.tokenUsageRecorder = options?.tokenUsageRecorder;
     }
     // ── execute ──
     async *execute(task, signal) {
+        yield* executeWithResumeFallback(task, signal, (nextTask, nextSignal) => this.executeOnce(nextTask, nextSignal));
+    }
+    async *executeOnce(task, signal) {
+        // Pod 场景：通过 @anthropic-ai/claude-agent-sdk.query() 调 claude
+        if (task.claude?.useAgentSdk) {
+            yield* this.executeViaAgentSdk(task, signal);
+            return;
+        }
         const workDir = task.workDir;
         if (workDir && !existsSync(workDir)) {
-            yield { type: 'error', message: `Work directory does not exist: ${workDir}` };
+            yield {
+                type: 'error',
+                message: `Work directory does not exist: ${workDir}`,
+                code: 'cli_crash',
+                retryable: false,
+            };
             return;
         }
         const args = [...CLAUDE_BASE_ARGS];
-        // Permission mode
-        args.push('--permission-mode', task.claude?.permissionMode ?? 'bypassPermissions');
+        // Permission mode（harden-external-computer-daemon P1/D4：默认档降为 acceptEdits）
+        const permissionMode = resolvePermissionMode(task);
+        if (permissionMode === 'bypassPermissions') {
+            console.warn('[ClaudeAdapter] 本次任务以 bypassPermissions 运行（显式声明）。' +
+                '外部 CLI 将不做任何权限确认，请确认任务来源可信。');
+        }
+        args.push('--permission-mode', permissionMode);
         // workDir
         if (workDir) {
             args.push('--add-dir', workDir);
@@ -84,7 +131,9 @@ export class ClaudeAdapter {
             }
         }
         // Local tools (whitelist)
-        const tools = task.claude?.tools ?? ['Bash', 'Read', 'Write', 'Edit'];
+        const tools = task.claude?.tools?.length
+            ? task.claude.tools
+            : ['Bash', 'Read', 'Write', 'Edit'];
         args.push('--allowedTools', tools.join(','));
         // Disallowed tools
         if (task.claude?.disallowedTools?.length) {
@@ -115,8 +164,11 @@ export class ClaudeAdapter {
         else if (this.mcpBridgeUrl) {
             console.warn(`[ClaudeAdapter] Skipping MCP config: URL likely unreachable: ${this.mcpBridgeUrl}`);
         }
-        // Build env
-        const env = { ...process.env, ...(task.env ?? {}) };
+        // Build env（先剥凭据后显式加，harden-external-computer-daemon P1/D3）
+        const { env, strippedKeys } = sanitizeTaskEnv(task.env);
+        if (strippedKeys.length > 0) {
+            console.warn(`[ClaudeAdapter] 已剥离 ${strippedKeys.length} 个凭据形态环境变量（仅列 key 名）: ${strippedKeys.join(', ')}`);
+        }
         // Spawn
         let proc;
         try {
@@ -126,10 +178,17 @@ export class ClaudeAdapter {
                 env,
                 cwd: workDir ?? process.cwd(),
                 shell: spawnSpec.shell,
+                // POSIX 下独立进程组，killProcess 才能 kill(-pid) 杀整棵树
+                detached: process.platform !== 'win32',
             });
         }
         catch (err) {
-            yield { type: 'error', message: `Failed to spawn claude: ${err instanceof Error ? err.message : String(err)}` };
+            yield {
+                type: 'error',
+                message: `Failed to spawn claude: ${err instanceof Error ? err.message : String(err)}`,
+                code: 'cli_crash',
+                retryable: false,
+            };
             return;
         }
         // Send user message via stdin (stream-json protocol)
@@ -142,15 +201,23 @@ export class ClaudeAdapter {
             message: { role: 'user', content: task.input },
         }) + '\n';
         proc.stdin?.write(userMessage);
-        proc.stdin?.end();
-        // Drain stderr to prevent backpressure stall (--verbose produces lots of stderr)
-        proc.stderr?.on('data', () => { });
+        // steer（P2.1/D5）：stdin 保持打开，turn 结束（result 帧）时若有排队递话
+        // 则注入下一 turn；无排队才关闭 stdin 让 CLI 退出
+        this.activeStdin = proc.stdin ?? null;
+        // Drain stderr to prevent backpressure stall, while keeping a bounded error summary.
+        let stderrText = '';
+        proc.stderr?.on('data', (chunk) => {
+            if (stderrText.length < 4096) {
+                stderrText += chunk.toString('utf-8');
+            }
+        });
         proc.stderr?.on('error', () => { });
         // Track result fields
         let extractedSessionId;
         let extractedResultText;
         let extractedUsage;
         let completed = false;
+        const invocationUsageTracker = new ClaudeInvocationUsageTracker();
         // Delta text accumulator: fallback for empty/missing result frame
         let accumulatedDeltaText = '';
         // Abort handler
@@ -169,18 +236,56 @@ export class ClaudeAdapter {
                 const { lines, remainder } = splitLines(stdoutBuffer, text);
                 stdoutBuffer = remainder;
                 for (const line of lines) {
+                    const observedAt = new Date().toISOString();
+                    const usageFrame = parseClaudeInvocationUsageFrame(line);
+                    if (usageFrame && this.tokenUsageRecorder) {
+                        const completedUsage = invocationUsageTracker.accept(usageFrame, observedAt);
+                        if (completedUsage) {
+                            const workstationId = this.workstationId ?? task.env?.WINMATRIX_WORKSTATION_ID ?? process.env.WINMATRIX_WORKSTATION_ID;
+                            if (!workstationId?.trim()) {
+                                throw new Error('WORKSTATION_TOKEN_USAGE_WORKSTATION_ID_MISSING');
+                            }
+                            await this.tokenUsageRecorder.recordCompletedInvocation({
+                                workstationId,
+                                runtime: 'claude-code',
+                                sourceInvocationId: completedUsage.sourceInvocationId,
+                                provider: 'claude',
+                                startedAt: completedUsage.startedAt,
+                                occurredAt: completedUsage.occurredAt,
+                                timeSource: completedUsage.timeSource,
+                                sessionId: completedUsage.sessionId ?? extractedSessionId ?? sessionId,
+                                taskId: task.taskId,
+                                modelUsages: [{
+                                        sourceModelUsageId: `${completedUsage.sourceInvocationId}:model:0`,
+                                        model: completedUsage.model,
+                                        inputTokens: completedUsage.usage.inputTokens,
+                                        outputTokens: completedUsage.usage.outputTokens,
+                                        cacheReadTokens: completedUsage.usage.cacheReadTokens,
+                                        cacheCreationTokens: completedUsage.usage.cacheCreationTokens,
+                                    }],
+                            });
+                        }
+                    }
                     const action = parseClaudeLine(line);
                     if (action.type === 'tool_use' && isLocalTool(action.toolName)) {
-                        yield { type: 'thinking', content: `璋冪敤鏈湴宸ュ叿: ${action.toolName}` };
+                        yield { type: 'thinking', content: `调用本地工具: ${action.toolName}` };
                         continue;
                     }
                     switch (action.type) {
                         case 'delta':
                             accumulatedDeltaText += action.text;
-                            yield { type: 'delta', content: action.text };
+                            yield {
+                                type: 'delta',
+                                content: action.text,
+                                engineEvent: { type: 'content_delta', text: action.text },
+                            };
                             break;
                         case 'thinking':
-                            yield { type: 'thinking', content: action.text };
+                            yield {
+                                type: 'thinking',
+                                content: action.text,
+                                engineEvent: { type: 'thinking_delta', text: action.text },
+                            };
                             break;
                         case 'tool_use':
                             if (isLocalTool(action.toolName)) {
@@ -192,10 +297,15 @@ export class ClaudeAdapter {
                                     callId: randomUUID(),
                                     name: action.toolName,
                                     args: action.toolInput ?? {},
+                                    engineEvent: {
+                                        type: 'tool_call',
+                                        name: action.toolName,
+                                        input: action.toolInput,
+                                    },
                                 };
                             }
                             break;
-                        case 'result':
+                        case 'result': {
                             if (action.sessionId)
                                 extractedSessionId = action.sessionId;
                             if (action.result)
@@ -206,11 +316,35 @@ export class ClaudeAdapter {
                                     output_tokens: action.usage.output_tokens,
                                 };
                             }
+                            // steer：本 turn 结束。有排队递话则注入下一 turn 继续；
+                            // 否则关闭 stdin，CLI 处理完退出
+                            const nextSteer = this.steerQueue.shift();
+                            if (nextSteer && proc.stdin && !proc.stdin.destroyed && proc.stdin.writable) {
+                                accumulatedDeltaText = '';
+                                proc.stdin.write(JSON.stringify({
+                                    type: 'user',
+                                    message: { role: 'user', content: nextSteer },
+                                }) + '\n');
+                                yield {
+                                    type: 'thinking',
+                                    content: `[steer] 已注入纠偏消息（队列剩余 ${this.steerQueue.length} 条），继续执行`,
+                                    engineEvent: { type: 'status', text: 'steer_applied' },
+                                };
+                            }
+                            else {
+                                try {
+                                    proc.stdin?.end();
+                                }
+                                catch { /* already closed */ }
+                            }
                             break;
-                        case 'error':
+                        }
+                        case 'error': {
                             completed = true;
-                            yield { type: 'error', message: action.message };
+                            const classified = classifyAdapterError({ message: action.message, aborted: signal?.aborted });
+                            yield { type: 'error', message: action.message, code: classified.code, retryable: classified.retryable };
                             return;
+                        }
                         case 'skip':
                             break;
                     }
@@ -221,7 +355,8 @@ export class ClaudeAdapter {
             if (!completed) {
                 completed = true;
                 if (startupError) {
-                    yield { type: 'error', message: startupError };
+                    const classified = classifyAdapterError({ message: startupError, aborted: signal?.aborted });
+                    yield { type: 'error', message: startupError, code: classified.code, retryable: classified.retryable };
                     return;
                 }
                 if (extractedSessionId || exitResult.code === 0) {
@@ -237,10 +372,13 @@ export class ClaudeAdapter {
                     };
                 }
                 else {
-                    yield {
-                        type: 'error',
-                        message: exitResult.error ?? `Claude Code exited with code ${exitResult.code}`,
-                    };
+                    const message = stderrText.trim() || exitResult.error || `Claude Code exited with code ${exitResult.code}`;
+                    const classified = classifyAdapterError({
+                        message,
+                        exitCode: exitResult.code,
+                        aborted: signal?.aborted,
+                    });
+                    yield { type: 'error', message, code: classified.code, retryable: classified.retryable };
                 }
             }
         }
@@ -253,8 +391,26 @@ export class ClaudeAdapter {
                 }
                 catch { /* best-effort */ }
             }
+            this.activeStdin = null;
+            this.steerQueue = [];
         }
     }
+    /**
+     * 中途递话（P2.1/D5）：将纠偏消息排队，当前 turn 结束（result 帧）时注入
+     * stdin 开启下一 turn（dsh steer 语义的 stream-json 落地——stream-json 协议
+     * 在 turn 边界处理排队的 user 消息）。
+     */
+    steer(text) {
+        const stdin = this.activeStdin;
+        if (!stdin || stdin.destroyed || !stdin.writable) {
+            return { accepted: false, reason: 'no_active_run' };
+        }
+        const trimmed = text.trim();
+        if (!trimmed)
+            return { accepted: false, reason: 'empty_text' };
+        this.steerQueue.push(trimmed);
+        return { accepted: true };
+    }
     // ── healthCheck ──
     async healthCheck() {
         return new Promise((resolve) => {
@@ -283,71 +439,81 @@ export class ClaudeAdapter {
     async listSessions(options) {
         try {
             const dir = options.dir?.trim();
-            const projectDirs = this.resolveProjectDirs(dir);
-            if (projectDirs.length === 0) {
-                return { sessions: [] };
-            }
-            // load session index from ~/.claude/sessions/
-            const sessionsIndex = this.loadSessionsIndex();
-            const entries = [];
-            const seen = new Set();
-            for (const projectDir of projectDirs) {
-                const files = readdirSync(projectDir.path, { withFileTypes: true })
-                    .filter((d) => d.isFile() && d.name.endsWith('.jsonl'));
-                for (const file of files) {
-                    const sessionId = file.name.replace(/\.jsonl$/, '');
-                    if (seen.has(sessionId))
-                        continue;
-                    seen.add(sessionId);
-                    const indexPath = join(projectDir.path, file.name);
-                    const idxMeta = sessionsIndex.get(sessionId);
-                    if (idxMeta) {
-                        entries.push({
-                            id: sessionId,
-                            cwd: idxMeta.cwd,
-                            projectPath: idxMeta.cwd ?? projectDir.projectPath,
-                            summary: idxMeta.summary,
-                            createdAt: idxMeta.createdAt,
-                            lastActivityAt: idxMeta.lastActivityAt,
-                            messageCount: idxMeta.messageCount,
-                            status: idxMeta.status,
-                        });
-                        continue;
-                    }
-                    try {
-                        const stat = readFileSync(indexPath, 'utf-8');
-                        const lines = stat.trim().length > 0 ? stat.trim().split('\n') : [];
-                        const firstLine = lines.length > 0 ? JSON.parse(lines[0]) : null;
-                        const lastLine = lines.length > 0 ? JSON.parse(lines[lines.length - 1]) : null;
-                        entries.push({
-                            id: sessionId,
-                            projectPath: projectDir.projectPath,
-                            summary: typeof firstLine?.content === 'string'
-                                ? firstLine.content.slice(0, 120)
-                                : undefined,
-                            createdAt: firstLine?.timestamp,
-                            lastActivityAt: lastLine?.timestamp,
-                            messageCount: lines.length,
-                            status: firstLine?.status,
-                        });
-                    }
-                    catch {
-                        entries.push({ id: sessionId, projectPath: projectDir.projectPath });
-                    }
-                }
-            }
+            const entries = this.collectSessionEntries(dir);
             const limit = options.limit ?? 50;
-            entries.sort((a, b) => {
-                const da = a.lastActivityAt ?? a.createdAt ?? '';
-                const db = b.lastActivityAt ?? b.createdAt ?? '';
-                return db.localeCompare(da);
-            });
             return { sessions: entries.slice(0, limit) };
         }
         catch (err) {
             return { sessions: [], error: err instanceof Error ? err.message : String(err) };
         }
     }
+    /**
+     * 收集给定工作目录范围内的全部会话条目（task 6.10）。
+     *
+     * 复用 listSessions 的遍历逻辑：索引元数据优先（`~/.claude/sessions/*.json`），
+     * 缺失时回退到读取 `.jsonl` 首尾行。结果按 lastActivityAt/createdAt 倒序排列。
+     * searchSessions 与 listSessions 共享该集合以保持一致行为。
+     */
+    collectSessionEntries(dir) {
+        const projectDirs = this.resolveProjectDirs(dir);
+        if (projectDirs.length === 0) {
+            return [];
+        }
+        const sessionsIndex = this.loadSessionsIndex();
+        const entries = [];
+        const seen = new Set();
+        for (const projectDir of projectDirs) {
+            const files = readdirSync(projectDir.path, { withFileTypes: true })
+                .filter((d) => d.isFile() && d.name.endsWith('.jsonl'));
+            for (const file of files) {
+                const sessionId = file.name.replace(/\.jsonl$/, '');
+                if (seen.has(sessionId))
+                    continue;
+                seen.add(sessionId);
+                const indexPath = join(projectDir.path, file.name);
+                const idxMeta = sessionsIndex.get(sessionId);
+                if (idxMeta) {
+                    entries.push({
+                        id: sessionId,
+                        cwd: idxMeta.cwd,
+                        projectPath: idxMeta.cwd ?? projectDir.projectPath,
+                        summary: idxMeta.summary,
+                        createdAt: idxMeta.createdAt,
+                        lastActivityAt: idxMeta.lastActivityAt,
+                        messageCount: idxMeta.messageCount,
+                        status: idxMeta.status,
+                    });
+                    continue;
+                }
+                try {
+                    const stat = readFileSync(indexPath, 'utf-8');
+                    const lines = stat.trim().length > 0 ? stat.trim().split('\n') : [];
+                    const firstLine = lines.length > 0 ? JSON.parse(lines[0]) : null;
+                    const lastLine = lines.length > 0 ? JSON.parse(lines[lines.length - 1]) : null;
+                    entries.push({
+                        id: sessionId,
+                        projectPath: projectDir.projectPath,
+                        summary: typeof firstLine?.content === 'string'
+                            ? firstLine.content.slice(0, 120)
+                            : undefined,
+                        createdAt: firstLine?.timestamp,
+                        lastActivityAt: lastLine?.timestamp,
+                        messageCount: lines.length,
+                        status: firstLine?.status,
+                    });
+                }
+                catch {
+                    entries.push({ id: sessionId, projectPath: projectDir.projectPath });
+                }
+            }
+        }
+        entries.sort((a, b) => {
+            const da = a.lastActivityAt ?? a.createdAt ?? '';
+            const db = b.lastActivityAt ?? b.createdAt ?? '';
+            return db.localeCompare(da);
+        });
+        return entries;
+    }
     // ── getSession ──
     async getSession(sessionId, options = {}) {
         try {
@@ -404,6 +570,124 @@ export class ClaudeAdapter {
             return this.emptySessionResult(sessionId, err instanceof Error ? err.message : String(err));
         }
     }
+    // ── searchSessions（task 6.10） ──
+    /**
+     * 按可见文本字段搜索项目会话。命中 summary / customTitle / firstPrompt /
+     * cwd / projectName / projectPath（不区分大小写）。
+     *
+     * 实现为 collectSessionEntries + 内存过滤：daemon 侧结果集通常很小，
+     * 无需引擎原生搜索能力；与 listSessions 共享同一数据源保证一致性。
+     * cursor 为简单整数偏移字符串。
+     */
+    async searchSessions(options) {
+        try {
+            const needle = options.query?.trim().toLowerCase();
+            if (!needle) {
+                return { sessions: [] };
+            }
+            const dir = options.dir?.trim();
+            const all = this.collectSessionEntries(dir);
+            const matched = all.filter((entry) => this.sessionEntryMatches(entry, needle));
+            const limit = options.limit ?? 50;
+            const start = this.cursorToOffset(options.cursor);
+            const page = matched.slice(start, start + limit);
+            const hasNext = start + limit < matched.length;
+            return {
+                sessions: page,
+                ...(hasNext ? { nextCursor: String(start + limit) } : {}),
+            };
+        }
+        catch (err) {
+            return { sessions: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    sessionEntryMatches(entry, needle) {
+        const fields = [
+            entry.summary,
+            entry.customTitle,
+            entry.firstPrompt,
+            entry.cwd,
+            entry.projectName,
+            entry.projectPath,
+            entry.gitBranch,
+            entry.tag,
+        ];
+        return fields.some((value) => typeof value === 'string' && value.toLowerCase().includes(needle));
+    }
+    cursorToOffset(cursor) {
+        if (!cursor)
+            return 0;
+        const parsed = Number.parseInt(cursor, 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+    }
+    // ── deleteSession（task 6.10） ──
+    /**
+     * 幂等删除会话：删除 `~/.claude/projects/<dir>/<sessionId>.jsonl`，
+     * 并清理 `~/.claude/sessions/*.json` 索引中指向该 sessionId 的条目。
+     *
+     * - 文件不存在（或从未存在）→ `already_deleted`（幂等）。
+     * - 文件存在并删除成功 → `deleted`。
+     * - 删除失败（权限等）→ `rejected`（含 error）。
+     *
+     * 仅作用于 Engine 原生 Session 文件，不影响产品 conversation/task 记录（task 9.13）。
+     */
+    async deleteSession(sessionId, _request) {
+        try {
+            const resolved = this.resolveSessionFile(sessionId);
+            if (!resolved || !existsSync(resolved.path)) {
+                // 索引条目仍可能残留：清理之，保持幂等语义
+                this.cleanSessionsIndex(sessionId);
+                return { status: 'already_deleted' };
+            }
+            try {
+                unlinkSync(resolved.path);
+            }
+            catch (err) {
+                return {
+                    status: 'rejected',
+                    error: `Failed to delete session file: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            this.cleanSessionsIndex(sessionId);
+            return { status: 'deleted' };
+        }
+        catch (err) {
+            return {
+                status: 'rejected',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * 清理 `~/.claude/sessions/*.json` 索引中指向该 sessionId 的条目。
+     * 静默处理：索引不存在或解析失败不影响删除回执。
+     */
+    cleanSessionsIndex(sessionId) {
+        try {
+            const sessionsDir = join(homedir(), '.claude', 'sessions');
+            if (!existsSync(sessionsDir))
+                return;
+            const files = readdirSync(sessionsDir, { withFileTypes: true });
+            for (const file of files) {
+                if (!file.isFile() || !file.name.endsWith('.json'))
+                    continue;
+                const filePath = join(sessionsDir, file.name);
+                try {
+                    const meta = JSON.parse(readFileSync(filePath, 'utf-8'));
+                    if (meta?.sessionId !== sessionId)
+                        continue;
+                    // 该索引文件即为该会话的元数据；删除整个文件
+                    unlinkSync(filePath);
+                }
+                catch {
+                    /* skip malformed index entries */
+                }
+            }
+        }
+        catch {
+            /* index cleanup is best-effort */
+        }
+    }
     // ── helpers for session queries ──
     /** �?~/.claude/sessions/*.json 加载会话元数据索�?*/
     loadSessionsIndex() {
@@ -678,5 +962,41 @@ export class ClaudeAdapter {
         }
         return null;
     }
+    // 搬自 run-claude-agent.mjs:38-40,491-511
+    async *executeViaAgentSdk(task, signal) {
+        const sdkPath = process.env.CLAUDE_AGENT_SDK_PATH
+            || '/home/node/.local/lib/node_modules/@anthropic-ai/claude-agent-sdk';
+        const require = createRequire(import.meta.url);
+        const sdk = require(sdkPath);
+        const { query } = sdk;
+        const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+        const permissionMode = resolvePermissionMode(task);
+        const maxTurns = Math.min(task.claude?.maxTurns ?? 200, 500);
+        const allowedTools = task.claude?.tools ?? ['Skill', 'Read', 'Write', 'Bash', 'mcp__*'];
+        const queryOptions = {
+            cwd: task.workDir || process.cwd(),
+            settingSources: ['user', 'project'],
+            allowedTools,
+            permissionMode,
+            maxTurns,
+        };
+        if (task.resumeSession && task.sessionId)
+            queryOptions.resume = task.sessionId;
+        if (!isRoot)
+            queryOptions.allowDangerouslySkipPermissions = true;
+        for await (const message of query({
+            prompt: task.prompt || task.input || '',
+            options: queryOptions,
+        })) {
+            if (signal?.aborted)
+                return;
+            if (message.type === 'result' && message.result != null) {
+                yield { type: 'result', content: String(message.result) };
+            }
+            else if (message.type === 'assistant' && message.message != null) {
+                yield { type: 'delta', content: String(message.message), engineEvent: { type: 'content_delta', text: String(message.message) } };
+            }
+        }
+    }
 }
 //# sourceMappingURL=ClaudeAdapter.js.map