@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/engines/claude.js

@@ -1,1254 +0,0 @@
-"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 branding_1 = require("../branding");
-const base_1 = require("./base");
-const utils_1 = require("../utils");
-const permissions_1 = require("../permissions");
-const mcp_1 = require("../mcp");
-const runtime_1 = require("../cli/runtime");
-const session_1 = require("../session");
-const agentpack_1 = require("../agentpack");
-const credential_context_1 = require("../cli/credential-context");
-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)
-        // claude routes to Anthropic when direct (or the LiteLLM proxy when configured) — never OpenAI.
-        const { apiKey, baseUrl, useLiteLLM } = (0, utils_1.resolveApiRouting)(options, this.config, 'anthropic');
-        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,
-            policyVersion: options.policyVersion,
-            packDigest: options.packDigest,
-            instanceId: options.instanceId,
-            engineVersion: options.engineVersion,
-            tier: options.tier,
-        });
-        // 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',
-        };
-        // The gateway token stays broker-side; scrub it from the child env so it never reaches
-        // the model (secure-obo-design §7.6 / §7.4 gap 1). UNCONDITIONALLY (serve-v4 §10 hole 2):
-        // gating this on the egress broker let a deployment without --gateway-bridge re-inherit
-        // the token, including via buildCliEnvPatch's bake from the host's ~/.openclaw config.
-        delete claudeEnv[runtime_1.OPENCLAW_GATEWAY_TOKEN_ENV];
-        // Data-plane sidecar control token: never the engine's to hold (secure-obo-design §7.6).
-        delete claudeEnv['AGENTHIPPO_DATA_PLANE_TOKEN'];
-        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). In
-        // multi-tenant serve, additionally key it by the verified request user — the same
-        // §8 Phase 0 scoping codex.ts applies to CODEX_HOME. A shared per-agent dir lets
-        // concurrent turns of different users race each other's per-turn credential state
-        // (the agentpack/paths.ts race); per-user scoping makes any remaining race
-        // same-user. No credential frame (IDE, single-tenant CLI) ⇒ unchanged path.
-        const claudeConfigDir = (0, agentpack_1.userScopedEngineHome)(runtimePaths.claudeConfigDir, (0, credential_context_1.currentCredential)()?.userId);
-        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. URL servers carry a
-            // `${NAME}` bearer reference the CLI expands from claudeEnv at connect time, so the
-            // turn nonce rides neither a shared config file nor the SDK's --mcp-config argv —
-            // claudeEnv is passed for the rare non-expandable-name fallback only.
-            const mcpServers = await this.loadMcpServersForClaude(logger, options.workspaceRoot, agentId, claudeEnv);
-            // 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 ${(0, branding_1.toSettingsDisplayKey)('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 — including HTTP Streamable
-     * servers (`{type:'http', url, headers}`). A URL server's `bearerTokenEnv` (e.g.
-     * AGENTHIPPO_TURN_NONCE) becomes a `${NAME}` reference the CLI expands from its own env,
-     * NOT a resolved header: the SDK serializes mcpServers into `--mcp-config` argv, and a
-     * resolved bearer there is world-readable via /proc/<pid>/cmdline (see
-     * referenceHttpMcpHeaders). `turnEnv` is the per-turn child env, used only for the
-     * fallback when a name is outside the CLI's expansion grammar.
-     */
-    async loadMcpServersForClaude(logger, workspaceRoot, agentId = 'default', turnEnv) {
-        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) {
-            if (s.url) {
-                const headers = (0, mcp_1.referenceHttpMcpHeaders)(s, turnEnv ?? process.env);
-                mcpServers[s.name] = {
-                    type: 'http',
-                    url: s.url,
-                    ...(headers ? { headers } : {}),
-                };
-                continue;
-            }
-            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;