@agenthippo-ai/agenthippo 0.1.0

package/out/engines/claude.js

@@ -0,0 +1,1215 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeEngine = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const base_1 = require("./base");
+const utils_1 = require("../utils");
+const permissions_1 = require("../permissions");
+const mcp_1 = require("../mcp");
+const session_1 = require("../session");
+const agentpack_1 = require("../agentpack");
+const shared_1 = require("../shared");
+// File tools we track for edit diffs via hooks (Set for O(1) lookup)
+// Includes Claude SDK tools, Computer Use tools, and common variations
+const FILE_TOOLS = new Set([
+    'Write', 'Edit', 'FileEdit', 'FileWrite', 'MultiEdit',
+    // Claude Computer Use / text_editor tools
+    'str_replace_editor', 'Str_replace_editor', 'TextEditor', 'text_editor',
+    // Bash can modify files - track it too
+    'Bash', 'bash', 'shell', 'Shell',
+]);
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const ACTIVE_SESSION_IDLE_TTL_MS = 1000 * 60 * 30; // 30 minutes
+/** Build canUseTool handler: AskUserQuestion → emitter.question (workbench askQuestions); other tools → allow. */
+function buildCanUseTool(emitter, logger) {
+    return async (toolName, input) => {
+        if (toolName === 'AskUserQuestion') {
+            const askInput = input;
+            const questions = askInput?.questions ?? [];
+            if (questions.length === 0) {
+                logger.warn('[AgentIDE] AskUserQuestion with no questions');
+                return { behavior: 'allow', updatedInput: { ...askInput, answers: {} } };
+            }
+            const answers = {};
+            for (const q of questions) {
+                const payload = {
+                    questionId: `ask-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                    prompt: q.question,
+                    options: q.options?.map(o => ({ label: o.label, description: o.description })),
+                    multiSelect: q.multiSelect,
+                };
+                const answer = await emitter.question(payload);
+                if (answer.declined || answer.cancelled) {
+                    return { behavior: 'deny', message: 'User declined or cancelled the question.' };
+                }
+                const value = answer.freeText ?? answer.selected.join(', ');
+                answers[q.question] = value;
+            }
+            return {
+                behavior: 'allow',
+                updatedInput: { questions: askInput.questions, answers },
+            };
+        }
+        // Other tools: allow (permission mode / hooks handle approval elsewhere)
+        return { behavior: 'allow', updatedInput: input };
+    };
+}
+// Per-process runtime context for agents: lets the agent locate its per-session context export.
+const AGENTIDE_CONTEXT_EXPORT_PATH_ENV_VAR = 'AGENTIDE_CONTEXT_EXPORT_PATH';
+const AGENTIDE_TERMINAL_LOG_PATH_ENV_VAR = 'AGENTIDE_TERMINAL_LOG_PATH';
+// -----------------------------------------------------------------------------
+// Async Queue for Claude Persistent Sessions
+// -----------------------------------------------------------------------------
+function createAsyncQueue() {
+    let closed = false;
+    const buffer = [];
+    const pending = [];
+    return {
+        enqueue(value) {
+            if (closed) {
+                throw new Error('Cannot enqueue into a closed queue');
+            }
+            const next = pending.shift();
+            if (next) {
+                next({ value, done: false });
+                return;
+            }
+            buffer.push(value);
+        },
+        close() {
+            closed = true;
+            while (pending.length) {
+                const next = pending.shift();
+                next?.({ value: undefined, done: true });
+            }
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (buffer.length) {
+                        const value = buffer.shift();
+                        return Promise.resolve({ value, done: false });
+                    }
+                    if (closed) {
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise(resolve => pending.push(resolve));
+                }
+            };
+        }
+    };
+}
+function createClaudePersistentQuerySession(params) {
+    const input = createAsyncQueue();
+    const abortController = new AbortController();
+    const q = params.queryFn({
+        prompt: input,
+        options: {
+            ...params.options,
+            abortController,
+            resume: params.resumeSessionId
+        }
+    });
+    const iterator = q[Symbol.asyncIterator]();
+    let closed = false;
+    let sessionId = params.resumeSessionId ?? null;
+    return {
+        get sessionId() {
+            return sessionId;
+        },
+        async setMaxThinkingTokens(maxThinkingTokens) {
+            if (closed) {
+                throw new Error('Cannot setMaxThinkingTokens on closed Claude session');
+            }
+            await q.setMaxThinkingTokens(maxThinkingTokens);
+        },
+        async interrupt() {
+            if (closed) {
+                return;
+            }
+            try {
+                await q.interrupt();
+            }
+            catch {
+                // Best-effort; caller may fall back to close()
+            }
+        },
+        async send(message) {
+            if (closed) {
+                throw new Error('Cannot send to closed Claude session');
+            }
+            let userMessage;
+            if (typeof message === 'string') {
+                userMessage = {
+                    type: 'user',
+                    session_id: '',
+                    message: {
+                        role: 'user',
+                        content: [{ type: 'text', text: message }]
+                    },
+                    parent_tool_use_id: null
+                };
+            }
+            else {
+                userMessage = message;
+            }
+            input.enqueue(userMessage);
+        },
+        async *receive() {
+            while (true) {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    return;
+                }
+                const msg = value;
+                if (msg.type === 'system' && msg.subtype === 'init') {
+                    sessionId = msg.session_id;
+                }
+                yield msg;
+                if (msg.type === 'result') {
+                    return;
+                }
+            }
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            input.close();
+            abortController.abort();
+        }
+    };
+}
+// -----------------------------------------------------------------------------
+// Claude Provider
+// -----------------------------------------------------------------------------
+class ClaudeEngine {
+    config;
+    computeAgentideSignature;
+    getBundledBasePromptsDir;
+    id = 'claude';
+    displayName = 'Claude';
+    activeSessions = new Map();
+    constructor(config, computeAgentideSignature, getBundledBasePromptsDir) {
+        this.config = config;
+        this.computeAgentideSignature = computeAgentideSignature;
+        this.getBundledBasePromptsDir = getBundledBasePromptsDir;
+    }
+    async stream(message, options, emitter, runtime, signal) {
+        // Use logger from runtime context
+        const logger = runtime.logger;
+        // Edit tracker from runtime context (optional)
+        const editTracker = runtime.editTracker;
+        // Resolve API routing (LiteLLM proxy vs direct Anthropic)
+        const { apiKey, baseUrl, useLiteLLM } = (0, utils_1.resolveApiRouting)(options, this.config.litellmApiKey, this.config.litellmBaseUrl);
+        if (!apiKey) {
+            throw new Error('Claude API key not provided');
+        }
+        logger.info(`[AgentIDE] Claude using ${useLiteLLM ? 'LiteLLM proxy' : 'direct Anthropic'}, baseUrl: ${baseUrl || 'default'}, workspaceRoot=${options.workspaceRoot}, additionalDirs=${options.additionalDirectories?.length ?? 0}`);
+        await emitter.progress('Thinking...');
+        // Build LiteLLM metadata headers for OTEL analytics.
+        // Use requestId from options (generated by caller) for Layer 1/Layer 2 correlation.
+        const litellmMetadataHeaders = (0, base_1.buildLiteLLMMetadataHeaders)(useLiteLLM, {
+            sessionId: options.sessionId,
+            analyticsUserId: options.analyticsUserId,
+            analyticsProjectId: (0, base_1.resolveAnalyticsProjectId)(options.analyticsProjectId, options.workspaceRoot),
+            agentId: options.agentPackId ?? 'default',
+            agentVersion: options.agentPackVersion ?? 'workspace',
+            source: 'agenthippo',
+            engine: 'claude',
+            requestId: options.requestId,
+        });
+        // Build environment for Claude SDK.
+        // Setup-token auth must use Claude's OAuth token env var instead of ANTHROPIC_API_KEY.
+        const claudeEnv = {
+            ...process.env,
+            ...(runtime.cliEnvPatch ?? {}),
+            'DEBUG_CLAUDE_AGENT_SDK': '1',
+            'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC': '1',
+        };
+        const isSetupTokenAuth = (0, shared_1.isAnthropicSetupToken)(apiKey);
+        if (isSetupTokenAuth) {
+            const normalizedSetupToken = (0, shared_1.normalizeAnthropicSetupToken)(apiKey);
+            claudeEnv['CLAUDE_CODE_OAUTH_TOKEN'] = normalizedSetupToken;
+            // Important: do NOT also set ANTHROPIC_AUTH_TOKEN here.
+            // The Claude SDK prioritizes ANTHROPIC_AUTH_TOKEN over CLAUDE_CODE_OAUTH_TOKEN.
+            // Setting both can force the wrong auth path and yield 401 Invalid bearer token.
+            delete claudeEnv['ANTHROPIC_AUTH_TOKEN'];
+            delete claudeEnv['ANTHROPIC_API_KEY'];
+            logger.info('[AgentIDE] Claude using setup-token auth (CLAUDE_CODE_OAUTH_TOKEN)');
+        }
+        else {
+            claudeEnv['ANTHROPIC_API_KEY'] = apiKey;
+            claudeEnv['ANTHROPIC_AUTH_TOKEN'] = apiKey;
+            delete claudeEnv['CLAUDE_CODE_OAUTH_TOKEN'];
+        }
+        // Expose the VS Code chat session id to the agent process so it can locate:
+        //   .agentide/sessions/<sessionId>/context.md
+        const rawChatSessionId = options.sessionId?.trim();
+        const contextSessionId = options.contextSessionId?.trim() || rawChatSessionId;
+        if (contextSessionId) {
+            claudeEnv[AGENTIDE_CONTEXT_EXPORT_PATH_ENV_VAR] = path.join(options.workspaceRoot, agentpack_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'sessions', contextSessionId, 'context.md');
+            claudeEnv[AGENTIDE_TERMINAL_LOG_PATH_ENV_VAR] = path.join(options.workspaceRoot, agentpack_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'sessions', contextSessionId, 'terminal.md');
+        }
+        // Resolve runtime paths for config directories (agent-isolated)
+        // Note: cwd is ALWAYS workspaceRoot - active agent content is synced to workspace's .claude/.codex
+        const agentId = options.agentPackId ?? 'default';
+        const runtimePaths = (0, agentpack_1.resolveRuntimePaths)(options.workspaceRoot, this.config.storagePath, agentId, options.agentPackVersion);
+        // Claude config directory (isolated per agent for session/state isolation)
+        const claudeConfigDir = runtimePaths.claudeConfigDir;
+        claudeEnv['CLAUDE_CONFIG_DIR'] = claudeConfigDir;
+        await fs_1.promises.mkdir(claudeConfigDir, { recursive: true });
+        // Always set AGENT_ID for agent to know its identity
+        claudeEnv['AGENT_ID'] = agentId;
+        if (options.agentPackVersion) {
+            claudeEnv['AGENTIDE_AGENT_VERSION'] = options.agentPackVersion;
+        }
+        if (agentId !== 'default') {
+            logger.info(`[AgentIDE] Claude using agent: ${agentId}, CLAUDE_CONFIG_DIR=${claudeConfigDir} (agent-isolated)`);
+        }
+        else {
+            logger.info(`[AgentIDE] Claude using default agent, CLAUDE_CONFIG_DIR=${claudeConfigDir}`);
+        }
+        if (litellmMetadataHeaders.length > 0) {
+            claudeEnv['ANTHROPIC_CUSTOM_HEADERS'] = litellmMetadataHeaders.join('\n');
+        }
+        // Only set ANTHROPIC_BASE_URL if using a custom endpoint (not direct Anthropic API).
+        // The default Anthropic endpoint is https://api.anthropic.com/v1 - don't override for that.
+        const DEFAULT_ANTHROPIC_ENDPOINT = 'https://api.anthropic.com/v1';
+        const isCustomEndpoint = baseUrl && baseUrl !== DEFAULT_ANTHROPIC_ENDPOINT;
+        if (isCustomEndpoint) {
+            // The Anthropic SDK always appends /v1/messages to ANTHROPIC_BASE_URL, so strip any
+            // trailing /v1 to avoid a doubled /v1/v1/messages path. Applies to all custom
+            // endpoints (OpenRouter, local gateways, etc.); direct Anthropic is excluded above.
+            let anthropicBaseUrl = baseUrl.endsWith('/v1')
+                ? baseUrl.slice(0, -3)
+                : baseUrl;
+            claudeEnv['ANTHROPIC_BASE_URL'] = anthropicBaseUrl;
+            logger.info(`[AgentIDE] Using custom Anthropic base URL: ${anthropicBaseUrl}`);
+            if ((0, utils_1.applyLocalTlsBypass)(claudeEnv, anthropicBaseUrl)) {
+                logger.info('[AgentIDE] Disabling TLS verification for local HTTPS');
+            }
+        }
+        const modelName = options.modelId;
+        if (!modelName) {
+            throw new Error('Claude modelId not provided for streaming request');
+        }
+        logger.info(`[AgentIDE] Using Claude model: ${modelName}`);
+        let streamedTextBuffer = '';
+        const emitUniqueMarkdown = async (text) => {
+            if (!text) {
+                return;
+            }
+            const bufLen = streamedTextBuffer.length;
+            const textLen = text.length;
+            if (bufLen === 0) {
+                streamedTextBuffer = text;
+                await emitter.text(text);
+                return;
+            }
+            if (textLen === bufLen) {
+                if (text === streamedTextBuffer) {
+                    logger.debug('[AgentIDE] Claude: exact duplicate, skipping');
+                    return;
+                }
+            }
+            else if (textLen > bufLen) {
+                if (text.startsWith(streamedTextBuffer)) {
+                    const remainder = text.slice(bufLen);
+                    streamedTextBuffer = text;
+                    logger.debug(`[AgentIDE] Claude: emitting remainder (${remainder.length} chars)`);
+                    await emitter.text(remainder);
+                    return;
+                }
+            }
+            else {
+                if (streamedTextBuffer.endsWith(text)) {
+                    logger.debug('[AgentIDE] Claude: suffix already streamed, skipping');
+                    return;
+                }
+            }
+            streamedTextBuffer = text;
+            await emitter.text(text);
+        };
+        const convo = (0, session_1.buildConversationKey)('claude', options);
+        logger.info(`[AgentIDE] Claude conversationKey=${convo.key} (chatSessionId=${convo.chatSessionId}, signature=${convo.signatureHash}${convo.isEphemeral ? ', ephemeral' : ''})`);
+        await (0, session_1.withConversationLock)(convo.key, async () => {
+            // Get engine settings from runtime config provider or VS Code
+            const engineSettings = (0, utils_1.getAgentideEngineSettings)(runtime?.configProvider);
+            const maxThinkingTokens = (typeof engineSettings.claudeMaxThinkingTokens === 'number' && engineSettings.claudeMaxThinkingTokens > 0)
+                ? Math.floor(engineSettings.claudeMaxThinkingTokens)
+                : null;
+            logger.debug(`[AgentIDE] Claude maxThinkingTokens=${maxThinkingTokens ?? 'default/disabled'}`);
+            const cheapModel = (engineSettings.claudeCheapModel || '').trim();
+            if (cheapModel) {
+                // Route Claude's lightweight/background model usage (including subagents) to a cheaper model.
+                claudeEnv['ANTHROPIC_DEFAULT_HAIKU_MODEL'] = cheapModel;
+                claudeEnv['CLAUDE_CODE_SUBAGENT_MODEL'] = cheapModel;
+                logger.debug(`[AgentIDE] Claude cheapModel=${cheapModel}`);
+            }
+            // Resolve unified permissions (from manifest via options, or defaults)
+            const effectivePerms = options.permissions ?? permissions_1.DEFAULT_PERMISSIONS;
+            logger.debug(`[AgentIDE] Claude permissions: fileAccess=${effectivePerms.fileAccess}`);
+            // Build workspace folders list for permission mapping
+            const workspaceFolders = (0, utils_1.stableAdditionalDirs)([
+                options.workspaceRoot,
+                ...(options.additionalDirectories ?? []),
+            ]);
+            // Map unified permissions to Claude SDK options
+            const claudePermOpts = (0, permissions_1.toClaudeOptions)(effectivePerms, workspaceFolders);
+            logger.debug(`[AgentIDE] Claude mapped: permissionMode=${claudePermOpts.permissionMode}, allowDangerouslySkipPermissions=${claudePermOpts.allowDangerouslySkipPermissions}, dirs=${claudePermOpts.additionalDirectories?.length ?? 'undefined'}`);
+            // Build additional directories for tool access
+            // Always include workspace root and config dir
+            const claudeToolDirectories = (0, utils_1.stableAdditionalDirs)([
+                ...(claudePermOpts.additionalDirectories ?? []),
+                claudeConfigDir,
+            ]);
+            const agentideSignature = await this.computeAgentideSignature(options.workspaceRoot, options.additionalDirectories);
+            const rawChatSessionId = options.sessionId;
+            const workspaceRoot = options.workspaceRoot;
+            // Mutable container for edit state - populated after session is obtained.
+            // Using a container object avoids repeated Map lookups in hot-path hooks.
+            const editStateRef = { current: null };
+            // Git commands don't modify file content - skip tracking them
+            const isGitCommand = (command) => {
+                const trimmed = command.trim();
+                // Match git commands at start, or after && or ; or |
+                return /(?:^|&&|\||;)\s*git\s+/.test(trimmed);
+            };
+            // Extract files from tool input based on tool type
+            const getFilesFromToolInput = (toolName, toolInput) => {
+                const input = toolInput;
+                if (!input) {
+                    return [];
+                }
+                if (toolName === 'Bash') {
+                    const command = input.command;
+                    if (!command) {
+                        return [];
+                    }
+                    // Skip git commands - they don't modify file content
+                    if (isGitCommand(command)) {
+                        return [];
+                    }
+                    return (0, utils_1.extractFilePaths)(command, workspaceRoot);
+                }
+                // File tools (Write, Edit, etc.) have file_path or path
+                const filePath = (input.file_path ?? input.path);
+                if (!filePath) {
+                    return [];
+                }
+                const absPath = path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+                return [absPath];
+            };
+            // Cached return value to avoid object allocation on every call
+            const CONTINUE = { continue: true };
+            // PreToolUse hook: snapshot files BEFORE tool modifies them
+            // MUST await startTracking so opId is available for PostToolUse
+            const preToolUseHook = async (input, toolUseID, _options) => {
+                try {
+                    logger.debug(`[AgentIDE] PreToolUse hook called: toolUseID=${toolUseID}, event=${input.hook_event_name}`);
+                    const state = editStateRef.current;
+                    if (!state) {
+                        logger.debug(`[AgentIDE] PreToolUse: no edit state`);
+                        return CONTINUE;
+                    }
+                    if (state.aborted) {
+                        logger.debug(`[AgentIDE] PreToolUse: aborted`);
+                        return CONTINUE;
+                    }
+                    if (input.hook_event_name !== 'PreToolUse') {
+                        logger.debug(`[AgentIDE] PreToolUse: wrong event ${input.hook_event_name}`);
+                        return CONTINUE;
+                    }
+                    if (!rawChatSessionId) {
+                        logger.debug(`[AgentIDE] PreToolUse: no rawChatSessionId`);
+                        return CONTINUE;
+                    }
+                    if (!editTracker) {
+                        logger.debug(`[AgentIDE] PreToolUse: no edit tracker available`);
+                        return CONTINUE;
+                    }
+                    const toolName = input.tool_name;
+                    if (!FILE_TOOLS.has(toolName)) {
+                        logger.debug(`[AgentIDE] PreToolUse: tool ${toolName} not tracked (not in FILE_TOOLS)`);
+                        return CONTINUE;
+                    }
+                    const toolUseId = input.tool_use_id;
+                    const files = getFilesFromToolInput(toolName, input.tool_input).filter(f => !(0, utils_1.isBinaryFile)(f));
+                    logger.debug(`[AgentIDE] PreToolUse: ${toolName} files=${files.length}: ${files.join(', ')}`);
+                    if (files.length === 0) {
+                        return CONTINUE;
+                    }
+                    // Start edit tracking via abstracted interface
+                    logger.debug(`[AgentIDE] PreToolUse: calling startTracking for ${files.length} files`);
+                    try {
+                        const result = await editTracker.startTracking(rawChatSessionId, files);
+                        if (result?.operationId !== undefined && state && !state.aborted) {
+                            logger.debug(`[AgentIDE] PreToolUse: startTracking returned opId=${result.operationId}`);
+                            state.pendingOperations.set(toolUseId, result.operationId);
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`[AgentIDE] PreToolUse: startTracking failed: ${e}`);
+                        // Continue without edit tracking - agent should still work
+                    }
+                    return CONTINUE;
+                }
+                catch (e) {
+                    logger.error(`[AgentIDE] PreToolUse hook EXCEPTION`, e instanceof Error ? e : undefined);
+                    return CONTINUE;
+                }
+            };
+            // PostToolUse hook: compute diffs AFTER tool completes
+            // MUST await stopTracking to compute diffs
+            const postToolUseHook = async (input, toolUseID, _options) => {
+                try {
+                    logger.debug(`[AgentIDE] PostToolUse hook called: toolUseID=${toolUseID}, event=${input.hook_event_name}`);
+                    const state = editStateRef.current;
+                    if (!state || state.aborted || input.hook_event_name !== 'PostToolUse' || !rawChatSessionId) {
+                        return CONTINUE;
+                    }
+                    if (!editTracker) {
+                        return CONTINUE;
+                    }
+                    const toolUseId = input.tool_use_id;
+                    if (!toolUseId) {
+                        return CONTINUE;
+                    }
+                    const opId = state.pendingOperations.get(toolUseId);
+                    logger.debug(`[AgentIDE] PostToolUse: toolUseId=${toolUseId} opId=${opId}`);
+                    if (opId !== undefined) {
+                        state.pendingOperations.delete(toolUseId); // Delete early to prevent double-stop
+                        try {
+                            await editTracker.stopTracking(rawChatSessionId, opId);
+                            logger.debug(`[AgentIDE] PostToolUse: stopTracking done`);
+                        }
+                        catch (e) {
+                            logger.warn(`[AgentIDE] PostToolUse: stopTracking failed: ${e}`);
+                        }
+                    }
+                    return CONTINUE;
+                }
+                catch (e) {
+                    logger.error(`[AgentIDE] PostToolUse hook EXCEPTION`, e instanceof Error ? e : undefined);
+                    return CONTINUE;
+                }
+            };
+            logger.debug(`[AgentIDE] Setting up Claude hooks for session ${rawChatSessionId}`);
+            // Test hook to verify hooks work at all
+            const sessionStartHook = async (input, _toolUseID, _options) => {
+                logger.debug(`[AgentIDE] SessionStart hook called! event=${input.hook_event_name}`);
+                return CONTINUE;
+            };
+            // Load MCP servers for the active agent and pass directly to SDK
+            const mcpServers = await this.loadMcpServersForClaude(logger, options.workspaceRoot, agentId);
+            // Determine cwd and settingSources
+            // cwd is ALWAYS workspaceRoot - active agent content has been synced to workspace's .claude/
+            // Agent packs: settingSources is 'project' only (no user ~/.claude/ mixing)
+            // Default agent: settingSources includes 'user' and 'project'
+            const queryCwd = options.workspaceRoot;
+            const querySettingSources = agentId !== 'default'
+                ? ['project'] // Agent pack: only pack's synced .claude/ settings, no ~/.claude/
+                : ['user', 'project']; // Default agent: inherit from user + project
+            // When using bypassPermissions, allowDangerouslySkipPermissions must be true
+            // Otherwise the SDK will still prompt for permissions
+            const skipPermissions = claudePermOpts.allowDangerouslySkipPermissions === true ? true : undefined;
+            const queryOptions = {
+                model: modelName,
+                cwd: queryCwd,
+                additionalDirectories: claudeToolDirectories,
+                settingSources: querySettingSources,
+                env: claudeEnv,
+                // Use mapped permissions from unified AgentPermissions
+                permissionMode: claudePermOpts.permissionMode,
+                allowDangerouslySkipPermissions: skipPermissions,
+                includePartialMessages: true,
+                persistSession: true,
+                ...(maxThinkingTokens ? { maxThinkingTokens } : {}),
+                ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
+                // Path to Claude Code CLI (for headless mode when bundled)
+                ...(this.config.claudeCodeExecutablePath ? { pathToClaudeCodeExecutable: this.config.claudeCodeExecutablePath } : {}),
+                // AskUserQuestion → emitter.question (workbench askQuestions); other tools → allow
+                canUseTool: buildCanUseTool(emitter, logger),
+                // Hooks for tracking file modifications (edit diffs) - fire-and-forget, zero agent impact
+                hooks: {
+                    SessionStart: [{ hooks: [sessionStartHook] }],
+                    PreToolUse: [{ hooks: [preToolUseHook] }],
+                    PostToolUse: [{ hooks: [postToolUseHook] }],
+                },
+                stderr: (line) => {
+                    logger.debug(`[AgentIDE] Claude CLI stderr: ${line}`);
+                }
+            };
+            const sessionEntry = await this.getOrCreateSession({
+                conversationKey: convo.key,
+                chatSessionId: convo.chatSessionId,
+                signatureHash: convo.signatureHash,
+                signatureRaw: convo.signatureRaw,
+                agentideSignature,
+                isEphemeral: convo.isEphemeral,
+                modelId: modelName,
+                cheapModel: cheapModel || undefined,
+                queryOptions,
+                logger
+            });
+            const session = sessionEntry.session;
+            const editState = sessionEntry.editTrackingState;
+            // Populate the ref so hooks can access the edit state without Map lookups
+            editStateRef.current = editState;
+            let aborted = false;
+            const onAbort = () => {
+                aborted = true;
+                editState.aborted = true; // Signal hooks to stop
+                // Clean up any pending edit operations - release locks so future turns don't deadlock
+                const pendingOpIds = Array.from(editState.pendingOperations.values());
+                editState.pendingOperations.clear();
+                if (rawChatSessionId && pendingOpIds.length > 0 && editTracker) {
+                    for (const opId of pendingOpIds) {
+                        void editTracker.stopTracking(rawChatSessionId, opId).catch(() => { });
+                    }
+                }
+                logger.info('[AgentIDE] Claude cancel requested; interrupting session...');
+                // Best-effort: interrupt the current turn but keep the persistent session alive.
+                // Fall back to closing the session if interrupt fails.
+                void session.interrupt().catch(() => {
+                    try {
+                        session.close();
+                    }
+                    catch {
+                        // ignore
+                    }
+                });
+            };
+            if (signal?.aborted) {
+                onAbort();
+                return;
+            }
+            signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+                try {
+                    await session.setMaxThinkingTokens(maxThinkingTokens);
+                    logger.debug(`[AgentIDE] Claude setMaxThinkingTokens(${maxThinkingTokens ?? 'null'}) ok`);
+                }
+                catch (e) {
+                    logger.warn(`[AgentIDE] Claude setMaxThinkingTokens(${maxThinkingTokens ?? 'null'}) failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                await session.send(message);
+                let thinkingDeltaCount = 0;
+                let thinkingCharCount = 0;
+                let thinkingStartBlockCount = 0;
+                let redactedThinkingBlockCount = 0;
+                let toolUseBlockCount = 0;
+                let toolUseEmitCount = 0;
+                let toolProgressCount = 0;
+                let inputJsonDeltaCount = 0;
+                const emittedToolUseIds = new Set();
+                const emittedToolUseIdsWithInput = new Set();
+                const emittedToolEndIds = new Set();
+                const activeToolUseById = new Map();
+                const toolUseIdByIndex = new Map();
+                const toolUseNameByIndex = new Map();
+                const toolUseJsonByIndex = new Map();
+                const previewThinking = (s) => s
+                    .replace(/\r/g, '')
+                    .replace(/\n/g, '\\n')
+                    .slice(0, 160);
+                const formatToolInputForDisplay = (_toolName, input) => {
+                    if (typeof input === 'string') {
+                        const trimmed = input.trim();
+                        return trimmed ? input : undefined;
+                    }
+                    if (!input || typeof input !== 'object') {
+                        return undefined;
+                    }
+                    const obj = input;
+                    // Common "command" pattern
+                    const cmd = obj['command'];
+                    if (typeof cmd === 'string' && cmd.trim()) {
+                        return cmd.trim();
+                    }
+                    const args = obj['args'];
+                    if (Array.isArray(args) && args.every(a => typeof a === 'string')) {
+                        return args.join(' ');
+                    }
+                    // Common "path" pattern (e.g. file tools)
+                    const maybeLocation = obj['location'];
+                    const maybeLocationPath = (maybeLocation && typeof maybeLocation === 'object')
+                        ? maybeLocation['path']
+                        : undefined;
+                    const pathLike = obj['path'] ?? obj['file_path'] ?? obj['file'] ?? obj['filename'] ?? maybeLocationPath;
+                    const parts = [];
+                    if (typeof pathLike === 'string' && pathLike.trim()) {
+                        parts.push(pathLike.trim());
+                    }
+                    // Avoid dumping large contents (WriteTool often includes full file content)
+                    const content = obj['content'];
+                    if (typeof content === 'string') {
+                        parts.push(`contentBytes=${Buffer.byteLength(content, 'utf8')}`);
+                    }
+                    const patchLike = obj['patch'] ?? obj['diff'];
+                    if (typeof patchLike === 'string') {
+                        parts.push(`patchBytes=${Buffer.byteLength(patchLike, 'utf8')}`);
+                    }
+                    if (parts.length > 0) {
+                        return parts.join(' ');
+                    }
+                    const MAX_STRING_CHARS = 300;
+                    const MAX_ARRAY_ITEMS = 30;
+                    const MAX_DEPTH = 4;
+                    const sanitize = (value, depth) => {
+                        if (typeof value === 'string') {
+                            return value.length > MAX_STRING_CHARS
+                                ? `${value.slice(0, MAX_STRING_CHARS)}… (${value.length} chars)`
+                                : value;
+                        }
+                        if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+                            return value;
+                        }
+                        if (Array.isArray(value)) {
+                            if (depth >= MAX_DEPTH) {
+                                return `[Array(${value.length})]`;
+                            }
+                            const head = value.slice(0, MAX_ARRAY_ITEMS).map(v => sanitize(v, depth + 1));
+                            return value.length > MAX_ARRAY_ITEMS
+                                ? [...head, `… (${value.length - MAX_ARRAY_ITEMS} more)`]
+                                : head;
+                        }
+                        if (typeof value === 'object' && value) {
+                            if (depth >= MAX_DEPTH) {
+                                return '[Object]';
+                            }
+                            const out = {};
+                            for (const [k, v] of Object.entries(value)) {
+                                // Heuristic: collapse huge string payloads in fields like "content", "text", "data", etc.
+                                if (typeof v === 'string' && /content|text|data|body|patch|diff/i.test(k) && v.length > MAX_STRING_CHARS) {
+                                    out[k] = `<${Buffer.byteLength(v, 'utf8')} bytes>`;
+                                    continue;
+                                }
+                                out[k] = sanitize(v, depth + 1);
+                            }
+                            return out;
+                        }
+                        return undefined;
+                    };
+                    try {
+                        const json = JSON.stringify(sanitize(input, 0), null, 2);
+                        const trimmed = json.trim();
+                        if (trimmed === '{}' || trimmed === '[]') {
+                            return undefined;
+                        }
+                        return json;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                };
+                const getToolUseInfoFromBlock = (block) => {
+                    if (!block || typeof block !== 'object') {
+                        return undefined;
+                    }
+                    const b = block;
+                    const type = b['type'];
+                    if (type === 'tool_use' || type === 'server_tool_use') {
+                        const id = b['id'];
+                        const name = b['name'];
+                        const input = b['input'];
+                        if (typeof id === 'string' && typeof name === 'string') {
+                            return { id, name, input };
+                        }
+                        return undefined;
+                    }
+                    if (type === 'mcp_tool_use') {
+                        const id = b['id'];
+                        const name = b['name'];
+                        const serverName = b['server_name'];
+                        const input = b['input'];
+                        if (typeof id === 'string' && typeof name === 'string' && typeof serverName === 'string') {
+                            return { id, name: `${serverName}.${name}`, input };
+                        }
+                    }
+                    return undefined;
+                };
+                const stringifyToolResult = (value) => {
+                    if (typeof value === 'string') {
+                        return value;
+                    }
+                    if (value === undefined || value === null) {
+                        return undefined;
+                    }
+                    try {
+                        return JSON.stringify(value, null, 2);
+                    }
+                    catch {
+                        return String(value);
+                    }
+                };
+                const extractToolResultText = (value) => {
+                    if (typeof value === 'string') {
+                        return value;
+                    }
+                    if (Array.isArray(value)) {
+                        const parts = [];
+                        for (const part of value) {
+                            if (typeof part === 'string') {
+                                parts.push(part);
+                                continue;
+                            }
+                            if (!part || typeof part !== 'object') {
+                                continue;
+                            }
+                            const p = part;
+                            if (typeof p['text'] === 'string') {
+                                parts.push(p['text']);
+                                continue;
+                            }
+                            const asString = stringifyToolResult(part);
+                            if (asString) {
+                                parts.push(asString);
+                            }
+                        }
+                        const joined = parts.join('\n').trim();
+                        return joined || undefined;
+                    }
+                    if (value && typeof value === 'object') {
+                        const obj = value;
+                        if (typeof obj['text'] === 'string') {
+                            return obj['text'];
+                        }
+                    }
+                    return stringifyToolResult(value);
+                };
+                const getToolResultInfoFromBlock = (block) => {
+                    if (!block || typeof block !== 'object') {
+                        return undefined;
+                    }
+                    const b = block;
+                    const type = b['type'];
+                    if (type !== 'tool_result' && type !== 'server_tool_result' && type !== 'mcp_tool_result') {
+                        return undefined;
+                    }
+                    const toolUseId = b['tool_use_id'];
+                    if (typeof toolUseId !== 'string' || !toolUseId) {
+                        return undefined;
+                    }
+                    const resultText = extractToolResultText(b['content'] ?? b['result'] ?? b['output'] ?? b['data'] ?? b['text']);
+                    const isError = typeof b['is_error'] === 'boolean'
+                        ? b['is_error']
+                        : (typeof b['isError'] === 'boolean' ? b['isError'] : undefined);
+                    return { toolUseId, resultText, isError };
+                };
+                const emitToolStart = async (toolName, toolUseId, formattedInput) => {
+                    const shouldEmit = !emittedToolUseIds.has(toolUseId)
+                        || (!!formattedInput && !emittedToolUseIdsWithInput.has(toolUseId));
+                    if (!shouldEmit) {
+                        activeToolUseById.set(toolUseId, toolName);
+                        return;
+                    }
+                    toolUseEmitCount++;
+                    emittedToolUseIds.add(toolUseId);
+                    if (formattedInput) {
+                        emittedToolUseIdsWithInput.add(toolUseId);
+                    }
+                    activeToolUseById.set(toolUseId, toolName);
+                    if (!aborted) {
+                        await emitter.toolStart(toolName, formattedInput, toolUseId);
+                    }
+                };
+                const emitToolEnd = async (toolUseId, resultText, isError, fallbackToolName) => {
+                    if (emittedToolEndIds.has(toolUseId)) {
+                        return;
+                    }
+                    const toolName = activeToolUseById.get(toolUseId) ?? fallbackToolName ?? 'tool';
+                    if (!emittedToolUseIds.has(toolUseId)) {
+                        // Ensure there's a matching start row before finalizing.
+                        await emitToolStart(toolName, toolUseId);
+                    }
+                    emittedToolEndIds.add(toolUseId);
+                    activeToolUseById.delete(toolUseId);
+                    if (!aborted) {
+                        await emitter.toolEnd(toolName, toolUseId, resultText, isError);
+                    }
+                };
+                let persistedThisTurn = false;
+                let messageCount = 0;
+                for await (const msg of session.receive()) {
+                    messageCount++;
+                    const m = msg;
+                    const sessionIdFromMsg = m.session_id;
+                    if (!persistedThisTurn && sessionIdFromMsg) {
+                        persistedThisTurn = true;
+                        await (0, base_1.persistSessionIfNeeded)('claude', convo, sessionIdFromMsg, options);
+                    }
+                    const subtype = m.type === 'result' || m.type === 'system' ? m.subtype : undefined;
+                    logger.debug(`[AgentIDE] Claude msg #${messageCount}: type=${m.type}, subtype=${subtype || 'none'}`);
+                    // If the user cancelled the turn, keep draining the SDK stream until it yields a terminal result,
+                    // but do not emit any further UI events. This prevents "leftover" result messages from surfacing
+                    // on the next turn (e.g., error_during_execution after a Stop).
+                    if (aborted && m.type !== 'result') {
+                        continue;
+                    }
+                    if (m.type === 'stream_event') {
+                        const event = m.event;
+                        const eventType = event.type;
+                        if (eventType === 'content_block_start') {
+                            const contentBlock = event.content_block;
+                            const blockType = contentBlock?.type;
+                            const blockIndex = event.index;
+                            if (blockType === 'thinking') {
+                                const initialThinking = contentBlock?.thinking;
+                                thinkingStartBlockCount++;
+                                if (typeof initialThinking === 'string' && initialThinking) {
+                                    thinkingCharCount += initialThinking.length;
+                                    logger.debug(`[AgentIDE] Claude thinking block start (${initialThinking.length} chars): ${previewThinking(initialThinking)}`);
+                                    if (!aborted) {
+                                        await emitter.thinking(initialThinking);
+                                    }
+                                }
+                                else {
+                                    logger.debug('[AgentIDE] Claude thinking block start (no initial thinking text)');
+                                }
+                            }
+                            else if (blockType === 'redacted_thinking') {
+                                redactedThinkingBlockCount++;
+                                const data = contentBlock?.data;
+                                logger.debug(`[AgentIDE] Claude redacted_thinking block start (dataType=${typeof data})`);
+                            }
+                            else {
+                                const toolResult = getToolResultInfoFromBlock(event.content_block);
+                                if (toolResult) {
+                                    await emitToolEnd(toolResult.toolUseId, toolResult.resultText, toolResult.isError);
+                                    continue;
+                                }
+                                // Tool use blocks are reported as content blocks in stream events.
+                                const toolUse = getToolUseInfoFromBlock(event.content_block);
+                                if (toolUse) {
+                                    toolUseBlockCount++;
+                                    if (typeof blockIndex === 'number') {
+                                        toolUseIdByIndex.set(blockIndex, toolUse.id);
+                                        toolUseNameByIndex.set(blockIndex, toolUse.name);
+                                    }
+                                    if (!emittedToolUseIds.has(toolUse.id)) {
+                                        const formatted = formatToolInputForDisplay(toolUse.name, toolUse.input);
+                                        logger.debug(`[AgentIDE] Claude tool_use start: ${toolUse.name} (id=${toolUse.id}, input=${formatted ? 'yes' : 'no'})`);
+                                        await emitToolStart(toolUse.name, toolUse.id, formatted);
+                                    }
+                                }
+                            }
+                        }
+                        else if (eventType === 'content_block_delta') {
+                            const delta = event.delta;
+                            const deltaType = delta.type;
+                            const thinking = delta.thinking;
+                            const text = delta.text;
+                            if (deltaType === 'thinking_delta' && typeof thinking === 'string' && thinking) {
+                                thinkingDeltaCount++;
+                                thinkingCharCount += thinking.length;
+                                if (thinkingDeltaCount <= 3) {
+                                    logger.debug(`[AgentIDE] Claude thinking delta #${thinkingDeltaCount} (${thinking.length} chars): ${previewThinking(thinking)}`);
+                                }
+                                if (!aborted) {
+                                    await emitter.thinking(thinking);
+                                }
+                            }
+                            else if (deltaType === 'input_json_delta') {
+                                // Some tool inputs stream as JSON fragments; emit a toolStart once we can parse valid JSON.
+                                const index = event.index;
+                                const partial = delta.partial_json;
+                                if (typeof index === 'number' && typeof partial === 'string' && partial) {
+                                    inputJsonDeltaCount++;
+                                    const prev = toolUseJsonByIndex.get(index) ?? '';
+                                    const next = prev + partial;
+                                    toolUseJsonByIndex.set(index, next);
+                                    const toolUseId = toolUseIdByIndex.get(index);
+                                    if (toolUseId && !emittedToolUseIdsWithInput.has(toolUseId)) {
+                                        try {
+                                            const parsed = JSON.parse(next);
+                                            const toolName = toolUseNameByIndex.get(index) ?? 'tool';
+                                            const formatted = formatToolInputForDisplay(toolName, parsed);
+                                            if (formatted) {
+                                                logger.debug(`[AgentIDE] Claude tool_use input_json parsed: ${toolName} (id=${toolUseId})`);
+                                                await emitToolStart(toolName, toolUseId, formatted);
+                                            }
+                                        }
+                                        catch {
+                                            // not parseable yet
+                                        }
+                                    }
+                                }
+                            }
+                            else if (deltaType === 'text_delta' && typeof text === 'string' && text) {
+                                streamedTextBuffer += text;
+                                if (!aborted) {
+                                    await emitter.text(text);
+                                }
+                            }
+                        }
+                    }
+                    else if (m.type === 'assistant') {
+                        const content = m.message.content;
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                const blockType = block.type;
+                                const blockText = block.text;
+                                const toolResult = getToolResultInfoFromBlock(block);
+                                if (toolResult) {
+                                    await emitToolEnd(toolResult.toolUseId, toolResult.resultText, toolResult.isError);
+                                    continue;
+                                }
+                                const toolUse = getToolUseInfoFromBlock(block);
+                                if (toolUse && !emittedToolUseIds.has(toolUse.id)) {
+                                    toolUseBlockCount++;
+                                    const formatted = formatToolInputForDisplay(toolUse.name, toolUse.input);
+                                    logger.debug(`[AgentIDE] Claude tool_use (assistant msg): ${toolUse.name} (id=${toolUse.id}, input=${formatted ? 'yes' : 'no'})`);
+                                    await emitToolStart(toolUse.name, toolUse.id, formatted);
+                                    continue;
+                                }
+                                if (blockType === 'text' && typeof blockText === 'string' && blockText) {
+                                    if (!aborted) {
+                                        await emitUniqueMarkdown(blockText);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (m.type === 'tool_progress') {
+                        toolProgressCount++;
+                        const toolUseId = m.tool_use_id;
+                        const toolName = m.tool_name || 'tool';
+                        if (toolUseId && !emittedToolUseIds.has(toolUseId)) {
+                            logger.debug(`[AgentIDE] Claude tool_progress: ${toolName} (tool_use_id=${toolUseId})`);
+                            await emitToolStart(toolName, toolUseId);
+                        }
+                    }
+                    else if (m.type === 'system') {
+                        if (m.subtype === 'status' && m.status === 'compacting') {
+                            if (!aborted) {
+                                await emitter.progress('Compacting context…');
+                            }
+                        }
+                    }
+                    else if (m.type === 'result') {
+                        if (m.subtype === 'success') {
+                            // Successful completion: only emit to UI if we weren't cancelled.
+                            if (!aborted) {
+                                await emitUniqueMarkdown(m.result);
+                            }
+                        }
+                        else {
+                            // Error completion: treat as fatal only if the user didn't cancel.
+                            if (!aborted) {
+                                throw new Error(m.errors?.join('\n') || m.subtype);
+                            }
+                        }
+                    }
+                    const genericMessageContent = m.message?.content;
+                    if (m.type !== 'assistant' && Array.isArray(genericMessageContent)) {
+                        for (const block of genericMessageContent) {
+                            const toolResult = getToolResultInfoFromBlock(block);
+                            if (toolResult) {
+                                await emitToolEnd(toolResult.toolUseId, toolResult.resultText, toolResult.isError);
+                            }
+                        }
+                    }
+                }
+                for (const [toolUseId, toolName] of Array.from(activeToolUseById.entries())) {
+                    await emitToolEnd(toolUseId, 'Completed', false, toolName);
+                }
+                logger.info(`[AgentIDE] Claude thinking summary: startBlocks=${thinkingStartBlockCount}, redactedBlocks=${redactedThinkingBlockCount}, deltas=${thinkingDeltaCount}, chars=${thinkingCharCount}`);
+                logger.info(`[AgentIDE] Claude tool summary: toolBlocks=${toolUseBlockCount}, toolEmits=${toolUseEmitCount}, toolProgressMsgs=${toolProgressCount}, inputJsonDeltas=${inputJsonDeltaCount}`);
+                if (thinkingStartBlockCount === 0 && thinkingDeltaCount === 0 && redactedThinkingBlockCount === 0) {
+                    logger.debug('[AgentIDE] Claude emitted no thinking blocks/deltas. Ensure model supports extended thinking and set agentide.claude.maxThinkingTokens >= 1024.');
+                }
+                if (toolUseBlockCount === 0 && toolProgressCount === 0) {
+                    logger.debug('[AgentIDE] Claude emitted no tool usage events. If tools were used, ensure includePartialMessages=true and parse tool_use blocks.');
+                }
+                (0, base_1.touchSessionIfNeeded)(convo);
+            }
+            catch (e) {
+                if (!aborted) {
+                    throw e;
+                }
+                logger.info(`[AgentIDE] Claude stream aborted: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            finally {
+                signal?.removeEventListener('abort', onAbort);
+            }
+        }, {
+            signal,
+            // Agent turns may run for hours; keep this high as a safety net only.
+            timeoutMs: session_1.DEFAULT_CONVERSATION_LOCK_TIMEOUT_MS,
+            label: 'claude.stream'
+        });
+        await emitter.done();
+        logger.info('[AgentIDE] Claude streaming complete');
+    }
+    dispose() {
+        for (const entry of this.activeSessions.values()) {
+            try {
+                entry.session.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.activeSessions.clear();
+    }
+    onMaintenance(logger) {
+        this.sweepIdleSessions(logger);
+    }
+    sweepIdleSessions(logger) {
+        const now = Date.now();
+        for (const [key, entry] of this.activeSessions.entries()) {
+            if (now - entry.lastUsedAt > ACTIVE_SESSION_IDLE_TTL_MS) {
+                try {
+                    entry.session.close();
+                    logger?.info(`[AgentIDE] Closed idle Claude session (key=${key}, idleMs=${now - entry.lastUsedAt})`);
+                }
+                catch {
+                    // ignore
+                }
+                this.activeSessions.delete(key);
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Session Management
+    // ---------------------------------------------------------------------------
+    async getOrCreateSession(params) {
+        const existing = this.activeSessions.get(params.conversationKey);
+        if (existing
+            && existing.signatureHash === params.signatureHash
+            && existing.modelId === params.modelId
+            && existing.cheapModel === params.cheapModel
+            && existing.agentideSignature === params.agentideSignature) {
+            existing.lastUsedAt = Date.now();
+            // Reset edit tracking state for new turn - clear any orphaned pending operations
+            existing.editTrackingState.aborted = false;
+            existing.editTrackingState.pendingOperations.clear();
+            void (0, session_1.touchPersistedSession)(params.conversationKey);
+            params.logger.debug(`[AgentIDE] REUSING existing Claude session (key=${params.conversationKey}) - NOTE: hooks from original session creation are used, not new ones`);
+            return existing;
+        }
+        let resumeSessionId;
+        if (existing) {
+            if (existing.signatureHash === params.signatureHash && existing.agentideSignature !== params.agentideSignature) {
+                params.logger.info(`[AgentIDE] AgentIDE manifest changed (${existing.agentideSignature} → ${params.agentideSignature}), restarting Claude session with resume`);
+                resumeSessionId = existing.session.sessionId ?? undefined;
+            }
+            if (existing.modelId !== params.modelId) {
+                params.logger.info(`[AgentIDE] Model changed (${existing.modelId} → ${params.modelId}), will resume session with new model`);
+                resumeSessionId = existing.session.sessionId ?? undefined;
+            }
+            if (existing.cheapModel !== params.cheapModel) {
+                params.logger.info(`[AgentIDE] Cheap model changed (${existing.cheapModel ?? 'unset'} → ${params.cheapModel ?? 'unset'}), will resume session with updated env`);
+                resumeSessionId = existing.session.sessionId ?? undefined;
+            }
+            try {
+                existing.session.close();
+            }
+            catch {
+                // ignore
+            }
+            this.activeSessions.delete(params.conversationKey);
+        }
+        if (!resumeSessionId && !params.isEphemeral) {
+            resumeSessionId = (0, base_1.getPersistedSessionId)('claude', params.conversationKey);
+        }
+        if (resumeSessionId) {
+            params.logger.info(`[AgentIDE] Claude session will resume: ${resumeSessionId} (model: ${params.modelId})`);
+        }
+        else {
+            params.logger.info(`[AgentIDE] Claude session starting new (model: ${params.modelId})`);
+        }
+        const sdk = await import('@anthropic-ai/claude-agent-sdk');
+        const session = createClaudePersistentQuerySession({
+            resumeSessionId,
+            queryFn: sdk.query,
+            options: params.queryOptions
+        });
+        const entry = {
+            session,
+            chatSessionId: params.chatSessionId,
+            signatureHash: params.signatureHash,
+            agentideSignature: params.agentideSignature,
+            modelId: params.modelId,
+            cheapModel: params.cheapModel,
+            lastUsedAt: Date.now(),
+            editTrackingState: {
+                aborted: false,
+                pendingOperations: new Map(),
+            },
+        };
+        this.activeSessions.set(params.conversationKey, entry);
+        return entry;
+    }
+    // ---------------------------------------------------------------------------
+    // MCP Configuration
+    // ---------------------------------------------------------------------------
+    /**
+     * Load MCP servers for the active agent and return them in Claude SDK format.
+     * - Default agent: uses bundled MCP servers from extension
+     * - Pack agents: uses pack's mcp/ directory
+     *
+     * The SDK accepts mcpServers directly in query options.
+     */
+    async loadMcpServersForClaude(logger, workspaceRoot, agentId = 'default') {
+        const basePromptsDir = this.getBundledBasePromptsDir();
+        const servers = await (0, mcp_1.loadMcpServers)(agentId, workspaceRoot, basePromptsDir);
+        if (servers.length === 0) {
+            return {};
+        }
+        const mcpServers = {};
+        for (const s of servers) {
+            mcpServers[s.name] = {
+                command: s.command,
+                args: s.args,
+                ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {})
+            };
+        }
+        const source = agentId === 'default' ? 'bundled' : `pack:${agentId}`;
+        logger.debug(`[AgentIDE] Claude MCP servers loaded (${source}): ${servers.map(s => s.name).join(', ')}`);
+        return mcpServers;
+    }
+}
+exports.ClaudeEngine = ClaudeEngine;