@exreve/exk 1.0.51 → 1.0.52

package/dist/cli/agentSession.js

@@ -0,0 +1,1456 @@
+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';
+    const r = toolResult;
+    // ── Read (FileReadOutput): {type: 'text'|'image'|'notebook'|'pdf'|'parts'|'file_unchanged', file: {...}}
+    if (r.file && typeof r.file === 'object'
+        && ['text', 'image', 'notebook', 'pdf', 'parts', 'file_unchanged'].includes(r.type)) {
+        return 'Read';
+    }
+    // ── Edit (FileEditOutput): {filePath, oldString, newString, structuredPatch}
+    if (r.filePath && r.oldString !== undefined && r.newString !== undefined
+        && Array.isArray(r.structuredPatch)) {
+        return 'Edit';
+    }
+    // ── Write (FileWriteOutput): {type: 'create'|'update', filePath, content, structuredPatch}
+    if (r.filePath && (r.type === 'create' || r.type === 'update')
+        && r.content !== undefined) {
+        return 'Write';
+    }
+    // ── Grep (GrepOutput): {mode, numFiles, filenames, content?, numLines?}
+    if (typeof r.numFiles === 'number' && Array.isArray(r.filenames)
+        && r.mode !== undefined) {
+        return 'Grep';
+    }
+    // ── Glob (GlobOutput): {durationMs, numFiles, filenames, truncated}
+    if (typeof r.numFiles === 'number' && Array.isArray(r.filenames)
+        && typeof r.durationMs === 'number' && r.truncated !== undefined) {
+        return 'Glob';
+    }
+    // ── TodoWrite (TodoWriteOutput): {oldTodos, newTodos}
+    if (Array.isArray(r.oldTodos) && Array.isArray(r.newTodos)) {
+        return 'TodoWrite';
+    }
+    // ── Bash (BashOutput): {stdout, stderr, interrupted, ...}
+    if (r.stdout !== undefined || r.stderr !== undefined) {
+        return 'Bash';
+    }
+    // ── WebSearch (WebSearchOutput): {query, results}
+    if (typeof r.query === 'string' && Array.isArray(r.results)) {
+        return 'WebSearch';
+    }
+    // ── WebFetch (WebFetchOutput): {url, result, code, bytes}
+    if (typeof r.url === 'string' && typeof r.result === 'string'
+        && typeof r.code === 'number') {
+        return 'WebFetch';
+    }
+    // ── send_file (custom MCP tool): content is JSON with _type marker
+    if (r.content && typeof r.content === 'string' && r.type === 'text') {
+        try {
+            const parsed = JSON.parse(r.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 (r.agentId && Array.isArray(r.content) && r.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();