@exreve/exk 1.0.6 → 1.0.8

package/dist/agentSession.js

@@ -0,0 +1,1020 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { symlink as fsSymlink } from 'fs';
+// Memory system removed for performance
+import { getSkillContent } from './skills/index.js';
+import { createModuleMcpServer } from './moduleMcpServer.js';
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+import { promisify } from 'util';
+/**
+ * Resolve path to the SDK's bundled cli.js.
+ * We resolve this ourselves so it works reliably on Windows when running from
+ * the PS1 install (ttc.cmd -> node ttc.js); the SDK's internal resolution via
+ * import.meta.url can fail or produce wrong paths in that context.
+ * CACHED: Path is resolved once at module load time for performance.
+ */
+function resolveSdkCliPath() {
+    try {
+        const req = typeof globalThis.require === 'function'
+            ? globalThis.require
+            : createRequire(import.meta.url);
+        const pkgPath = req.resolve('@anthropic-ai/claude-agent-sdk/package.json');
+        const cliPath = path.join(path.dirname(pkgPath), 'cli.js');
+        return existsSync(cliPath) ? cliPath : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Cache the resolved Claude executable path at module load time
+const CACHED_CLAUDE_PATH = (() => {
+    const envPath = process.env.TTC_CLAUDE_PATH;
+    if (envPath)
+        return envPath;
+    const sdkPath = resolveSdkCliPath();
+    if (sdkPath)
+        return sdkPath;
+    const localPath = path.join(os.homedir(), '.local', 'bin', 'claude');
+    if (existsSync(localPath))
+        return localPath;
+    return undefined;
+})();
+// Promisify symlink for async use
+const symlinkAsync = promisify(fsSymlink);
+// Helper function to extract tool name from result structure
+function extractToolName(toolResult) {
+    if (toolResult.name)
+        return toolResult.name;
+    if (toolResult.type === 'text' && toolResult.file)
+        return 'Read';
+    if (toolResult.file_path || toolResult.filePath) {
+        return (toolResult.content !== undefined || toolResult.type === 'create') ? 'Write' : 'Read';
+    }
+    if (toolResult.stdout !== undefined || toolResult.stderr !== undefined)
+        return 'Bash';
+    return 'unknown';
+}
+// AI config - loaded from server after registration, stored in ~/.talk-to-code/ai-config.json
+// (Do not read ANTHROPIC_* / CLAUDE_MODEL from the host environment — only this file + code default model.)
+const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
+const DEFAULT_AI_MODEL = 'glm-5.1';
+function loadAiConfig() {
+    try {
+        const data = readFileSync(AI_CONFIG_PATH, 'utf-8');
+        const config = JSON.parse(data);
+        const apiKey = typeof config.authToken === 'string' ? config.authToken.trim() : '';
+        const baseUrl = typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
+        const model = typeof config.model === 'string' && config.model.trim() ? config.model.trim() : DEFAULT_AI_MODEL;
+        return { apiKey, baseUrl, model };
+    }
+    catch {
+        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL };
+    }
+}
+/** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from ai-config only. */
+function envForClaudeCodeChild() {
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_BASE_URL;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    const { apiKey, baseUrl } = loadAiConfig();
+    if (apiKey)
+        env.ANTHROPIC_API_KEY = apiKey;
+    if (baseUrl)
+        env.ANTHROPIC_BASE_URL = baseUrl;
+    return env;
+}
+// Lazy config getter - reloads from file each time (so daemon picks up changes without restart)
+const CLAUDE_CONFIG = {
+    get apiKey() { return loadAiConfig().apiKey; },
+    get baseUrl() { return loadAiConfig().baseUrl; },
+    get model() { return loadAiConfig().model; },
+};
+export class AgentSessionManager {
+    sessions = new Map();
+    promptAbortControllers = new Map(); // Map promptId -> AbortController for cancellation
+    emergencyStopInProgress = new Set(); // Track sessions being emergency stopped
+    sessionHandlers = new Map(); // Track handlers for each session
+    async createSession(handler) {
+        const { sessionId, projectPath, model } = handler;
+        const sessionModel = model || CLAUDE_CONFIG.model;
+        // Ensure project directory exists - prevents ENOENT errors when SDK spawns process
+        if (!existsSync(projectPath)) {
+            try {
+                mkdirSync(projectPath, { recursive: true });
+                console.log(`[AgentSessionManager] Created project directory: ${projectPath}`);
+            }
+            catch (error) {
+                console.error(`[AgentSessionManager] Failed to create project directory ${projectPath}:`, error.message);
+                // Fallback for /home/abc - try to create symlink to /tmp/abc
+                if (projectPath === '/home/abc') {
+                    const fallbackPath = '/tmp/abc';
+                    try {
+                        mkdirSync(fallbackPath, { recursive: true });
+                        await symlinkAsync(fallbackPath, projectPath, 'dir');
+                        console.log(`[AgentSessionManager] Created symlink: ${projectPath} -> ${fallbackPath}`);
+                    }
+                    catch (symlinkError) {
+                        console.log(`[AgentSessionManager] Symlink creation failed: ${symlinkError.message}`);
+                    }
+                }
+            }
+        }
+        // If session already exists, update the model if provided
+        if (this.sessions.has(sessionId)) {
+            const existingSession = this.sessions.get(sessionId);
+            // Update model if a new one is provided
+            if (model && model !== existingSession.model) {
+                existingSession.model = model;
+                // DISABLED: File logging removed for performance
+                // if (existingSession.logger) {
+                //   await existingSession.logger.info(`Model updated to: ${model}`)
+                // }
+            }
+            // DISABLED: File logging removed for performance
+            // if (existingSession.logger) {
+            //   await existingSession.logger.info('Session already exists, reusing context')
+            // }
+            // Just ensure abort controller is fresh for new queries
+            existingSession.abortController = new AbortController();
+            return;
+        }
+        // DISABLED: File logging removed for performance
+        // const logger = new AgentLogger(sessionId)
+        // await logger.logSessionCreated(projectPath)
+        // await logger.logModelConfig(sessionModel, CLAUDE_CONFIG.baseUrl)
+        const logger = undefined;
+        // Store the handler for this session
+        this.sessionHandlers.set(sessionId, handler);
+        const abortController = new AbortController();
+        // Create MCP server for modules if enabled modules are provided
+        let mcpServer;
+        const enabledModules = handler.enabledModules || [];
+        const moduleSettings = handler.moduleSettings || {};
+        if (enabledModules.length > 0) {
+            mcpServer = createModuleMcpServer({
+                enabledModules,
+                moduleSettings,
+                onChoiceRequest: handler.onChoiceRequest
+                    ? async (request) => {
+                        return new Promise((resolve) => {
+                            const session = this.sessions.get(sessionId);
+                            if (session) {
+                                session.pendingChoice = { request, resolve };
+                                handler.onChoiceRequest(request);
+                            }
+                            else {
+                                resolve({ choiceId: request.choiceId, selectedValue: null });
+                            }
+                        });
+                    }
+                    : undefined
+            });
+            // DISABLED: File logging removed for performance
+            // if (logger) {
+            //   await logger.info(`MCP server created with modules: ${enabledModules.join(', ')}`)
+            // }
+        }
+        this.sessions.set(sessionId, {
+            abortController,
+            messages: [],
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalCostUsd: 0,
+            promptQueue: [],
+            isProcessingQueue: false,
+            claudeSessionId: undefined, // Will be set when Claude SDK returns session ID
+            // logger, // DISABLED: File logging removed for performance
+            // Memory system removed for performance
+            childProcesses: new Set(),
+            claudeProcessGroupId: undefined,
+            currentPromptId: undefined,
+            model: sessionModel,
+            userChoiceEnabled: handler.userChoiceEnabled || false,
+            enabledModules,
+            moduleSettings,
+            mcpServer
+        });
+        // Auto-regenerate CLAUDE.md for fresh project context
+        // DISABLED: File logging removed for performance
+        await this.regenerateClaudeMd(projectPath, undefined);
+    }
+    /**
+     * Regenerate CLAUDE.md for fresh project context
+     */
+    async regenerateClaudeMd(projectPath, logger) {
+        try {
+            const scriptPath = path.join(projectPath, 'scripts', 'generate-claude-md.js');
+            if (existsSync(scriptPath)) {
+                const startTime = Date.now();
+                execSync(`node "${scriptPath}"`, { cwd: projectPath, stdio: 'ignore' });
+                const duration = Date.now() - startTime;
+                if (logger) {
+                    await logger.info(`CLAUDE.md regenerated in ${duration}ms`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail session if CLAUDE.md generation fails
+            console.error('[AgentSessionManager] Failed to regenerate CLAUDE.md:', error);
+        }
+    }
+    // Memory system removed for performance - no loadMemoryContext or storeConversationInMemory
+    async sendPrompt(sessionId, prompt, enhancers = [], handler) {
+        // Ensure session exists
+        if (!this.sessions.has(sessionId)) {
+            await this.createSession(handler);
+        }
+        const session = this.sessions.get(sessionId);
+        // Update session model if provided in handler
+        if (handler.model && handler.model !== session.model) {
+            session.model = handler.model;
+            // DISABLED: File logging removed for performance
+            // if (session.logger) {
+            //   await session.logger.info(`Model updated to: ${handler.model}`)
+            // }
+        }
+        // Add prompt to queue - store promptId for cancellation
+        session.promptQueue.push({
+            prompt,
+            enhancers,
+            handler,
+            timestamp: Date.now(),
+            promptId: handler.promptId,
+            abortController: new AbortController(), // Pre-create for queued cancellation
+            model: handler.model || session.model // Use handler model or fall back to session model
+        });
+        // Start processing queue if not already processing
+        if (!session.isProcessingQueue) {
+            this.processPromptQueue(sessionId);
+        }
+    }
+    async processPromptQueue(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        if (session.isProcessingQueue)
+            return;
+        session.isProcessingQueue = true;
+        while (session.promptQueue.length > 0 && !this.emergencyStopInProgress.has(sessionId)) {
+            const queuedPrompt = session.promptQueue.shift();
+            const { prompt, enhancers, handler, promptId: queuedPromptId, abortController: queuedAbortController } = queuedPrompt;
+            const { projectPath, promptId, onOutput, onError, onComplete, onStatusUpdate } = handler;
+            const promptStartTime = Date.now();
+            try {
+                // Verify promptId is present in handler
+                if (!promptId) {
+                    console.error(`[agentSession] Missing promptId in handler for prompt: ${prompt.substring(0, 50)}...`);
+                    onError?.('Missing promptId in handler');
+                    continue;
+                }
+                // Check if this queued prompt was cancelled before processing started
+                if (queuedAbortController?.signal.aborted) {
+                    console.log(`[agentSession] Queued prompt ${promptId} was cancelled before processing`);
+                    onStatusUpdate?.('cancelled');
+                    onComplete(null);
+                    continue;
+                }
+                // Use the queued promptId and abortController, or fallback to handler values
+                const effectivePromptId = queuedPromptId || promptId;
+                const abortController = queuedAbortController || new AbortController();
+                session.abortController = abortController;
+                session.currentPromptId = effectivePromptId; // Track current prompt for emergency stop
+                this.promptAbortControllers.set(effectivePromptId, abortController);
+                // Emit status update: CLI is starting to process the prompt (IMMEDIATELY)
+                // This ensures real-time status updates before any async operations
+                onStatusUpdate?.('running');
+                // DISABLED: File logging removed for performance
+                // // Log prompt start
+                // if (session.logger) {
+                //   await session.logger.logPromptStart(prompt, projectPath)
+                // }
+                // Wait for current query to finish before starting next prompt
+                // REMOVED: 200ms artificial delay - stream draining is sufficient
+                if (session.activeQueryStream !== undefined) {
+                    try {
+                        for await (const _ of session.activeQueryStream) { }
+                    }
+                    catch { }
+                    // REMOVED: await new Promise(resolve => setTimeout(resolve, 200))
+                    session.activeQueryStream = undefined;
+                }
+                session.activeQueryStream = undefined;
+                // Build final prompt with enhancers
+                let finalPrompt = prompt;
+                if (enhancers && enhancers.length > 0) {
+                    const skillContent = getSkillContent(enhancers);
+                    if (skillContent) {
+                        finalPrompt = `${skillContent}\n\n${prompt}`;
+                        // DISABLED: File logging removed for performance
+                        // // Log that enhancers are being used
+                        // if (session.logger) {
+                        //   await session.logger.info(`Using enhancers: ${enhancers.join(', ')}`)
+                        // }
+                    }
+                }
+                // Add user message to history
+                session.messages.push({
+                    role: 'user',
+                    content: finalPrompt,
+                    timestamp: Date.now()
+                });
+                // Emit context info
+                onOutput({
+                    type: 'system',
+                    data: {
+                        message: `Context: ${session.messages.length} messages, ${session.totalInputTokens + session.totalOutputTokens} total tokens`,
+                        contextInfo: {
+                            messageCount: session.messages.length,
+                            totalInputTokens: session.totalInputTokens,
+                            totalOutputTokens: session.totalOutputTokens,
+                            totalTokens: session.totalInputTokens + session.totalOutputTokens,
+                            totalCostUsd: session.totalCostUsd,
+                            lastUsage: session.lastUsage
+                        }
+                    },
+                    timestamp: Date.now(),
+                    metadata: {
+                        subtype: 'context_info',
+                        contextSize: session.messages.length,
+                        totalTokens: session.totalInputTokens + session.totalOutputTokens
+                    }
+                });
+                // Use cached Claude executable path (resolved at module load time for performance)
+                const pathToClaudeCodeExecutable = CACHED_CLAUDE_PATH;
+                // DISABLED: File logging removed for performance
+                // if (session.logger) {
+                //   if (pathToClaudeCodeExecutable) {
+                //     session.logger.info(`Using Claude (cli.js): ${pathToClaudeCodeExecutable}`).catch(() => {})
+                //   } else {
+                //     session.logger.info('Using SDK built-in Claude (cli.js)').catch(() => {})
+                //   }
+                // }
+                // Build query options - include abort signal for cancellation
+                const queryOptions = {
+                    signal: abortController.signal, // Pass abort signal to SDK for interruption
+                    cwd: projectPath,
+                    apiKey: CLAUDE_CONFIG.apiKey,
+                    model: CLAUDE_CONFIG.model,
+                    tools: { type: 'preset', preset: 'claude_code' },
+                    disallowedTools: ['AskUserQuestion'],
+                    settingSources: ['project'], // Enable CLAUDE.md loading
+                    permissionMode: 'bypassPermissions',
+                    allowDangerouslySkipPermissions: true,
+                    // Add MCP server for modules if configured
+                    ...(session.mcpServer ? { mcpServers: [session.mcpServer] } : {}),
+                    ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
+                    spawnClaudeCodeProcess: (spawnOptions) => {
+                        const { command, args, cwd: cwd2, env, signal } = spawnOptions;
+                        // Only check file existence when command is a path (not a bare name like "claude" from PATH)
+                        const hasPathSep = command.includes(path.sep) || command.includes('/') || command.includes('\\');
+                        if (hasPathSep && !existsSync(command)) {
+                            throw new Error(`Executable not found at ${command}. Set path with: ttc config --claude-path "<path>" (or TTC_CLAUDE_PATH)`);
+                        }
+                        try {
+                            if (cwd2 && !existsSync(cwd2)) {
+                                mkdirSync(cwd2, { recursive: true });
+                            }
+                        }
+                        catch { }
+                        const isWin = process.platform === 'win32';
+                        // Ensure PATH includes common node locations, especially in containers
+                        const defaultPath = isWin
+                            ? (process.env.Path || process.env.PATH || '')
+                            : '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+                        const spawnEnv = {
+                            ...env,
+                            PATH: env.PATH || process.env.PATH || defaultPath,
+                            ...(isWin
+                                ? {
+                                    USERPROFILE: env.USERPROFILE || process.env.USERPROFILE || os.homedir(),
+                                    USERNAME: env.USERNAME || process.env.USERNAME || 'user',
+                                    HOME: env.USERPROFILE || process.env.USERPROFILE || os.homedir(), // Windows: use Windows home, not /home/user
+                                }
+                                : { HOME: env.HOME || process.env.HOME || os.homedir(), USER: env.USER || process.env.USER || 'user' }),
+                        };
+                        // If command is 'node' and not found, try to resolve it
+                        if (command === 'node' && !hasPathSep) {
+                            try {
+                                const nodePath = execSync('which node', { encoding: 'utf-8', env: spawnEnv }).trim();
+                                if (nodePath) {
+                                    const child = spawn(nodePath, args, {
+                                        cwd: cwd2 || process.cwd(),
+                                        stdio: ["pipe", "pipe", env.DEBUG_CLAUDE_AGENT_SDK ? "pipe" : "ignore"],
+                                        signal,
+                                        env: spawnEnv,
+                                        windowsHide: true,
+                                        detached: !isWin // Create process group on Unix for tree-killing
+                                    });
+                                    // Track child process for force-kill
+                                    if (!session.childProcesses)
+                                        session.childProcesses = new Set();
+                                    session.childProcesses.add(child);
+                                    // Store process group ID for Unix (negative PID kills entire group)
+                                    if (!isWin && child.pid) {
+                                        session.claudeProcessGroupId = child.pid;
+                                    }
+                                    // Clean up when process exits
+                                    child.on('exit', () => {
+                                        session.childProcesses.delete(child);
+                                    });
+                                    child.on('error', () => {
+                                        session.childProcesses.delete(child);
+                                    });
+                                    return child;
+                                }
+                            }
+                            catch {
+                                // Fall through to original spawn
+                            }
+                        }
+                        const child = spawn(command, args, {
+                            cwd: cwd2 || process.cwd(),
+                            stdio: ["pipe", "pipe", env.DEBUG_CLAUDE_AGENT_SDK ? "pipe" : "ignore"],
+                            signal,
+                            env: spawnEnv,
+                            windowsHide: true,
+                            detached: !isWin // Create process group on Unix for tree-killing
+                        });
+                        // Track child process for force-kill
+                        if (!session.childProcesses)
+                            session.childProcesses = new Set();
+                        session.childProcesses.add(child);
+                        // Store process group ID for Unix (negative PID kills entire group)
+                        if (!isWin && child.pid) {
+                            session.claudeProcessGroupId = child.pid;
+                        }
+                        // Clean up when process exits
+                        child.on('exit', () => {
+                            session.childProcesses.delete(child);
+                        });
+                        child.on('error', () => {
+                            session.childProcesses.delete(child);
+                        });
+                        return child;
+                    },
+                    env: envForClaudeCodeChild(),
+                    hooks: {
+                        // PostToolUse hook DISABLED for tool_result emission.
+                        // tool_result events are already emitted via the user message handler (line ~752)
+                        // which correctly extracts toolUseId from the SDK's user message structure.
+                        // Sending duplicate events from here caused:
+                        // 1. Frontend merging conflicts (two results for same tool)
+                        // 2. Tools stuck showing "Running..." when the second event fails to merge
+                        // 3. Missing toolUseId in hook events (not always available here)
+                        PostToolUse: [(_toolResult) => {
+                                // Tool result is handled by the user message handler below
+                            }],
+                        Notification: [(notification) => {
+                                onOutput({
+                                    type: 'progress',
+                                    data: notification,
+                                    timestamp: Date.now(),
+                                    metadata: {
+                                        progress: {
+                                            message: typeof notification === 'string' ? notification : JSON.stringify(notification)
+                                        }
+                                    }
+                                });
+                            }]
+                    }
+                };
+                // Log model being used for debugging
+                const sessionModel = session.model || CLAUDE_CONFIG.model;
+                // DISABLED: File logging removed for performance
+                // if (session.logger) {
+                //   await session.logger.logModelConfig(sessionModel, CLAUDE_CONFIG.baseUrl)
+                // }
+                // Create query stream - resume session if we have a Claude session ID
+                // Always explicitly set model even when resuming to ensure we use the session's model
+                const queryStream = query({
+                    prompt,
+                    options: {
+                        ...queryOptions,
+                        model: sessionModel, // Use session-specific model (supports switching between prompts)
+                        ...(session.claudeSessionId ? { resume: session.claudeSessionId } : {})
+                    }
+                });
+                session.activeQueryStream = queryStream;
+                // Process messages with enhanced abort checking
+                // Create a wrapped stream that checks abort status more frequently
+                const abortCheckInterval = 200; // Check every 200ms
+                let lastAbortCheck = Date.now();
+                try {
+                    for await (const message of queryStream) {
+                        // Check abort on each message (existing behavior)
+                        if (session.abortController.signal.aborted || this.emergencyStopInProgress.has(sessionId)) {
+                            console.log(`[agentSession] Aborting prompt ${effectivePromptId} - abort signal received`);
+                            break;
+                        }
+                        // Periodic check for long-running operations
+                        const now = Date.now();
+                        if (now - lastAbortCheck > abortCheckInterval) {
+                            lastAbortCheck = now;
+                            if (session.abortController.signal.aborted || this.emergencyStopInProgress.has(sessionId)) {
+                                console.log(`[agentSession] Aborting prompt ${effectivePromptId} - periodic check detected abort`);
+                                break;
+                            }
+                        }
+                        // Capture Claude SDK session ID from system init message
+                        if (message.type === 'system' && message.subtype === 'init') {
+                            const systemMsg = message;
+                            if (systemMsg.session_id && !session.claudeSessionId) {
+                                session.claudeSessionId = systemMsg.session_id;
+                                // DISABLED: File logging removed for performance
+                                // if (session.logger) {
+                                //   await session.logger.logClaudeSessionId(systemMsg.session_id)
+                                // }
+                            }
+                        }
+                        if (message.type === 'assistant') {
+                            const msg = message;
+                            // Capture Claude session ID from assistant message if not already set
+                            if (msg.session_id && !session.claudeSessionId) {
+                                session.claudeSessionId = msg.session_id;
+                                // DISABLED: File logging removed for performance
+                                // if (session.logger) {
+                                //   await session.logger.logClaudeSessionId(msg.session_id)
+                                // }
+                            }
+                            session.messages.push({
+                                role: 'assistant',
+                                content: msg.message,
+                                timestamp: Date.now()
+                            });
+                            // DISABLED: File logging removed for performance
+                            // // Log agent response
+                            // const responseText = typeof msg.message === 'string' ? msg.message : JSON.stringify(msg.message)
+                            // if (session.logger) {
+                            //   await session.logger.logAgentResponse(responseText, {
+                            //     uuid: msg.uuid,
+                            //     sessionId: msg.session_id,
+                            //     error: msg.error,
+                            //     contextSize: session.messages.length
+                            //   })
+                            // }
+                            onOutput({
+                                type: 'assistant',
+                                data: msg.message,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    parentToolUseId: msg.parent_tool_use_id,
+                                    uuid: msg.uuid,
+                                    sessionId: msg.session_id,
+                                    error: msg.error,
+                                    contextSize: session.messages.length
+                                }
+                            });
+                        }
+                        else if (message.type === 'result') {
+                            const msg = message;
+                            // Update usage tracking
+                            if (msg.usage) {
+                                const usage = msg.usage;
+                                const inputTokens = usage.input_tokens || usage.inputTokens || 0;
+                                const outputTokens = usage.output_tokens || usage.outputTokens || 0;
+                                session.totalInputTokens += inputTokens;
+                                session.totalOutputTokens += outputTokens;
+                                session.totalCostUsd += msg.total_cost_usd || 0;
+                                session.lastUsage = {
+                                    inputTokens,
+                                    outputTokens,
+                                    totalTokens: inputTokens + outputTokens
+                                };
+                                // DISABLED: File logging removed for performance
+                                // // Log token usage
+                                // if (session.logger) {
+                                //   await session.logger.logTokenUsage({
+                                //     inputTokens: session.totalInputTokens,
+                                //     outputTokens: session.totalOutputTokens,
+                                //     totalTokens: session.totalInputTokens + session.totalOutputTokens,
+                                //     costUsd: session.totalCostUsd
+                                //   })
+                                // }
+                            }
+                            const promptDuration = Date.now() - promptStartTime;
+                            // DISABLED: File logging removed for performance
+                            // // Log prompt completion
+                            // if (session.logger) {
+                            //   await session.logger.logPromptEnd(
+                            //     msg.is_error ? 1 : 0,
+                            //     promptDuration,
+                            //     session.lastUsage ? {
+                            //       inputTokens: session.lastUsage.inputTokens,
+                            //       outputTokens: session.lastUsage.outputTokens,
+                            //       costUsd: msg.total_cost_usd || 0
+                            //     } : undefined
+                            //   )
+                            // }
+                            onOutput({
+                                type: 'result',
+                                data: msg,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    subtype: msg.subtype,
+                                    isError: msg.is_error,
+                                    exitCode: msg.is_error ? 1 : 0,
+                                    durationMs: msg.duration_ms,
+                                    totalCostUsd: msg.total_cost_usd,
+                                    usage: msg.usage,
+                                    contextInfo: {
+                                        messageCount: session.messages.length,
+                                        totalInputTokens: session.totalInputTokens,
+                                        totalOutputTokens: session.totalOutputTokens,
+                                        totalTokens: session.totalInputTokens + session.totalOutputTokens,
+                                        totalCostUsd: session.totalCostUsd,
+                                        lastUsage: session.lastUsage
+                                    }
+                                }
+                            });
+                            // Emit status update: CLI finished processing (real-time)
+                            const exitCode = msg.is_error ? 1 : 0;
+                            // Clean up abort controller
+                            this.promptAbortControllers.delete(promptId);
+                            // Update status immediately based on exit code
+                            onStatusUpdate?.(exitCode === 0 ? 'completed' : 'error');
+                            onComplete(exitCode);
+                            session.activeQueryStream = undefined;
+                            // Memory system removed for performance
+                            break; // Prompt complete, continue to next in queue
+                        }
+                        else if (message.type === 'user') {
+                            const msg = message;
+                            if (msg.tool_use_result) {
+                                const toolResult = msg.tool_use_result;
+                                let toolUseId = msg.parent_tool_use_id;
+                                if (!toolUseId && Array.isArray(msg.message.content)) {
+                                    const toolResultContent = msg.message.content.find((c) => c.type === 'tool_result' && c.tool_use_id);
+                                    toolUseId = toolResultContent?.tool_use_id || null;
+                                }
+                                onOutput({
+                                    type: 'tool_result',
+                                    data: toolResult,
+                                    timestamp: Date.now(),
+                                    metadata: {
+                                        toolName: extractToolName(toolResult),
+                                        toolResult: toolResult,
+                                        toolUseId: toolUseId || undefined,
+                                        parentToolUseId: msg.parent_tool_use_id,
+                                        isSynthetic: msg.isSynthetic
+                                    }
+                                });
+                            }
+                            else {
+                                onOutput({
+                                    type: 'user',
+                                    data: msg.message,
+                                    timestamp: Date.now(),
+                                    metadata: {
+                                        parentToolUseId: null,
+                                        isSynthetic: msg.isSynthetic
+                                    }
+                                });
+                            }
+                        }
+                        else if (message.type === 'system') {
+                            onOutput({
+                                type: 'system',
+                                data: message,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    subtype: message.subtype,
+                                    messageType: message.subtype || 'system'
+                                }
+                            });
+                        }
+                        else if (message.type === 'tool_progress') {
+                            const msg = message;
+                            onOutput({
+                                type: 'tool_progress',
+                                data: msg,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    toolName: msg.tool_name,
+                                    toolUseId: msg.tool_use_id,
+                                    elapsedTimeSeconds: msg.elapsed_time_seconds,
+                                    parentToolUseId: msg.parent_tool_use_id
+                                }
+                            });
+                        }
+                        else if (message.type === 'auth_status') {
+                            onOutput({
+                                type: 'auth_status',
+                                data: message,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    isAuthenticating: message.isAuthenticating,
+                                    error: message.error
+                                }
+                            });
+                        }
+                        else if (message.type === 'stream_event') {
+                            onOutput({
+                                type: 'stream_event',
+                                data: message.event || message,
+                                timestamp: Date.now(),
+                                metadata: {
+                                    parentToolUseId: message.parent_tool_use_id
+                                }
+                            });
+                        }
+                        else {
+                            onOutput({
+                                type: 'stdout',
+                                data: JSON.stringify(message, null, 2),
+                                timestamp: Date.now()
+                            });
+                        }
+                    }
+                }
+                catch (streamError) {
+                    // Check if this was an abort-related error
+                    if (session.abortController.signal.aborted || this.emergencyStopInProgress.has(sessionId)) {
+                        console.log(`[agentSession] Stream aborted for prompt ${effectivePromptId}`);
+                        // Handle abort gracefully
+                        onStatusUpdate?.('cancelled');
+                        onComplete(null);
+                        session.activeQueryStream = undefined;
+                        session.currentPromptId = undefined;
+                        return;
+                    }
+                    // Re-throw non-abort errors
+                    throw streamError;
+                }
+                session.activeQueryStream = undefined;
+                session.currentPromptId = undefined; // Clear current prompt when done
+            }
+            catch (error) {
+                const currentSession = this.sessions.get(sessionId);
+                if (currentSession) {
+                    currentSession.activeQueryStream = undefined;
+                    // DISABLED: File logging removed for performance
+                    // // Log error
+                    // if (currentSession.logger) {
+                    //   await currentSession.logger.logSessionError(error, {
+                    //     prompt: prompt.substring(0, 200),
+                    //     projectPath
+                    //   })
+                    // }
+                }
+                // Clean up abort controller (promptId is guaranteed to exist here due to check at line 204)
+                if (promptId) {
+                    this.promptAbortControllers.delete(promptId);
+                }
+                // Emit status update: CLI encountered an error (real-time)
+                onStatusUpdate?.('error');
+                onError(error.message || 'Unknown error');
+                onComplete(null);
+            }
+        }
+        session.isProcessingQueue = false;
+        // Continue processing queue if more prompts are waiting
+        if (session.promptQueue.length > 0) {
+            this.processPromptQueue(sessionId);
+        }
+    }
+    getContextInfo(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        return {
+            messageCount: session.messages.length,
+            totalInputTokens: session.totalInputTokens,
+            totalOutputTokens: session.totalOutputTokens,
+            totalTokens: session.totalInputTokens + session.totalOutputTokens,
+            totalCostUsd: session.totalCostUsd,
+            lastUsage: session.lastUsage
+        };
+    }
+    clearContext(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.messages = [];
+            session.totalInputTokens = 0;
+            session.totalOutputTokens = 0;
+            session.totalCostUsd = 0;
+            // Clear Claude session ID to start fresh
+            session.claudeSessionId = undefined;
+            session.lastUsage = undefined;
+        }
+    }
+    async deleteSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.abortController.abort();
+            session.activeQueryStream = undefined;
+            this.sessions.delete(sessionId);
+        }
+    }
+    /**
+     * Cancel a running or queued prompt by promptId
+     */
+    async cancelPrompt(promptId, sessionId, onStatusUpdate) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false; // Session not found
+        }
+        // First, check if prompt is in the queue (not yet started)
+        const queuedIndex = session.promptQueue.findIndex(p => p.promptId === promptId);
+        if (queuedIndex !== -1) {
+            // Found in queue - abort it and remove from queue
+            const queuedPrompt = session.promptQueue[queuedIndex];
+            if (queuedPrompt.abortController) {
+                queuedPrompt.abortController.abort();
+            }
+            // Remove from queue
+            session.promptQueue.splice(queuedIndex, 1);
+            // Emit status update: prompt was cancelled (real-time)
+            onStatusUpdate?.('cancelled');
+            console.log(`[agentSession] Cancelled queued prompt: ${promptId}`);
+            return true;
+        }
+        // Not in queue, check if it's currently running
+        const abortController = this.promptAbortControllers.get(promptId);
+        if (!abortController) {
+            return false; // Prompt not found or already completed
+        }
+        // Abort the running prompt
+        abortController.abort();
+        // Clean up
+        this.promptAbortControllers.delete(promptId);
+        // Emit status update: prompt was cancelled (real-time)
+        onStatusUpdate?.('cancelled');
+        console.log(`[agentSession] Cancelled running prompt: ${promptId}`);
+        return true;
+    }
+    /**
+     * Kill the entire process tree for a session (including grandchildren)
+     * Uses process group killing on Unix-like systems
+     */
+    async killProcessTree(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        const isWin = process.platform === 'win32';
+        // 1. Kill all tracked child processes
+        if (session.childProcesses && session.childProcesses.size > 0) {
+            console.log(`[agentSession] Killing ${session.childProcesses.size} tracked child processes`);
+            for (const child of session.childProcesses) {
+                if (!child.killed) {
+                    try {
+                        if (isWin) {
+                            // Windows: use taskkill to force kill
+                            if (child.pid) {
+                                spawn('taskkill', ['/pid', child.pid.toString(), '/f', '/t'], {
+                                    stdio: 'ignore',
+                                    windowsHide: true
+                                });
+                            }
+                        }
+                        else {
+                            // Unix: try graceful SIGTERM first, then SIGKILL
+                            child.kill('SIGTERM');
+                        }
+                    }
+                    catch (e) {
+                        // Process may already be dead
+                    }
+                }
+            }
+            // Wait a bit for graceful shutdown, then force kill
+            await new Promise(resolve => setTimeout(resolve, 500));
+            for (const child of session.childProcesses) {
+                if (!child.killed) {
+                    try {
+                        if (!isWin && child.pid) {
+                            // Unix: force kill with SIGKILL
+                            child.kill('SIGKILL');
+                        }
+                    }
+                    catch (e) {
+                        // Already dead
+                    }
+                }
+            }
+            session.childProcesses.clear();
+        }
+        // 2. Kill the entire process group on Unix-like systems
+        if (!isWin && session.claudeProcessGroupId) {
+            try {
+                console.log(`[agentSession] Killing process group ${session.claudeProcessGroupId}`);
+                // Kill entire process group using negative PID
+                process.kill(-session.claudeProcessGroupId, 'SIGKILL');
+            }
+            catch (e) {
+                // Process group may already be dead
+            }
+            session.claudeProcessGroupId = undefined;
+        }
+    }
+    /**
+     * Emergency stop - immediately halt all activity in a session
+     * This is a forceful stop that kills all processes and clears state
+     */
+    async emergencyStop(sessionId) {
+        // Prevent concurrent emergency stops
+        if (this.emergencyStopInProgress.has(sessionId)) {
+            return { success: false, message: 'Emergency stop already in progress' };
+        }
+        this.emergencyStopInProgress.add(sessionId);
+        console.log(`[agentSession] EMERGENCY STOP triggered for session ${sessionId}`);
+        try {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return { success: false, message: 'Session not found' };
+            }
+            // 1. Abort all controllers (session level + all prompt-level)
+            session.abortController.abort();
+            for (const controller of this.promptAbortControllers.values()) {
+                controller.abort();
+            }
+            // 2. Kill the entire process tree
+            await this.killProcessTree(sessionId);
+            // 3. Clear the prompt queue
+            const queueSize = session.promptQueue.length;
+            session.promptQueue = [];
+            // 4. Clear active stream
+            session.activeQueryStream = undefined;
+            // 5. Reset processing state
+            session.isProcessingQueue = false;
+            // 6. Clear current prompt tracking
+            const currentPromptId = session.currentPromptId;
+            // 7. Clean up abort controllers map
+            this.promptAbortControllers.clear();
+            // 8. Remove from emergency stop tracking
+            this.emergencyStopInProgress.delete(sessionId);
+            // 9. Resolve any pending choice request with null (cancelled)
+            if (session.pendingChoice) {
+                session.pendingChoice.resolve({ choiceId: session.pendingChoice.request.choiceId, selectedValue: null });
+                session.pendingChoice = undefined;
+            }
+            const message = currentPromptId
+                ? `Emergency stop: Cancelled prompt '${currentPromptId}' and cleared ${queueSize} queued prompts`
+                : `Emergency stop: Cleared ${queueSize} queued prompts`;
+            console.log(`[agentSession] ${message}`);
+            return { success: true, message };
+        }
+        catch (error) {
+            this.emergencyStopInProgress.delete(sessionId);
+            console.error(`[agentSession] Emergency stop error:`, error);
+            return { success: false, message: error.message || 'Emergency stop failed' };
+        }
+    }
+    /**
+     * Handle user choice response from frontend
+     */
+    async handleChoiceResponse(sessionId, response) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.error(`[agentSession] Session ${sessionId} not found for choice response`);
+            return;
+        }
+        if (!session.pendingChoice) {
+            console.warn(`[agentSession] No pending choice for session ${sessionId}`);
+            return;
+        }
+        if (session.pendingChoice.request.choiceId !== response.choiceId) {
+            console.warn(`[agentSession] Choice ID mismatch: expected ${session.pendingChoice.request.choiceId}, got ${response.choiceId}`);
+            return;
+        }
+        // Resolve the pending choice promise
+        session.pendingChoice.resolve(response);
+        session.pendingChoice = undefined;
+    }
+    /**
+     * Request user choice during agent execution
+     */
+    async requestUserChoice(sessionId, request) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Check if user choice is enabled for this session
+        if (!session.userChoiceEnabled) {
+            throw new Error('User choice is not enabled for this session');
+        }
+        // Create a promise that will be resolved when the user responds
+        return new Promise((resolve) => {
+            session.pendingChoice = { request, resolve };
+            // Emit the choice request through the onOutput callback
+            // This will be picked up by the CLI and sent to the frontend
+            const handler = this.sessionHandlers.get(sessionId);
+            if (handler?.onChoiceRequest) {
+                handler.onChoiceRequest(request);
+            }
+            // Set timeout if specified
+            if (request.timeout) {
+                setTimeout(() => {
+                    if (session.pendingChoice?.request.choiceId === request.choiceId) {
+                        session.pendingChoice.resolve({ choiceId: request.choiceId, selectedValue: null });
+                        session.pendingChoice = undefined;
+                    }
+                }, request.timeout);
+            }
+        });
+    }
+}
+export const agentSessionManager = new AgentSessionManager();