@exreve/exk 1.0.0

package/agentSession.ts

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