@exreve/exk 1.0.53 → 1.0.55

package/dist/agentSession.js

@@ -1,1455 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { execSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
-import { symlink as fsSymlink } from 'fs';
-import { getSkillContent } from './skills/index.js';
-import { isLocalModel, unwrapModelName, startOpenAIAdapter, getAdapterConfig } from './openaiAdapter.js';
-import { createModuleMcpServer } from './moduleMcpServer.js';
-import path from 'path';
-import os from 'os';
-import { createRequire } from 'module';
-import { promisify } from 'util';
-// ============ Session State Persistence ============
-// Persists claudeSessionId to disk so context survives CLI restarts.
-// Files are stored in ~/.talk-to-code/session-state/<sessionId>.json
-const SESSION_STATE_DIR = path.join(os.homedir(), '.talk-to-code', 'session-state');
-function sessionStatePath(sessionId) {
-    return path.join(SESSION_STATE_DIR, `${sessionId}.json`);
-}
-function saveSessionState(sessionId, state) {
-    try {
-        if (!existsSync(SESSION_STATE_DIR)) {
-            mkdirSync(SESSION_STATE_DIR, { recursive: true });
-        }
-        writeFileSync(sessionStatePath(sessionId), JSON.stringify(state, null, 2));
-    }
-    catch (err) {
-        console.error(`[AgentSessionManager] Failed to persist session state for ${sessionId}:`, err);
-    }
-}
-function loadSessionState(sessionId) {
-    try {
-        const filePath = sessionStatePath(sessionId);
-        if (!existsSync(filePath))
-            return null;
-        const data = JSON.parse(readFileSync(filePath, 'utf-8'));
-        if (data && typeof data.claudeSessionId === 'string' && data.claudeSessionId) {
-            return data;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function deleteSessionState(sessionId) {
-    try {
-        const filePath = sessionStatePath(sessionId);
-        if (existsSync(filePath))
-            unlinkSync(filePath);
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-}
-/**
- * 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
-/**
- * Detect tool name from the shape of tool_use_result.
- *
- * Uses discriminating keys from the SDK's own type definitions
- * (sdk-tools.d.ts: BashOutput, GrepOutput, GlobOutput, FileReadOutput,
- *  FileEditOutput, FileWriteOutput, TodoWriteOutput, etc.)
- */
-function extractToolName(toolResult) {
-    if (!toolResult || typeof toolResult !== 'object')
-        return 'unknown';
-    // ── Read (FileReadOutput): {type: 'text'|'image'|'notebook'|'pdf'|'parts'|'file_unchanged', file: {...}}
-    if (toolResult.file && typeof toolResult.file === 'object'
-        && ['text', 'image', 'notebook', 'pdf', 'parts', 'file_unchanged'].includes(toolResult.type)) {
-        return 'Read';
-    }
-    // ── Edit (FileEditOutput): {filePath, oldString, newString, structuredPatch}
-    if (toolResult.filePath && toolResult.oldString !== undefined && toolResult.newString !== undefined
-        && Array.isArray(toolResult.structuredPatch)) {
-        return 'Edit';
-    }
-    // ── Write (FileWriteOutput): {type: 'create'|'update', filePath, content, structuredPatch}
-    if (toolResult.filePath && (toolResult.type === 'create' || toolResult.type === 'update')
-        && toolResult.content !== undefined) {
-        return 'Write';
-    }
-    // ── Grep (GrepOutput): {mode, numFiles, filenames, content?, numLines?}
-    if (typeof toolResult.numFiles === 'number' && Array.isArray(toolResult.filenames)
-        && toolResult.mode !== undefined) {
-        return 'Grep';
-    }
-    // ── Glob (GlobOutput): {durationMs, numFiles, filenames, truncated}
-    if (typeof toolResult.numFiles === 'number' && Array.isArray(toolResult.filenames)
-        && typeof toolResult.durationMs === 'number' && toolResult.truncated !== undefined) {
-        return 'Glob';
-    }
-    // ── TodoWrite (TodoWriteOutput): {oldTodos, newTodos}
-    if (Array.isArray(toolResult.oldTodos) && Array.isArray(toolResult.newTodos)) {
-        return 'TodoWrite';
-    }
-    // ── Bash (BashOutput): {stdout, stderr, interrupted, ...}
-    if (toolResult.stdout !== undefined || toolResult.stderr !== undefined) {
-        return 'Bash';
-    }
-    // ── WebSearch (WebSearchOutput): {query, results}
-    if (typeof toolResult.query === 'string' && Array.isArray(toolResult.results)) {
-        return 'WebSearch';
-    }
-    // ── WebFetch (WebFetchOutput): {url, result, code, bytes}
-    if (typeof toolResult.url === 'string' && typeof toolResult.result === 'string'
-        && typeof toolResult.code === 'number') {
-        return 'WebFetch';
-    }
-    // ── send_file (custom MCP tool): content is JSON with _type marker
-    if (toolResult.content && typeof toolResult.content === 'string' && toolResult.type === 'text') {
-        try {
-            const parsed = JSON.parse(toolResult.content);
-            if (parsed._type === 'send_file')
-                return 'send_file';
-        }
-        catch { /* not JSON, fall through */ }
-        // SDK 0.2.x: content-only results from nested tool calls (no stdout/stderr wrapper)
-        return 'Bash';
-    }
-    // ── Agent/Task output: {agentId, content, status}
-    if (toolResult.agentId && Array.isArray(toolResult.content) && toolResult.status) {
-        return 'Task';
-    }
-    return 'unknown';
-}
-// Look up tool name from the most recent assistant message's tool_use blocks by tool_use_id
-function lookupToolNameFromHistory(messages, toolUseId) {
-    if (!toolUseId)
-        return null;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role !== 'assistant')
-            continue;
-        // msg.content is the SDK message object: {role: 'assistant', content: [{type: 'text',...}, {type: 'tool_use',...}]}
-        let content = typeof msg.content === 'string' ? null : msg.content;
-        // Unwrap nested content: {content: [...]} → [...]
-        if (content && !Array.isArray(content) && Array.isArray(content.content)) {
-            content = content.content;
-        }
-        if (!Array.isArray(content))
-            continue;
-        const toolUse = content.find((c) => c.type === 'tool_use' && c.id === toolUseId);
-        if (toolUse?.name)
-            return toolUse.name;
-    }
-    return null;
-}
-// 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';
-/** TTL cache for ai-config.json reads to avoid hitting disk on every call */
-let _aiConfigCache = null;
-const AI_CONFIG_TTL_MS = 5_000;
-const PROVIDERS = {
-    zai: {
-        apiKey: process.env.ZHIPU_API_KEY || '',
-        baseUrl: process.env.CLI_AI_BASE_URL || 'https://api.z.ai/api/anthropic',
-        models: ['glm-5.1', 'glm-4.7', 'glm-4.5-air'],
-    },
-    minimax: {
-        apiKey: '', // Populated from ai-config.json (served by backend)
-        baseUrl: 'https://api.minimax.io/anthropic',
-        models: ['MiniMax-M2.7', 'MiniMax-M2.7-highspeed'],
-    },
-    openrouter: {
-        apiKey: '', // Populated from ai-config.json openrouterApiKey (served by backend)
-        baseUrl: 'https://openrouter.ai/api',
-        models: ['gpt-oss-120b:cerebras'],
-    },
-};
-/** Resolve which provider to use based on model name or explicit provider ID.
- *  1. Populate provider API keys from ai-config.json (served by backend).
- *  2. If explicit providerId is given and has an API key configured, use that provider.
- *  3. Else if model name matches one of a provider's model list, use that provider.
- *  4. Else fall back to zai (default). */
-function resolveProvider(model, providerId) {
-    // Populate provider keys from ai-config.json
-    const aiConfig = loadAiConfig();
-    PROVIDERS.minimax.apiKey = aiConfig.minimaxApiKey || process.env.MINIMAX_API_KEY || '';
-    PROVIDERS.openrouter.apiKey = aiConfig.openrouterApiKey || process.env.OPENROUTER_API_KEY || '';
-    if (!PROVIDERS.zai.apiKey)
-        PROVIDERS.zai.apiKey = aiConfig.apiKey || '';
-    // 1. Explicit provider selection
-    if (providerId && PROVIDERS[providerId]?.apiKey) {
-        const provider = PROVIDERS[providerId];
-        return { provider: providerId, apiKey: provider.apiKey, baseUrl: provider.baseUrl, model };
-    }
-    // 2. Match model name to a provider
-    for (const [id, config] of Object.entries(PROVIDERS)) {
-        if (config.models.includes(model) && config.apiKey) {
-            return { provider: id, apiKey: config.apiKey, baseUrl: config.baseUrl, model };
-        }
-    }
-    // 3. Fallback: use ai-config.json credentials (z.ai default)
-    return {
-        provider: 'zai',
-        apiKey: aiConfig.apiKey,
-        baseUrl: aiConfig.baseUrl || PROVIDERS.zai.baseUrl,
-        model,
-    };
-}
-function loadAiConfig() {
-    const now = Date.now();
-    if (_aiConfigCache && (now - _aiConfigCache.ts) < AI_CONFIG_TTL_MS) {
-        return _aiConfigCache.data;
-    }
-    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;
-        const proxy = typeof config.proxy === 'string' ? config.proxy.trim() : '';
-        const minimaxApiKey = typeof config.minimaxApiKey === 'string' ? config.minimaxApiKey.trim() : '';
-        const openrouterApiKey = typeof config.openrouterApiKey === 'string' ? config.openrouterApiKey.trim() : '';
-        const result = { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
-        _aiConfigCache = { data: result, ts: now };
-        return result;
-    }
-    catch {
-        const fallback = { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
-        _aiConfigCache = { data: fallback, ts: now };
-        return fallback;
-    }
-}
-/** Get OpenRouter API key from ai-config.json (served by backend) */
-export function getOpenrouterApiKey() {
-    return loadAiConfig().openrouterApiKey || process.env.OPENROUTER_API_KEY || '';
-}
-/** Get the backend API URL from config file */
-export function getApiUrl() {
-    const configPath = path.join(os.homedir(), '.talk-to-code', 'config.json');
-    try {
-        const data = readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(data);
-        return config.apiUrl || 'https://api.talk-to-code.com';
-    }
-    catch {
-        return process.env.API_URL || 'https://api.talk-to-code.com';
-    }
-}
-/** Create (or reuse) an empty directory to use as CLAUDE_CONFIG_DIR.
- *  Setting this prevents the spawned Claude CLI from reading ~/.claude/settings.json,
- *  which may contain env.ANTHROPIC_BASE_URL pointing to z.ai and would override our
- *  carefully configured base URL. */
-function getEmptyConfigDir() {
-    const configDir = path.join(os.homedir(), '.talk-to-code', 'empty-config-dir');
-    if (!existsSync(configDir)) {
-        mkdirSync(configDir, { recursive: true });
-    }
-    return configDir;
-}
-const PROXY_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'proxy.json');
-/** Read proxy toggle state from disk (synchronous) */
-function readProxyToggle() {
-    try {
-        const data = readFileSync(PROXY_CONFIG_PATH, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return { enabled: false };
-    }
-}
-/** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from provider or ai-config.
- *  If a local model is provided, override baseUrl to point to the anthropic-proxy adapter.
- *  If resolvedProvider is provided, use its credentials instead of ai-config defaults. */
-function envForClaudeCodeChild(_localModel, resolvedProvider) {
-    const env = { ...process.env };
-    // Strip any host ANTHROPIC_* vars to prevent leaking credentials or wrong URLs
-    delete env.ANTHROPIC_API_KEY;
-    delete env.ANTHROPIC_BASE_URL;
-    delete env.ANTHROPIC_AUTH_TOKEN;
-    // Also strip model alias env vars to prevent stale overrides
-    delete env.ANTHROPIC_MODEL;
-    delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
-    delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
-    delete env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
-    // Determine credentials: use resolvedProvider if provided, else ai-config defaults
-    const { apiKey, baseUrl, proxy } = loadAiConfig();
-    const effectiveApiKey = resolvedProvider?.apiKey || apiKey;
-    const effectiveBaseUrl = resolvedProvider?.baseUrl || baseUrl;
-    if (effectiveApiKey)
-        env.ANTHROPIC_API_KEY = effectiveApiKey;
-    if (effectiveBaseUrl)
-        env.ANTHROPIC_BASE_URL = effectiveBaseUrl;
-    // For MiniMax specifically: override ALL model aliases so the SDK
-    // sends the correct model ID to the Anthropic-compatible endpoint
-    if (resolvedProvider?.provider === 'minimax') {
-        env.ANTHROPIC_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_SONNET_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_OPUS_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolvedProvider.model;
-        env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
-    }
-    // For OpenRouter specifically: override ALL model aliases so the SDK
-    // sends the correct model ID to the Anthropic-compatible endpoint
-    if (resolvedProvider?.provider === 'openrouter') {
-        env.ANTHROPIC_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_SONNET_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_OPUS_MODEL = resolvedProvider.model;
-        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolvedProvider.model;
-        env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
-    }
-    // Apply proxy if enabled
-    const proxyToggle = readProxyToggle();
-    if (proxyToggle.enabled && proxy) {
-        env.HTTPS_PROXY = proxy;
-        env.HTTP_PROXY = proxy;
-    }
-    else {
-        // Clear any inherited proxy env
-        delete env.HTTPS_PROXY;
-        delete env.HTTP_PROXY;
-        delete env.https_proxy;
-        delete env.http_proxy;
-    }
-    // Prevent ~/.claude/settings.json env section from overriding our base URL.
-    // This redirects the Claude config dir to an empty dir so that
-    // ~/.claude/settings.json (which may have ANTHROPIC_BASE_URL set to z.ai)
-    // is never read during the CLI process initialization.
-    env.CLAUDE_CONFIG_DIR = getEmptyConfigDir();
-    return env;
-}
-/** Get env overrides for a local model (adapter proxy URL + dummy key). Returns null if not a local model. */
-async function getLocalModelEnvOverrides(model) {
-    if (!isLocalModel(model))
-        return null;
-    const adapterConfig = getAdapterConfig(model);
-    if (!adapterConfig)
-        return null;
-    const proxyUrl = await startOpenAIAdapter({
-        targetBaseUrl: adapterConfig.targetBaseUrl,
-        model: unwrapModelName(model),
-        apiKey: adapterConfig.apiKey,
-    });
-    return { baseUrl: proxyUrl, apiKey: 'local-no-key-needed' };
-}
-// 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
-    socketRef = null; // Socket.IO reference for fetching session history from backend
-    /** Set the socket reference for backend communication (called from app-child.ts) */
-    setSocketRef(socket) {
-        this.socketRef = socket;
-    }
-    /**
-     * Fetch conversation history from the backend DB for a session.
-     * Returns array of { role, content } pairs (user prompts + assistant responses).
-     */
-    async fetchSessionHistory(sessionId) {
-        return new Promise((resolve) => {
-            if (!this.socketRef?.connected) {
-                console.log(`[AgentSessionManager] Cannot fetch history: socket not connected`);
-                resolve([]);
-                return;
-            }
-            const timeoutId = setTimeout(() => {
-                console.warn(`[AgentSessionManager] fetchSessionHistory timed out for ${sessionId}`);
-                resolve([]);
-            }, 5000);
-            this.socketRef.emit('session:history', { sessionId }, (response) => {
-                clearTimeout(timeoutId);
-                if (response?.history && Array.isArray(response.history)) {
-                    console.log(`[AgentSessionManager] Fetched ${response.history.length} history entries for session ${sessionId}`);
-                    resolve(response.history);
-                }
-                else {
-                    resolve([]);
-                }
-            });
-        });
-    }
-    /**
-     * Format conversation history into a text block for injection into a prompt.
-     * Takes the last N exchanges to avoid token overflow.
-     */
-    formatHistoryForPrompt(history) {
-        if (!history.length)
-            return '';
-        // Take last N entries to stay within reasonable token limits
-        const maxEntries = 40;
-        const trimmed = history.slice(-maxEntries);
-        const lines = trimmed.map(m => {
-            const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-            // Truncate very long individual messages
-            const maxLen = 2000;
-            const truncated = content.length > maxLen
-                ? content.slice(0, maxLen) + '...[truncated]'
-                : content;
-            return `<${m.role}>\n${truncated}\n</${m.role}>`;
-        });
-        return [
-            '[Previous Conversation Context]',
-            'The following is conversation history from this session that was lost due to a session reset.',
-            'Use it as context for the current request.',
-            '',
-            '<conversation>',
-            ...lines,
-            '</conversation>',
-            '',
-            '[End of Previous Context]',
-            '',
-            '',
-        ].join('\n');
-    }
-    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 mutable fields
-        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;
-            }
-            // Update enabled modules and settings if provided
-            // Ensure abort controller is fresh for new queries
-            existingSession.abortController = new AbortController();
-            // Update handler reference
-            this.sessionHandlers.set(sessionId, handler);
-            return;
-        }
-        // Store the handler for this session
-        this.sessionHandlers.set(sessionId, handler);
-        const abortController = new AbortController();
-        // Restore claudeSessionId from disk (survives CLI restart)
-        const persistedState = loadSessionState(sessionId);
-        const restoredClaudeSessionId = persistedState?.claudeSessionId;
-        if (restoredClaudeSessionId) {
-            console.log(`[AgentSessionManager] Restored claudeSessionId for session ${sessionId}: ${restoredClaudeSessionId}`);
-        }
-        this.sessions.set(sessionId, {
-            abortController,
-            messages: [],
-            totalInputTokens: 0,
-            totalOutputTokens: 0,
-            totalCostUsd: 0,
-            promptQueue: [],
-            isProcessingQueue: false,
-            claudeSessionId: restoredClaudeSessionId, // Restored from disk or undefined
-            childProcesses: new Set(),
-            claudeProcessGroupId: undefined,
-            currentPromptId: undefined,
-            model: sessionModel,
-        });
-        // Auto-regenerate CLAUDE.md for fresh project context
-        await this.regenerateClaudeMd(projectPath);
-    }
-    /**
-     * Regenerate CLAUDE.md for fresh project context
-     */
-    async regenerateClaudeMd(projectPath) {
-        try {
-            const scriptPath = path.join(projectPath, 'scripts', 'generate-claude-md.js');
-            if (existsSync(scriptPath)) {
-                execSync(`node "${scriptPath}"`, { cwd: projectPath, stdio: 'ignore' });
-            }
-        }
-        catch (error) {
-            // Don't fail session if CLAUDE.md generation fails
-            console.error('[AgentSessionManager] Failed to regenerate CLAUDE.md:', error);
-        }
-    }
-    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;
-        }
-        // 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
-            attachments: handler.attachments // Pass attachments through
-        });
-        // Start processing queue if not already processing
-        if (!session.isProcessingQueue) {
-            this.processPromptQueue(sessionId);
-        }
-        else if (session.isProcessingQueue && !session.activeQueryStream && !this.emergencyStopInProgress.has(sessionId)) {
-            // Safety: isProcessingQueue is true but there's no active stream and no emergency stop
-            // This means the queue got stuck (e.g. from a previous abort return that bypassed cleanup)
-            console.warn(`[agentSession] Queue stuck detected for session ${sessionId}, resetting isProcessingQueue`);
-            session.isProcessingQueue = false;
-            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 { enhancers, handler, promptId: queuedPromptId, abortController: queuedAbortController } = queuedPrompt;
-            const { projectPath, promptId, onOutput: _onOutput, onError: _onError, onComplete: _onComplete, onStatusUpdate } = handler;
-            const onOutput = _onOutput;
-            const onError = _onError;
-            const onComplete = _onComplete;
-            // Write attachments to temp dir and inject paths into prompt
-            let effectivePrompt = queuedPrompt.prompt;
-            let attachmentDir;
-            if (queuedPrompt.attachments && queuedPrompt.attachments.length > 0) {
-                attachmentDir = path.join(os.tmpdir(), 'talk-to-code', 'attachments', sessionId, String(promptId || Date.now()));
-                mkdirSync(attachmentDir, { recursive: true });
-                const attachmentLines = [];
-                for (const att of queuedPrompt.attachments) {
-                    const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, '_');
-                    const filePath = path.join(attachmentDir, safeName);
-                    const buf = Buffer.from(att.content, 'base64');
-                    writeFileSync(filePath, buf);
-                    attachmentLines.push(`- ${safeName} (${att.mimeType}): path="${filePath}"`);
-                }
-                effectivePrompt += `\n\n[Attachments]\nThe following files are attached and available on disk. Use the analyze_image tool to examine images.\n${attachmentLines.join('\n')}`;
-                console.log(`[agentSession] Wrote ${queuedPrompt.attachments.length} attachment(s) to ${attachmentDir}`);
-            }
-            try {
-                // Verify promptId is present in handler
-                if (!promptId) {
-                    console.error(`[agentSession] Missing promptId in handler for prompt: ${queuedPrompt.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');
-                // Wait for current query to finish before starting next prompt
-                if (session.activeQueryStream !== undefined) {
-                    try {
-                        for await (const _ of session.activeQueryStream) { }
-                    }
-                    catch (err) {
-                        console.error(`[AgentSession] Error draining active query stream:`, err);
-                    }
-                    session.activeQueryStream = undefined;
-                }
-                session.activeQueryStream = undefined;
-                // Build final prompt with enhancers
-                let finalPrompt = effectivePrompt;
-                if (enhancers && enhancers.length > 0) {
-                    const skillContent = getSkillContent(enhancers);
-                    if (skillContent) {
-                        finalPrompt = `${skillContent}\n\n${effectivePrompt}`;
-                    }
-                }
-                // Inject DB history if context was lost in a previous prompt (resume failed)
-                if (session.contextLost) {
-                    console.log(`[agentSession] Context was lost previously, fetching DB history for session ${sessionId}`);
-                    try {
-                        const history = await this.fetchSessionHistory(sessionId);
-                        if (history.length > 0) {
-                            const historyPrefix = this.formatHistoryForPrompt(history);
-                            finalPrompt = historyPrefix + finalPrompt;
-                            console.log(`[agentSession] Injected ${history.length} history entries into prompt for session ${sessionId}`);
-                        }
-                        else {
-                            console.log(`[agentSession] No DB history available for session ${sessionId}`);
-                        }
-                    }
-                    catch (err) {
-                        console.error(`[agentSession] Failed to fetch/format history:`, err);
-                    }
-                    session.contextLost = false; // Reset after injection attempt
-                }
-                // 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;
-                // 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', 'analyze_image'], // Disable built-in analyze_image (we provide our own via MCP)
-                    settingSources: ['project'], // Enable CLAUDE.md loading
-                    permissionMode: 'bypassPermissions',
-                    allowDangerouslySkipPermissions: true,
-                    // Create a fresh MCP server for each query call (SDK connects transport internally, cannot reuse)
-                    ...(() => {
-                        const mcpServer = this.buildMcpServer(sessionId, attachmentDir, promptId);
-                        return { mcpServers: { 'claude-voice-modules': mcpServer } };
-                    })(),
-                    ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
-                    spawnClaudeCodeProcess: (spawnOptions) => {
-                        const { command, args, cwd: cwd2, env, signal } = spawnOptions;
-                        // Debug: log what env/args are being passed to Claude process
-                        console.log(`[agentSession] Spawn ANTHROPIC_BASE_URL:`, env?.ANTHROPIC_BASE_URL || '(not set)');
-                        console.log(`[agentSession] Spawn ANTHROPIC_API_KEY:`, env?.ANTHROPIC_API_KEY ? '(set)' : '(not set)');
-                        console.log(`[agentSession] Spawn args:`, args?.join(' '));
-                        // 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 (err) {
-                            console.error(`[AgentSession] Failed to create working directory ${cwd2}:`, err);
-                        }
-                        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: {
-                        // HookCallbackMatcher format: each entry must be { hooks: [callback] }
-                        // NOT a raw callback array — wrong format silently breaks MCP server registration.
-                        PostToolUse: [{
-                                hooks: [(_toolResult) => {
-                                        // Tool result is handled by the user message handler below
-                                        return { continue: true };
-                                    }]
-                            }],
-                        Notification: [{
-                                hooks: [(notification) => {
-                                        onOutput({
-                                            type: 'progress',
-                                            data: notification,
-                                            timestamp: Date.now(),
-                                            metadata: {
-                                                progress: {
-                                                    message: typeof notification === 'string' ? notification : JSON.stringify(notification)
-                                                }
-                                            }
-                                        });
-                                        return { continue: true };
-                                    }]
-                            }],
-                    }
-                };
-                // Log model being used for debugging
-                const sessionModel = session.model || CLAUDE_CONFIG.model;
-                // Resolve local model adapter overrides (if using OpenAI-compatible endpoint)
-                let effectiveModel = sessionModel;
-                let effectiveApiKey = queryOptions.apiKey;
-                let effectiveEnv = queryOptions.env;
-                let effectiveSettings;
-                const localOverrides = await getLocalModelEnvOverrides(sessionModel);
-                if (localOverrides) {
-                    effectiveModel = unwrapModelName(sessionModel);
-                    effectiveApiKey = localOverrides.apiKey;
-                    effectiveEnv = {
-                        ...effectiveEnv,
-                        ANTHROPIC_API_KEY: localOverrides.apiKey,
-                        ANTHROPIC_BASE_URL: localOverrides.baseUrl,
-                    };
-                    // Override settings to prevent ~/.claude/settings.json env from overriding our proxy URL.
-                    // Claude Code CLI reads settings.json → env section and applies those on top of spawn env,
-                    // which would replace our ANTHROPIC_BASE_URL with the z.ai URL.
-                    effectiveSettings = { env: { ANTHROPIC_API_KEY: localOverrides.apiKey, ANTHROPIC_BASE_URL: localOverrides.baseUrl } };
-                    console.log(`[agentSession] Using local model adapter: ${sessionModel} -> ${localOverrides.baseUrl}`);
-                    console.log(`[agentSession] effectiveSettings for local model:`, JSON.stringify(effectiveSettings));
-                }
-                else {
-                    // Resolve provider for multi-provider switching (Z.ai / MiniMax)
-                    const resolved = resolveProvider(sessionModel);
-                    console.log(`[agentSession] Resolved provider: ${resolved.provider} for model: ${sessionModel}`);
-                    effectiveApiKey = resolved.apiKey;
-                    effectiveEnv = envForClaudeCodeChild(undefined, resolved);
-                    // Build settings env to prevent ~/.claude/settings.json from overriding our credentials
-                    const settingsEnv = {
-                        ANTHROPIC_API_KEY: resolved.apiKey,
-                        ANTHROPIC_BASE_URL: resolved.baseUrl,
-                    };
-                    // For MiniMax: also override all model aliases in settings
-                    if (resolved.provider === 'minimax') {
-                        settingsEnv.ANTHROPIC_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolved.model;
-                        settingsEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
-                    }
-                    // For OpenRouter: also override all model aliases in settings
-                    if (resolved.provider === 'openrouter') {
-                        settingsEnv.ANTHROPIC_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = resolved.model;
-                        settingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolved.model;
-                        settingsEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
-                    }
-                    effectiveSettings = { env: settingsEnv };
-                    console.log(`[agentSession] Provider: ${resolved.provider}, baseUrl: ${resolved.baseUrl}, model: ${resolved.model}`);
-                }
-                // 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: finalPrompt,
-                    options: {
-                        ...queryOptions,
-                        apiKey: effectiveApiKey,
-                        model: effectiveModel,
-                        env: effectiveEnv,
-                        ...(effectiveSettings ? { settings: effectiveSettings } : {}),
-                        ...(session.claudeSessionId && !localOverrides && (() => {
-                            // Don't resume if provider changed since last session (context format may differ)
-                            const persisted = loadSessionState(sessionId);
-                            const currentProvider = resolveProvider(sessionModel).provider;
-                            return persisted?.provider === currentProvider;
-                        })() ? { resume: session.claudeSessionId } : {})
-                        // Note: don't resume session for local models - context format differs
-                        // Note: also don't resume if provider differs from persisted session provider (context format may differ)
-                    }
-                });
-                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) {
-                                // Detect context loss: session_id changed unexpectedly (resume failed)
-                                if (session.claudeSessionId && session.claudeSessionId !== systemMsg.session_id) {
-                                    session.contextLost = true;
-                                    console.warn(`[AgentSessionManager] Context lost! Session ID changed: ${session.claudeSessionId} → ${systemMsg.session_id}`);
-                                }
-                                session.claudeSessionId = systemMsg.session_id;
-                                saveSessionState(sessionId, { claudeSessionId: systemMsg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
-                            }
-                        }
-                        if (message.type === 'assistant') {
-                            const msg = message;
-                            // Capture Claude session ID from assistant message (always update to track session changes)
-                            if (msg.session_id) {
-                                if (session.claudeSessionId && session.claudeSessionId !== msg.session_id) {
-                                    session.contextLost = true;
-                                    console.warn(`[AgentSessionManager] Context lost! Session ID changed in assistant msg: ${session.claudeSessionId} → ${msg.session_id}`);
-                                }
-                                session.claudeSessionId = msg.session_id;
-                                saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
-                            }
-                            session.messages.push({
-                                role: 'assistant',
-                                content: msg.message,
-                                timestamp: Date.now()
-                            });
-                            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
-                                };
-                            }
-                            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,
-                                    durationApiMs: msg.duration_api_ms,
-                                    totalCostUsd: msg.total_cost_usd,
-                                    usage: msg.usage,
-                                    modelUsage: msg.modelUsage,
-                                    structuredOutput: msg.structured_output,
-                                    numTurns: msg.num_turns,
-                                    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;
-                            break; // Prompt complete, continue to next in queue
-                        }
-                        else if (message.type === 'user') {
-                            const msg = message;
-                            // SDK sends tool results with TWO data sources:
-                            //   message.content[0]  — {type:'tool_result', tool_use_id:'...', content: <raw text>}
-                            //   msg.tool_use_result  — structured object with {stdout,stderr} for Bash,
-                            //                          {type,file} for Read, or [{type:'text',text:'...'}] for MCP tools
-                            //
-                            // The tool_use_id lives ONLY in message.content[].tool_use_id.
-                            // The structured result lives in tool_use_result for built-in tools.
-                            // For MCP tools, tool_use_result is a content-block array we need to parse.
-                            let toolResult = null;
-                            let toolUseId = msg.parent_tool_use_id;
-                            // STEP 1: Always extract tool_use_id from message.content (authoritative source)
-                            if (Array.isArray(msg.message?.content)) {
-                                const contentBlocks = msg.message.content;
-                                const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
-                                if (toolResultBlock?.tool_use_id) {
-                                    toolUseId = toolResultBlock.tool_use_id;
-                                }
-                            }
-                            // STEP 2: Use tool_use_result as the primary data source.
-                            // For built-in tools (Bash, Read, Edit, Write, Glob, Grep) it's a structured
-                            // object like {stdout, stderr} or {type:'text', file:{...}} — use directly.
-                            // For MCP tools it's a content-block array [{type:'text', text:'...'}] — parse text.
-                            if (msg.tool_use_result) {
-                                const raw = msg.tool_use_result;
-                                if (Array.isArray(raw)) {
-                                    // MCP tool result: [{type:'text', text:'...'}] — extract and parse
-                                    const textParts = raw
-                                        .filter((c) => c.type === 'text')
-                                        .map((c) => c.text);
-                                    const rawContent = textParts.join('\n');
-                                    try {
-                                        toolResult = JSON.parse(rawContent);
-                                    }
-                                    catch {
-                                        toolResult = { content: rawContent, type: 'text' };
-                                    }
-                                }
-                                else if (typeof raw === 'object' && raw !== null) {
-                                    // Built-in tool result: {stdout, stderr, ...} or {type, file, ...} — use directly
-                                    toolResult = raw;
-                                }
-                                else if (typeof raw === 'string') {
-                                    try {
-                                        toolResult = JSON.parse(raw);
-                                    }
-                                    catch {
-                                        toolResult = { content: raw, type: 'text' };
-                                    }
-                                }
-                            }
-                            // STEP 3: Fallback to parsing message.content if tool_use_result wasn't available
-                            // (e.g. subagent calls where tool_use_result may be absent)
-                            if (!toolResult && Array.isArray(msg.message?.content)) {
-                                const contentBlocks = msg.message.content;
-                                const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
-                                if (toolResultBlock) {
-                                    if (typeof toolResultBlock.content === 'string') {
-                                        try {
-                                            toolResult = JSON.parse(toolResultBlock.content);
-                                        }
-                                        catch {
-                                            toolResult = { content: toolResultBlock.content, type: 'text' };
-                                        }
-                                    }
-                                    else if (Array.isArray(toolResultBlock.content)) {
-                                        const textParts = toolResultBlock.content
-                                            .filter((c) => c.type === 'text')
-                                            .map((c) => c.text);
-                                        const rawContent = textParts.join('\n');
-                                        try {
-                                            toolResult = JSON.parse(rawContent);
-                                        }
-                                        catch {
-                                            toolResult = { content: rawContent, type: 'text' };
-                                        }
-                                    }
-                                    else {
-                                        toolResult = toolResultBlock;
-                                    }
-                                }
-                            }
-                            if (toolResult) {
-                                // History lookup is authoritative: the assistant's tool_use block names the tool.
-                                // Heuristic detection can't distinguish Bash/Grep/Glob/etc (all have {stdout,stderr}).
-                                const historyName = lookupToolNameFromHistory(session.messages, toolUseId);
-                                const detectedName = extractToolName(toolResult);
-                                const resolvedName = historyName || detectedName;
-                                onOutput({
-                                    type: 'tool_result',
-                                    data: toolResult,
-                                    timestamp: Date.now(),
-                                    metadata: {
-                                        toolName: resolvedName,
-                                        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') {
-                            const sysMsg = message;
-                            onOutput({
-                                type: 'system',
-                                data: { ...sysMsg, subtype: sysMsg.subtype },
-                                timestamp: Date.now(),
-                                metadata: {
-                                    subtype: sysMsg.subtype,
-                                    messageType: sysMsg.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 if (message.type === 'tool_use_summary') {
-                            const msg = message;
-                            onOutput({
-                                type: 'tool_use_summary',
-                                data: msg.summary || '',
-                                timestamp: Date.now(),
-                                metadata: {
-                                    precedingToolUseIds: msg.preceding_tool_use_ids,
-                                    uuid: msg.uuid,
-                                    sessionId: msg.session_id
-                                }
-                            });
-                        }
-                        else if (message.type === 'rate_limit_event') {
-                            const msg = message;
-                            onOutput({
-                                type: 'rate_limit_event',
-                                data: msg,
-                                timestamp: Date.now(),
-                                metadata: {
-                                    rateLimitInfo: msg.rate_limit_info,
-                                    uuid: msg.uuid,
-                                    sessionId: msg.session_id
-                                }
-                            });
-                        }
-                        else if (message.type === 'prompt_suggestion') {
-                            const msg = message;
-                            onOutput({
-                                type: 'prompt_suggestion',
-                                data: msg.suggestion || '',
-                                timestamp: Date.now(),
-                                metadata: {
-                                    uuid: msg.uuid,
-                                    sessionId: msg.session_id
-                                }
-                            });
-                        }
-                        else if (message.type === 'keep_alive') {
-                            // Internal keepalive - silently ignore
-                        }
-                        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;
-                        // Use break instead of return to ensure isProcessingQueue gets reset
-                        // after the while loop at the end of processPromptQueue
-                        break;
-                    }
-                    // 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;
-                }
-                // 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);
-        }
-    }
-    async deleteSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.abortController.abort();
-            session.activeQueryStream = undefined;
-            this.sessions.delete(sessionId);
-        }
-        // Clean up persisted state
-        deleteSessionState(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 session-level controller only (not all sessions' controllers)
-            session.abortController.abort();
-            // Abort only controllers belonging to THIS session
-            // Find and abort controllers for prompts in this session's queue and current prompt
-            if (session.currentPromptId) {
-                const ctrl = this.promptAbortControllers.get(session.currentPromptId);
-                if (ctrl)
-                    ctrl.abort();
-            }
-            for (const queued of session.promptQueue) {
-                if (queued.abortController)
-                    queued.abortController.abort();
-                if (queued.promptId) {
-                    const ctrl = this.promptAbortControllers.get(queued.promptId);
-                    if (ctrl)
-                        ctrl.abort();
-                }
-            }
-            // 2. Kill the entire process tree
-            await this.killProcessTree(sessionId);
-            // 3. Collect prompt IDs from queue BEFORE clearing it
-            const queueSize = session.promptQueue.length;
-            const queuedPromptIds = session.promptQueue
-                .map(p => p.promptId)
-                .filter((id) => !!id);
-            const currentPromptId = session.currentPromptId;
-            // 4. Clear the prompt queue
-            session.promptQueue = [];
-            // 5. Clear active stream
-            session.activeQueryStream = undefined;
-            // 6. Reset processing state
-            session.isProcessingQueue = false;
-            // 7. Clean up abort controllers map (only for this session's prompts, not ALL sessions)
-            if (currentPromptId) {
-                this.promptAbortControllers.delete(currentPromptId);
-            }
-            for (const pid of queuedPromptIds) {
-                this.promptAbortControllers.delete(pid);
-            }
-            session.currentPromptId = undefined;
-            // 8. Remove from emergency stop tracking
-            this.emergencyStopInProgress.delete(sessionId);
-            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' };
-        }
-    }
-    /**
-     * Build a fresh MCP server for a query call.
-     * The SDK's query() connects the MCP server's internal transport, so we cannot
-     * reuse a single instance across multiple queries. This must be called fresh each time.
-     */
-    buildMcpServer(sessionId, attachmentDir, promptId) {
-        console.log(`[buildMcpServer] Session ${sessionId}: attachmentDir=${attachmentDir || 'none'}, promptId=${promptId || 'none'}`);
-        return createModuleMcpServer({
-            attachmentDir,
-            sessionId,
-            promptId,
-        });
-    }
-}
-export const agentSessionManager = new AgentSessionManager();