@xagent-ai/cli 1.2.2 → 1.3.0

package/src/session.ts

@@ -4,16 +4,28 @@ import https from 'https';
 import axios from 'axios';
 import crypto from 'crypto';
 import ora from 'ora';
-import inquirer from 'inquirer';
 import { createRequire } from 'module';
-import { dirname, join } from 'path';
+import path from 'path';
 import { fileURLToPath } from 'url';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import os from 'os';
 
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
-import { ExecutionMode, ChatMessage, ToolCall, AuthType } from './types.js';
-import { AIClient, Message, detectThinkingKeywords, getThinkingTokens } from './ai-client.js';
-import { RemoteAIClient, TokenInvalidError } from './remote-ai-client.js';
+import {
+  ExecutionMode,
+  ChatMessage,
+  ToolCall,
+  AuthType,
+  AuthConfig,
+  AgentConfig,
+  ToolCallItem,
+} from './types.js';
+import { createAIClient, type AIClientInterface } from './ai-client-factory.js';
+import { detectThinkingKeywords, getThinkingTokens } from './ai-client/types.js';
+import { TokenInvalidError } from './ai-client/types.js';
+import { fetchDefaultModels } from './ai-client/providers/remote.js';
 import { getConfigManager, ConfigManager } from './config.js';
 import { AuthService, selectAuthType } from './auth.js';
 import { getToolRegistry } from './tools.js';
@@ -25,10 +37,28 @@ import { getConversationManager, ConversationManager } from './conversation.js';
 import { getSessionManager, SessionManager } from './session-manager.js';
 import { SlashCommandHandler, parseInput, detectImageInput } from './slash-commands.js';
 import { SystemPromptGenerator } from './system-prompt-generator.js';
-import { theme, icons, colors, styleHelpers, renderMarkdown, renderDiff, renderLines, TERMINAL_BG } from './theme.js';
+import {
+  theme,
+  icons,
+  colors,
+  styleHelpers,
+  renderMarkdown,
+  renderDiff,
+  renderLines,
+  TERMINAL_BG,
+} from './theme.js';
 import { getCancellationManager, CancellationManager } from './cancellation.js';
-import { getContextCompressor, ContextCompressor, CompressionResult } from './context-compressor.js';
+import {
+  getContextCompressor,
+  ContextCompressor,
+  CompressionResult,
+} from './context-compressor.js';
 import { Logger, LogLevel, getLogger } from './logger.js';
+import { ensureTtySane, setupEscKeyHandler } from './terminal.js';
+
+// Type aliases for backward compatibility
+type AIClient = AIClientInterface;
+type RemoteAIClient = AIClientInterface;
 
 const logger = getLogger();
 
@@ -39,7 +69,7 @@ export class InteractiveSession {
   private aiClient: AIClient | null = null;
   private remoteAIClient: RemoteAIClient | null = null;
   private conversation: ChatMessage[] = [];
-  private toolCalls: ToolCall[] = [];
+  private tool_calls: ToolCall[] = [];
   private executionMode: ExecutionMode;
   private slashCommandHandler: SlashCommandHandler;
   private configManager: ConfigManager;
@@ -47,7 +77,7 @@ export class InteractiveSession {
   private memoryManager: MemoryManager;
   private mcpManager: MCPManager;
   private checkpointManager: CheckpointManager;
-  private currentAgent: any = null;
+  private currentAgent: AgentConfig | null = null;
   private rl: readline.Interface;
   private cancellationManager: CancellationManager;
   private indentLevel: number;
@@ -57,67 +87,51 @@ export class InteractiveSession {
   private taskCompleted: boolean = false;
   private isFirstApiCall: boolean = true;
 
-    constructor(indentLevel: number = 0) {
-
-      this.rl = readline.createInterface({
-
-        input: process.stdin,
-
-        output: process.stdout
-
-      });
-
-  
-
-      this.configManager = getConfigManager(process.cwd());
-
-      this.agentManager = getAgentManager(process.cwd());
-
-      this.memoryManager = getMemoryManager(process.cwd());
-
-      this.mcpManager = getMCPManager();
-
-      this.checkpointManager = getCheckpointManager(process.cwd());
-
-      this.conversationManager = getConversationManager();
-
-      this.sessionManager = getSessionManager(process.cwd());
-
-      this.slashCommandHandler = new SlashCommandHandler();
-
-      // Register /clear callback, clear local conversation when clearing dialogue
-      this.slashCommandHandler.setClearCallback(() => {
-        this.conversation = [];
-        this.toolCalls = [];
-        this.currentTaskId = null;
-        this.taskCompleted = false;
-        this.isFirstApiCall = true;
-        this.slashCommandHandler.setConversationHistory([]);
-      });
-
-  
-
-      // Register MCP update callback, update system prompt
-
-      this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
-
-        await this.updateSystemPrompt();
+  constructor(indentLevel: number = 0) {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
 
-      });
+    this.configManager = getConfigManager(process.cwd());
+    this.agentManager = getAgentManager(process.cwd());
+    this.memoryManager = getMemoryManager(process.cwd());
+    this.mcpManager = getMCPManager();
+    this.checkpointManager = getCheckpointManager(process.cwd());
+    this.conversationManager = getConversationManager();
+    this.sessionManager = getSessionManager(process.cwd());
+    this.slashCommandHandler = new SlashCommandHandler();
+
+    // Register /clear callback, clear local conversation when clearing dialogue
+    this.slashCommandHandler.setClearCallback(() => {
+      this.conversation = [];
+      this.tool_calls = [];
+      this.currentTaskId = null;
+      this.taskCompleted = false;
+      this.isFirstApiCall = true;
+      this.slashCommandHandler.setConversationHistory([]);
+    });
 
-  
+    // Register MCP update callback, update system prompt
+    this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
+      await this.updateSystemPrompt();
+    });
 
-      this.executionMode = ExecutionMode.DEFAULT;
+    // Register config update callback, update aiClient config when /auth changes config
+    this.slashCommandHandler.setConfigUpdateCallback(() => {
+      this.updateAiClientConfig();
+    });
 
-      this.cancellationManager = getCancellationManager();
+    this.executionMode = ExecutionMode.DEFAULT;
 
-      this.indentLevel = indentLevel;
+    this.cancellationManager = getCancellationManager();
 
-      this.indentString = ' '.repeat(indentLevel);
+    this.indentLevel = indentLevel;
 
-      this.contextCompressor = getContextCompressor();
+    this.indentString = ' '.repeat(indentLevel);
 
-    }
+    this.contextCompressor = getContextCompressor();
+  }
 
   private getIndent(): string {
     return this.indentString;
@@ -127,6 +141,34 @@ export class InteractiveSession {
     this.aiClient = aiClient;
   }
 
+  /**
+   * Update aiClient config when /auth changes config (called from callback)
+   */
+  updateAiClientConfig(): void {
+    const authConfig = this.configManager.getAuthConfig();
+    const isRemote = authConfig.type === AuthType.OAUTH_XAGENT;
+
+    if (isRemote) {
+      // Already in remote mode, no change needed
+      if (this.remoteAIClient !== null) {
+        return;
+      }
+      // Switch to remote: clear local client, create remote client
+      this.aiClient = null;
+      this.remoteAIClient = createAIClient(authConfig);
+    } else {
+      // Already in local mode, no change needed
+      if (this.aiClient !== null) {
+        return;
+      }
+      // Switch to local: clear remote client, create local client
+      this.remoteAIClient = null;
+      this.aiClient = createAIClient(authConfig);
+    }
+
+    this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
+  }
+
   setExecutionMode(mode: ExecutionMode): void {
     this.executionMode = mode;
   }
@@ -135,30 +177,88 @@ export class InteractiveSession {
    * Update system prompt to reflect MCP changes (called after add/remove MCP)
    */
   async updateSystemPrompt(): Promise<void> {
+    // Reload skills to pick up any newly added/removed skills
+    // First reset the SkillLoader to clear all cached skills
+    const { resetSkillLoader } = await import('./skill-loader.js');
+    resetSkillLoader();
+
+    // Then reload the skill invoker
+    const skillInvoker = (await import('./skill-invoker.js')).getSkillInvoker();
+    await skillInvoker.reload();
+
     const toolRegistry = getToolRegistry();
-    const promptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
+    const promptGenerator = new SystemPromptGenerator(
+      toolRegistry,
+      this.executionMode,
+      undefined,
+      this.mcpManager
+    );
 
     // Use the current agent's original system prompt as base
-    const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are xAgent, an AI-powered CLI tool.';
+    const baseSystemPrompt =
+      this.currentAgent?.systemPrompt || 'You are xAgent, an AI-powered CLI tool.';
     const newSystemPrompt = await promptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
 
     // Replace old system prompt with new one
-    this.conversation = this.conversation.filter(msg => msg.role !== 'system');
+    this.conversation = this.conversation.filter((msg) => msg.role !== 'system');
     this.conversation.unshift({
       role: 'system',
       content: newSystemPrompt,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
 
     // Sync to slashCommandHandler
     this.slashCommandHandler.setConversationHistory(this.conversation);
   }
 
-  setAgent(agent: any): void {
+  /**
+   * Watch for skill updates from CLI and update system prompt accordingly
+   */
+  private startSkillUpdateWatcher(): void {
+    const SKILL_STATE_FILE = '.skill-state.json';
+    const configManager = getConfigManager();
+    const userSkillsPath = configManager.getUserSkillsPath();
+    const stateFilePath = userSkillsPath 
+      ? path.join(userSkillsPath, SKILL_STATE_FILE)
+      : null;
+    
+    if (!stateFilePath) {
+      return; // No user skills path configured
+    }
+
+    let lastUpdateTime = 0;
+
+    // Check for updates every 2 seconds
+    const checkInterval = setInterval(async () => {
+      try {
+        const { existsSync, readFileSync } = await import('fs');
+        if (existsSync(stateFilePath)) {
+          const content = readFileSync(stateFilePath, 'utf-8');
+          const state = JSON.parse(content);
+          
+          if (state.lastSkillUpdate && state.lastSkillUpdate > lastUpdateTime) {
+            lastUpdateTime = state.lastSkillUpdate;
+            
+            // Update system prompt with new skills
+            await this.updateSystemPrompt();
+            
+            console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+          }
+        }
+      } catch (error) {
+        // Silent fail - watcher is optional
+      }
+    }, 2000);
+
+    // Clean up on session end
+    (this as any)._skillWatcherInterval = checkInterval;
+  }
+
+  setAgent(agent: AgentConfig): void {
     this.currentAgent = agent;
   }
 
-  async start(): Promise<void> {
+  async start(initializedCount: number = 0): Promise<void> {
     // Set this session as the singleton for access from other modules
     setSingletonSession(this);
 
@@ -169,29 +269,52 @@ export class InteractiveSession {
     console.log('');
     console.log(colors.gradient('╔════════════════════════════════════════════════════════════╗'));
     console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
-    console.log(colors.gradient('║') + ' '.repeat(13) + '🤖 ' + colors.gradient('XAGENT CLI') + ' '.repeat(32) + colors.gradient('  ║'));
-    console.log(colors.gradient('║') + ' '.repeat(16) + colors.textMuted(`v${packageJson.version}`) + ' '.repeat(36) + colors.gradient('  ║'));
+    console.log(
+      colors.gradient('║') +
+        ' '.repeat(13) +
+        '🤖 ' +
+        colors.gradient('XAGENT CLI') +
+        ' '.repeat(32) +
+        colors.gradient('  ║')
+    );
+    console.log(
+      colors.gradient('║') +
+        ' '.repeat(16) +
+        colors.textMuted(`v${packageJson.version}`) +
+        ' '.repeat(36) +
+        colors.gradient('  ║')
+    );
     console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
     console.log(colors.gradient('╚════════════════════════════════════════════════════════════╝'));
     console.log(colors.textMuted('  AI-powered command-line assistant'));
+
+    // Show initialization message if skills were initialized
+    if (initializedCount > 0) {
+      console.log(colors.textMuted(`  ✨ Initialized ${initializedCount} built-in skills`));
+    }
     console.log('');
 
     await this.initialize();
     this.showWelcomeMessage();
 
+    // Start watching for skill updates from CLI
+    this.startSkillUpdateWatcher();
+    // Set up ESC key handler using the terminal module
+    // This avoids conflicts with readline and provides clean ESC detection
+    let escCleanup: (() => void) | undefined;
+    if (process.stdin.isTTY) {
+      escCleanup = setupEscKeyHandler(() => {
+        if ((this as any)._isOperationInProgress) {
+          // An operation is running, let it be cancelled
+          this.cancellationManager.cancel();
+        }
+        // No operation running, ignore ESC
+      });
+    }
+
     // Track if an operation is in progress
     (this as any)._isOperationInProgress = false;
 
-    // Listen for ESC cancellation - only cancel operations, don't exit the program
-    const cancelHandler = () => {
-      if ((this as any)._isOperationInProgress) {
-        // An operation is running, let it be cancelled
-        return;
-      }
-      // No operation running, ignore ESC or show a message
-    };
-    this.cancellationManager.on('cancelled', cancelHandler);
-
     this.promptLoop();
 
     // Keep the promise pending until shutdown
@@ -204,17 +327,17 @@ export class InteractiveSession {
     logger.debug('\n[SESSION] ========== initialize() 开始 ==========\n');
 
     try {
-            // Custom spinner for initialization (like Thinking...)
-            const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-            let frameIndex = 0;
-            const validatingText = colors.textMuted('Validating authentication...');
-      
-            const spinnerInterval = setInterval(() => {
-              process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${validatingText}`);
-              frameIndex = (frameIndex + 1) % frames.length;
-            }, 120);
+      // Custom spinner for initialization (like Thinking...)
+      const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+      let frameIndex = 0;
+      const validatingText = colors.textMuted('Validating authentication...');
+
+      const spinnerInterval = setInterval(() => {
+        process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${validatingText}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+      }, 120);
       logger.debug('[SESSION] 调用 configManager.load()...');
-      await this.configManager.load();
+      this.configManager.load();
 
       logger.debug('[SESSION] Config loaded');
       let authConfig = this.configManager.getAuthConfig();
@@ -224,13 +347,16 @@ export class InteractiveSession {
       logger.debug('[SESSION] selectedAuthType (initial):', String(selectedAuthType));
       logger.debug('[SESSION] AuthType.OAUTH_XAGENT:', String(AuthType.OAUTH_XAGENT));
       logger.debug('[SESSION] AuthType.OPENAI_COMPATIBLE:', String(AuthType.OPENAI_COMPATIBLE));
-      logger.debug('[SESSION] Will validate OAuth:', String(!!(authConfig.apiKey && selectedAuthType === AuthType.OAUTH_XAGENT)));
+      logger.debug(
+        '[SESSION] Will validate OAuth:',
+        String(!!(authConfig.apiKey && selectedAuthType === AuthType.OAUTH_XAGENT))
+      );
 
       // Only validate OAuth tokens, skip validation for third-party API keys
       if (authConfig.apiKey && selectedAuthType === AuthType.OAUTH_XAGENT) {
         clearInterval(spinnerInterval);
         process.stdout.write('\r' + ' '.repeat(50) + '\r'); // Clear the line
-        
+
         const baseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
         let isValid = await this.validateToken(baseUrl, authConfig.apiKey);
 
@@ -242,15 +368,14 @@ export class InteractiveSession {
             process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${refreshingText}`);
             frameIndex = (frameIndex + 1) % frames.length;
           }, 120);
-          
+
           const newToken = await this.refreshToken(baseUrl, authConfig.refreshToken);
           clearInterval(refreshInterval);
           process.stdout.write('\r' + ' '.repeat(50) + '\r');
 
           if (newToken) {
-            // Save new token and persist
-            await this.configManager.set('apiKey', newToken);
-            await this.configManager.save('global');
+            this.configManager.set('apiKey', newToken);
+            this.configManager.save('global');
             authConfig.apiKey = newToken;
             isValid = true;
           }
@@ -262,23 +387,21 @@ export class InteractiveSession {
           console.log(colors.info('Please select an authentication method to continue.'));
           console.log('');
 
-          // Clear invalid credentials and persist
-          // Note: Do NOT overwrite selectedAuthType - let user re-select their preferred auth method
-          await this.configManager.set('apiKey', '');
-          await this.configManager.set('refreshToken', '');
-          await this.configManager.save('global');
+          this.configManager.set('apiKey', '');
+          this.configManager.set('refreshToken', '');
+          this.configManager.save('global');
 
-          await this.configManager.load();
+          this.configManager.load();
           authConfig = this.configManager.getAuthConfig();
 
           await this.setupAuthentication();
           authConfig = this.configManager.getAuthConfig();
 
-          // Recreate readline interface after inquirer
+          // Recreate readline interface after interactive prompt
           this.rl.close();
           this.rl = readline.createInterface({
             input: process.stdin,
-            output: process.stdout
+            output: process.stdout,
           });
           this.rl.on('close', () => {
             // readline closed
@@ -293,11 +416,11 @@ export class InteractiveSession {
         selectedAuthType = this.configManager.get('selectedAuthType');
         logger.debug('[SESSION] selectedAuthType (after setup):', String(selectedAuthType));
 
-        // Recreate readline interface after inquirer
+        // Recreate readline interface after interactive prompt
         this.rl.close();
         this.rl = readline.createInterface({
           input: process.stdin,
-          output: process.stdout
+          output: process.stdout,
         });
         this.rl.on('close', () => {
           // readline closed
@@ -308,22 +431,46 @@ export class InteractiveSession {
       }
       // For OPENAI_COMPATIBLE with API key, skip validation and proceed directly
 
-      this.aiClient = new AIClient(authConfig);
-      this.contextCompressor.setAIClient(this.aiClient);
-
-      // Initialize remote AI client for OAuth XAGENT mode
-      logger.debug('[SESSION] Final selectedAuthType:', String(selectedAuthType));
-      logger.debug('[SESSION] Creating RemoteAIClient?', String(selectedAuthType === AuthType.OAUTH_XAGENT));
+      // Initialize AI clients and set contextCompressor appropriately
       if (selectedAuthType === AuthType.OAUTH_XAGENT) {
-        const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
-        // In OAuth XAGENT mode, we still pass apiKey (can be empty or used for other purposes)
-        this.remoteAIClient = new RemoteAIClient(authConfig.apiKey || '', webBaseUrl, authConfig.showAIDebugInfo);
+        // Remote mode: fetch default models if not set
+        const currentLlm = this.configManager.get('remote_llmModelName');
+        const currentVlm = this.configManager.get('remote_vlmModelName');
+        
+        if (!currentLlm || !currentVlm) {
+          const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
+          
+          try {
+            const defaults = await fetchDefaultModels(authConfig.apiKey || '', webBaseUrl);
+
+            if (!currentLlm && defaults.llm?.name) {
+              this.configManager.set('remote_llmModelName', defaults.llm.name);
+            }
+            if (!currentVlm && defaults.vlm?.name) {
+              this.configManager.set('remote_vlmModelName', defaults.vlm.name);
+            }
+            this.configManager.save('global');
+          } catch (error: any) {
+            logger.debug('[SESSION] Failed to fetch default models:', error.message);
+          }
+        }
+
+        // Remote mode: create RemoteAIClient and use it for context compression
+        this.remoteAIClient = createAIClient(authConfig);
+        this.contextCompressor.setAIClient(this.remoteAIClient);
         logger.debug('[DEBUG Initialize] RemoteAIClient created successfully');
       } else {
+        // Local mode: create local AIClient
+        this.aiClient = createAIClient(authConfig);
+        this.contextCompressor.setAIClient(this.aiClient);
         logger.debug('[DEBUG Initialize] RemoteAIClient NOT created (not OAuth XAGENT mode)');
       }
 
-      this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
+      // Sync remoteAIClient reference to slashCommandHandler for /provider command
+      this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
+
+      this.executionMode =
+        this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
 
       await this.agentManager.loadAgents();
       await this.memoryManager.loadMemory();
@@ -350,11 +497,17 @@ export class InteractiveSession {
       // Eagerly connect to MCP servers to get tool definitions
       if (mcpServers && Object.keys(mcpServers).length > 0) {
         try {
-          console.log(`${colors.info(`${icons.brain} Connecting to ${Object.keys(mcpServers).length} MCP server(s)...`)}`);
+          console.log(
+            `${colors.info(`${icons.brain} Connecting to ${Object.keys(mcpServers).length} MCP server(s)...`)}`
+          );
           await this.mcpManager.connectAllServers();
-          const connectedCount = Array.from(this.mcpManager.getAllServers()).filter((s: any) => s.isServerConnected()).length;
+          const connectedCount = Array.from(this.mcpManager.getAllServers()).filter((s: any) =>
+            s.isServerConnected()
+          ).length;
           const mcpTools = this.mcpManager.getToolDefinitions();
-          console.log(`${colors.success(`✓ ${connectedCount}/${Object.keys(mcpServers).length} MCP server(s) connected (${mcpTools.length} tools available)`)}`);
+          console.log(
+            `${colors.success(`✓ ${connectedCount}/${Object.keys(mcpServers).length} MCP server(s) connected (${mcpTools.length} tools available)`)}`
+          );
 
           // Register MCP tools with the tool registry (hide MCP origin from LLM)
           const toolRegistry = getToolRegistry();
@@ -375,7 +528,7 @@ export class InteractiveSession {
         await this.checkpointManager.initialize();
       }
 
-      this.currentAgent = this.agentManager.getAgent('general-purpose');
+      this.currentAgent = this.agentManager.getAgent('general-purpose') ?? null;
 
       console.log(colors.success('✔ Initialization complete'));
     } catch (error: any) {
@@ -392,7 +545,7 @@ export class InteractiveSession {
   private async validateToken(baseUrl: string, apiKey: string): Promise<boolean> {
     logger.debug('[SESSION] validateToken called with baseUrl:', baseUrl);
     logger.debug('[SESSION] apiKey exists:', apiKey ? 'yes' : 'no');
-    
+
     try {
       // For OAuth XAGENT auth, use /api/auth/me endpoint
       const url = `${baseUrl}/api/auth/me`;
@@ -402,11 +555,11 @@ export class InteractiveSession {
 
       const response = await axios.get(url, {
         headers: {
-          'Authorization': `Bearer ${apiKey}`,
-          'Content-Type': 'application/json'
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
         },
         httpsAgent,
-        timeout: 10000
+        timeout: 10000,
       });
 
       logger.debug('[SESSION] Validation response status:', String(response.status));
@@ -428,10 +581,14 @@ export class InteractiveSession {
       const url = `${baseUrl}/api/auth/refresh`;
       const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 
-      const response = await axios.post(url, { refreshToken }, {
-        httpsAgent,
-        timeout: 10000
-      });
+      const response = await axios.post(
+        url,
+        { refreshToken },
+        {
+          httpsAgent,
+          timeout: 10000,
+        }
+      );
 
       if (response.status === 200) {
         const data = response.data as { token?: string; refreshToken?: string };
@@ -454,11 +611,15 @@ export class InteractiveSession {
     const authType = await selectAuthType();
     this.configManager.set('selectedAuthType', authType);
 
+    // Get xagentApiBaseUrl from config (respects XAGENT_BASE_URL env var)
+    const config = this.configManager.getAuthConfig();
+
     const authService = new AuthService({
       type: authType,
       apiKey: '',
       baseUrl: '',
-      modelName: ''
+      modelName: '',
+      xagentApiBaseUrl: config.xagentApiBaseUrl,
     });
 
     const success = await authService.authenticate();
@@ -472,17 +633,32 @@ export class InteractiveSession {
 
     const authConfig = authService.getAuthConfig();
 
+    // Clear modelName for remote mode
+    if (authType === AuthType.OAUTH_XAGENT) {
+      authConfig.modelName = '';
+    }
+
     // VLM configuration is optional - only show for non-OAuth (local) mode
     // Remote mode uses backend VLM configuration
     if (authType !== AuthType.OAUTH_XAGENT) {
       console.log('');
       console.log(colors.info(`${icons.info} VLM configuration is optional.`));
-      console.log(colors.info(`You can configure it later using the /vlm command if needed.`));
+      console.log(colors.info(`You can configure it later using the /model command if needed.`));
       console.log('');
     }
 
-    // Save LLM config only, skip VLM for now
-    await this.configManager.setAuthConfig(authConfig);
+    this.configManager.setAuthConfig(authConfig);
+
+    // Set default remote model settings if not already set
+    if (authType === AuthType.OAUTH_XAGENT) {
+      if (!this.configManager.get('remote_llmModelName')) {
+        this.configManager.set('remote_llmModelName', '');
+      }
+      if (!this.configManager.get('remote_vlmModelName')) {
+        this.configManager.set('remote_vlmModelName', '');
+      }
+      this.configManager.save('global');
+    }
   }
 
   private showWelcomeMessage(): void {
@@ -494,7 +670,8 @@ export class InteractiveSession {
 
     if (language === 'zh') {
       console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
-              console.log(colors.textMuted('Type /help to see available commands'));    } else {
+      console.log(colors.textMuted('Type /help to see available commands'));
+    } else {
       console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
       console.log(colors.textMuted('Type /help to see available commands'));
     }
@@ -510,28 +687,28 @@ export class InteractiveSession {
       [ExecutionMode.YOLO]: {
         color: colors.error,
         icon: icons.fire,
-        description: 'Execute commands without confirmation'
+        description: 'Execute commands without confirmation',
       },
       [ExecutionMode.ACCEPT_EDITS]: {
         color: colors.warning,
         icon: icons.check,
-        description: 'Accept all edits automatically'
+        description: 'Accept all edits automatically',
       },
       [ExecutionMode.PLAN]: {
         color: colors.info,
         icon: icons.brain,
-        description: 'Plan before executing'
+        description: 'Plan before executing',
       },
       [ExecutionMode.DEFAULT]: {
         color: colors.success,
         icon: icons.bolt,
-        description: 'Safe execution with confirmations'
+        description: 'Safe execution with confirmations',
       },
       [ExecutionMode.SMART]: {
         color: colors.primaryBright,
         icon: icons.sparkles,
-        description: 'Smart approval with intelligent security checks'
-      }
+        description: 'Smart approval with intelligent security checks',
+      },
     };
 
     const config = modeConfig[this.executionMode];
@@ -541,6 +718,28 @@ export class InteractiveSession {
     console.log(`  ${config.color(config.icon)} ${styleHelpers.text.bold(config.color(modeName))}`);
     console.log(`  ${colors.textDim(`  ${config.description}`)}`);
     console.log('');
+
+    this.showRemoteModelInfo();
+  }
+
+  private showRemoteModelInfo(): void {
+    const authConfig = this.configManager.getAuthConfig();
+    const isRemote = authConfig.type === AuthType.OAUTH_XAGENT;
+
+    if (isRemote) {
+      const llmModel = authConfig.remote_llmModelName || colors.textMuted('Not set');
+      const vlmModel = authConfig.remote_vlmModelName || colors.textMuted('Not set');
+      console.log(colors.textMuted(`${icons.brain} Remote Models:`));
+      console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('LLM:')} ${llmModel}`);
+      console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('VLM:')} ${vlmModel}`);
+    } else {
+      const modelName = authConfig.modelName || colors.textMuted('Not set');
+      const guiSubagentModel = this.configManager.get('guiSubagentModel') || colors.textMuted('Not set');
+      console.log(colors.textMuted(`${icons.brain} Local Models:`));
+      console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('LLM:')} ${modelName}`);
+      console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('VLM:')} ${guiSubagentModel}`);
+    }
+    console.log('');
   }
 
   private async promptLoop(): Promise<void> {
@@ -554,16 +753,13 @@ export class InteractiveSession {
       this.rl.close();
     }
 
-    // Enable raw mode BEFORE emitKeypressEvents for better ESC detection
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    readline.emitKeypressEvents(process.stdin);
+    // Ensure TTY is in proper state for input handling
+    // This handles any state left by @clack/prompts or other interactions
+    ensureTtySane();
 
     this.rl = readline.createInterface({
       input: process.stdin,
-      output: process.stdout
+      output: process.stdout,
     });
 
     const prompt = `${colors.primaryBright('❯')} `;
@@ -592,7 +788,8 @@ export class InteractiveSession {
     if (trimmedInput.startsWith('/')) {
       const handled = await this.slashCommandHandler.handleCommand(trimmedInput);
       if (handled) {
-        this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
+        this.executionMode =
+          this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
         // Sync conversation history to slashCommandHandler
         this.slashCommandHandler.setConversationHistory(this.conversation);
       }
@@ -622,7 +819,9 @@ export class InteractiveSession {
     }
 
     console.log('');
-    console.log(colors.primaryBright(`${icons.robot} Using agent: ${agent.name || agent.agentType}`));
+    console.log(
+      colors.primaryBright(`${icons.robot} Using agent: ${agent.name || agent.agentType}`)
+    );
     console.log(colors.border(icons.separator.repeat(40)));
     console.log('');
 
@@ -630,11 +829,11 @@ export class InteractiveSession {
     await this.processUserMessage(task, agent);
   }
 
-  public async processUserMessage(message: string, agent?: any): Promise<void> {
+  public async processUserMessage(message: string, agent?: AgentConfig): Promise<void> {
     const inputs = parseInput(message);
-    const textInput = inputs.find(i => i.type === 'text');
-    const fileInputs = inputs.filter(i => i.type === 'file');
-    const commandInput = inputs.find(i => i.type === 'command');
+    const textInput = inputs.find((i) => i.type === 'text');
+    const fileInputs = inputs.filter((i) => i.type === 'file');
+    const commandInput = inputs.find((i) => i.type === 'command');
 
     if (commandInput) {
       await this.executeShellCommand(commandInput.content);
@@ -647,10 +846,16 @@ export class InteractiveSession {
       const toolRegistry = getToolRegistry();
       for (const fileInput of fileInputs) {
         try {
-          const content = await toolRegistry.execute('Read', { filePath: fileInput.content }, this.executionMode);
+          const content = await toolRegistry.execute(
+            'Read',
+            { filePath: fileInput.content },
+            this.executionMode
+          );
           userContent += `\n\n--- File: ${fileInput.content} ---\n${content}`;
         } catch (error: any) {
-          console.log(chalk.yellow(`Warning: Failed to read file ${fileInput.content}: ${error.message}`));
+          console.log(
+            chalk.yellow(`Warning: Failed to read file ${fileInput.content}: ${error.message}`)
+          );
         }
       }
     }
@@ -660,7 +865,7 @@ export class InteractiveSession {
       type: 'text' as const,
       content: userContent,
       rawInput: message,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
     await this.sessionManager.addInput(sessionInput);
 
@@ -677,29 +882,23 @@ export class InteractiveSession {
     const userMessage: ChatMessage = {
       role: 'user',
       content: userContent,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
 
-    // Save last user message for recovery after compression
-    const lastUserMessage = userMessage;
-
     this.conversation.push(userMessage);
     await this.conversationManager.addMessage(userMessage);
 
-    // Check if context compression is needed
-    await this.checkAndCompressContext(lastUserMessage);
-
     // Use remote AI client if available (OAuth XAGENT mode)
     const currentSelectedAuthType = this.configManager.get('selectedAuthType');
-    logger.debug('[DEBUG processUserMessage] remoteAIClient exists:', !!this.remoteAIClient ? 'true' : 'false');
-    logger.debug('[DEBUG processUserMessage] selectedAuthType:', String(currentSelectedAuthType));
-    logger.debug('[DEBUG processUserMessage] AuthType.OAUTH_XAGENT:', String(AuthType.OAUTH_XAGENT));
+    logger.debug(
+      `[DEBUG] processUserMessage: remoteAIClient exists=${!!this.remoteAIClient}, selectedAuthType=${currentSelectedAuthType}`
+    );
 
     if (this.remoteAIClient) {
-      logger.debug('[DEBUG processUserMessage] Using generateRemoteResponse');
+      logger.debug('[DEBUG] Using generateRemoteResponse (remote mode)');
       await this.generateRemoteResponse(thinkingTokens);
     } else {
-      logger.debug('[DEBUG processUserMessage] Using generateResponse (local mode)');
+      logger.debug('[DEBUG] Using generateResponse (local mode)');
       await this.generateResponse(thinkingTokens);
     }
   }
@@ -709,7 +908,9 @@ export class InteractiveSession {
     const thinkingConfig = this.configManager.getThinkingConfig();
     const displayMode = thinkingConfig.displayMode || 'compact';
 
-    const separator = icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length);
+    const separator = icons.separator.repeat(
+      Math.min(60, process.stdout.columns || 80) - indent.length
+    );
 
     console.log('');
     console.log(`${indent}${colors.border(separator)}`);
@@ -725,9 +926,10 @@ export class InteractiveSession {
       case 'compact':
         // Compact display, truncate partial content
         const maxLength = 500;
-        const truncatedContent = reasoningContent.length > maxLength
-          ? reasoningContent.substring(0, maxLength) + '... (truncated)'
-          : reasoningContent;
+        const truncatedContent =
+          reasoningContent.length > maxLength
+            ? reasoningContent.substring(0, maxLength) + '... (truncated)'
+            : reasoningContent;
 
         console.log(`${indent}${colors.textDim(`${icons.brain} Thinking Process:`)}`);
         console.log('');
@@ -738,7 +940,9 @@ export class InteractiveSession {
       case 'indicator':
         // Show indicator only
         console.log(`${indent}${colors.textDim(`${icons.brain} Thinking process completed`)}`);
-        console.log(`${indent}${colors.textDim(`[${reasoningContent.length} chars of reasoning]`)}`);
+        console.log(
+          `${indent}${colors.textDim(`[${reasoningContent.length} chars of reasoning]`)}`
+        );
         break;
 
       default:
@@ -754,70 +958,107 @@ export class InteractiveSession {
   /**
    * Check and compress conversation context
    */
-  private async checkAndCompressContext(lastUserMessage?: ChatMessage): Promise<void> {
+  private async checkAndCompressContext(): Promise<void> {
     const compressionConfig = this.configManager.getContextCompressionConfig();
 
     if (!compressionConfig.enabled) {
       return;
     }
 
-    const { needsCompression, reason } = this.contextCompressor.needsCompression(
+    const indent = this.getIndent();
+    const currentTokens = this.contextCompressor.estimateContextTokens(this.conversation);
+    const currentMessages = this.conversation.length;
+    const { needsCompression, reason, tokenCount } = this.contextCompressor.needsCompression(
       this.conversation,
       compressionConfig
     );
 
-    if (needsCompression) {
-      const indent = this.getIndent();
-      console.log('');
-      console.log(`${indent}${colors.warning(`${icons.brain} Context compression triggered: ${reason}`)}`);
+    if (!needsCompression) {
+      return;
+    }
 
-      const toolRegistry = getToolRegistry();
-      const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
-      const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
-      const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
-
-      const result: CompressionResult = await this.contextCompressor.compressContext(
-        this.conversation,
-        enhancedSystemPrompt,
-        compressionConfig
-      );
+    // Extract threshold and contextWindow from reason
+    const thresholdMatch = reason.match(/budget\s*\((\d+)/);
+    const contextWindowMatch = reason.match(/contextWindow:\s*(\d+)/);
+    const threshold = thresholdMatch ? parseInt(thresholdMatch[1], 10) : 0;
+    const contextWindow = contextWindowMatch ? parseInt(contextWindowMatch[1], 10) : 0;
 
-      if (result.wasCompressed) {
-        this.conversation = result.compressedMessages;
-        // console.log(`${indent}${colors.success(`✓ Compressed ${result.originalMessageCount} messages to ${result.compressedMessageCount} messages`)}`);
-        console.log(`${indent}${colors.textMuted(`✓ Size: ${result.originalSize} → ${result.compressedSize} chars (${Math.round((1 - result.compressedSize / result.originalSize) * 100)}% reduction)`)}`);
+    console.log('');
+    console.log(
+      `${indent}${colors.success(`${icons.sparkles} Compressing context (${currentMessages} msgs, ${tokenCount.toLocaleString()} > ${threshold.toLocaleString()}/${contextWindow.toLocaleString()} tokens, ${Math.round((tokenCount / contextWindow) * 100)}% of context window)...`)}`
+    );
 
-        // Display compressed summary content
-        const summaryMessage = result.compressedMessages.find(m => m.role === 'assistant');
-        if (summaryMessage && summaryMessage.content) {
-          const maxPreviewLength = 800;
-          let summaryContent = summaryMessage.content;
-          const isTruncated = summaryContent.length > maxPreviewLength;
+    const toolRegistry = getToolRegistry();
+    const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
+    const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+    const enhancedSystemPrompt =
+      await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
 
-          if (isTruncated) {
-            summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
-          }
+    const result: CompressionResult = await this.contextCompressor.compressContext(
+      this.conversation,
+      enhancedSystemPrompt,
+      compressionConfig
+    );
 
-          console.log('');
-          console.log(`${indent}${theme.predefinedStyles.title(`${icons.sparkles} Conversation Summary`)}`);
-          const separator = icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length * 2);
-          console.log(`${indent}${colors.border(separator)}`);
-          const renderedSummary = renderMarkdown(summaryContent, (process.stdout.columns || 80) - indent.length * 4);
-          console.log(`${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`);
-          if (isTruncated) {
-            console.log(`${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`);
-          }
-          console.log(`${indent}${colors.border(separator)}`);
+    if (result.wasCompressed) {
+      this.conversation = result.compressedMessages;
+      const reductionPercent = Math.round((1 - result.compressedSize / result.originalSize) * 100);
+      console.log(
+        `${indent}${colors.success(`${icons.success} Compressed ${result.originalMessageCount} → ${result.compressedMessageCount} messages (${reductionPercent}% smaller)`)}`
+      );
+
+      // Summary is embedded in first user message, look for it
+      // The format is: "[Conversation Summary - X messages compressed]\n\n${summary}"
+      let summaryMessage: ChatMessage | undefined = result.compressedMessages.find(
+        (m) => m.role === 'user' && m.content.includes('[Conversation Summary')
+      );
+
+      if (summaryMessage) {
+        // Extract summary content after the header
+        const match = summaryMessage.content.match(/\[Conversation Summary.*?\]:\n\n(.+)/s);
+        if (match) {
+          summaryMessage = {
+            role: 'assistant',
+            content: match[1],
+            timestamp: summaryMessage.timestamp,
+          };
         }
+      }
 
-        // Restore user messages after compression, ensuring user message exists for API calls
-        if (lastUserMessage) {
-          this.conversation.push(lastUserMessage);
+      if (summaryMessage && summaryMessage.content) {
+        const maxPreviewLength = 800;
+        let summaryContent = summaryMessage.content;
+        const isTruncated = summaryContent.length > maxPreviewLength;
+
+        if (isTruncated) {
+          summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
         }
 
-        // Sync compressed conversation history to slashCommandHandler
-        this.slashCommandHandler.setConversationHistory(this.conversation);
+        console.log('');
+        console.log(
+          `${indent}${theme.predefinedStyles.title(`${icons.sparkles} Conversation Summary`)}`
+        );
+        const separator = icons.separator.repeat(
+          Math.min(60, process.stdout.columns || 80) - indent.length * 2
+        );
+        console.log(`${indent}${colors.border(separator)}`);
+        const renderedSummary = renderMarkdown(
+          summaryContent,
+          (process.stdout.columns || 80) - indent.length * 4
+        );
+        console.log(
+          `${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`
+        );
+        if (isTruncated) {
+          console.log(
+            `${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`
+          );
+        }
+        console.log(`${indent}${colors.border(separator)}`);
       }
+
+      // Sync compressed conversation history to slashCommandHandler
+      this.slashCommandHandler.setConversationHistory(this.conversation);
     }
   }
 
@@ -826,7 +1067,9 @@ export class InteractiveSession {
     console.log('');
     console.log(`${indent}${colors.textMuted(`${icons.code} Executing:`)}`);
     console.log(`${indent}${colors.codeText(`  $ ${command}`)}`);
-    console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
+    console.log(
+      `${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`
+    );
     console.log('');
 
     const toolRegistry = getToolRegistry();
@@ -846,17 +1089,17 @@ export class InteractiveSession {
         tool: 'Bash',
         params: { command },
         result,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       };
 
-      this.toolCalls.push(toolCall);
+      this.tool_calls.push(toolCall);
 
       // Record command execution to session manager
       await this.sessionManager.addInput({
         type: 'command',
         content: command,
         rawInput: command,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       });
 
       await this.sessionManager.addOutput({
@@ -865,7 +1108,7 @@ export class InteractiveSession {
         toolName: 'Bash',
         toolParams: { command },
         toolResult: result,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       });
     } catch (error: any) {
       console.log(`${indent}${colors.error(`Command execution failed: ${error.message}`)}`);
@@ -894,10 +1137,22 @@ export class InteractiveSession {
    */
   private createRemoteCaller(taskId: string, status: 'begin' | 'continue') {
     const client = this.remoteAIClient!;
+
+
     return {
-      chatCompletion: (messages: ChatMessage[], options: any) =>
-        client.chatCompletion(messages, { ...options, taskId, status }),
-      isRemote: true
+      chatCompletion: (messages: ChatMessage[], options: any) => {
+        // Must fetch authConfig inside the closure, otherwise it captures stale config
+        const authConfig = this.configManager.getAuthConfig();
+        logger.debug(`[DEBUG] createRemoteCaller: llmModelName=${authConfig.remote_llmModelName}, vlmModelName=${authConfig.remote_vlmModelName}`);
+        return client.chatCompletion(messages, {
+          ...options,
+          taskId,
+          status: options.isFirstApiCall ? 'begin' : 'continue',
+          llmModelName: authConfig.remote_llmModelName,
+          vlmModelName: authConfig.remote_vlmModelName
+        });
+      },
+      isRemote: true,
     };
   }
 
@@ -907,39 +1162,32 @@ export class InteractiveSession {
   private createLocalCaller() {
     const client = this.aiClient!;
     return {
-      chatCompletion: (messages: ChatMessage[], options: any) => 
+      chatCompletion: (messages: ChatMessage[], options: any) =>
         client.chatCompletion(messages as any, options),
-      isRemote: false
+      isRemote: false,
     };
   }
 
-  private async generateResponse(thinkingTokens: number = 0, customAIClient?: AIClient, existingTaskId?: string): Promise<void> {
+  private async generateResponse(
+    thinkingTokens: number = 0,
+    _customAIClient?: AIClient,
+    existingTaskId?: string
+  ): Promise<void> {
     // Use existing taskId or create new one for this user interaction
     // If taskId already exists (e.g., from tool calls), reuse it
     const taskId = existingTaskId || this.currentTaskId || crypto.randomUUID();
     this.currentTaskId = taskId;
-    this.isFirstApiCall = true;
 
-    // Determine status based on whether this is the first API call
-    const status: 'begin' | 'continue' = this.isFirstApiCall ? 'begin' : 'continue';
+    // isFirstApiCall is reset in generateRemoteResponse for new tasks
+    // For continuation calls (existingTaskId provided), keep previous value
 
-    // Use custom AI client if provided, otherwise use default logic
-    let chatCompletion: (messages: ChatMessage[], options: any) => Promise<any>;
-    let isRemote = false;
-
-    if (customAIClient) {
-      // Custom client (used by remote mode) - pass taskId and status
-      chatCompletion = (messages: ChatMessage[], options: any) =>
-        customAIClient.chatCompletion(messages as any, { ...options, taskId, status });
-      isRemote = true;
-    } else {
-      // Use unified LLM Caller with taskId (automatically selects local or remote mode)
-      const caller = this.createLLMCaller(taskId, status);
-      chatCompletion = caller.chatCompletion;
-      isRemote = caller.isRemote;
-    }
+    // Use unified LLM Caller with taskId (automatically selects local or remote mode)
+    const status: 'begin' | 'continue' = this.isFirstApiCall ? 'begin' : 'continue';
+    const caller = this.createLLMCaller(taskId, status);
+    const chatCompletion = caller.chatCompletion;
+    const isRemote = caller.isRemote;
 
-    if (!isRemote && !this.aiClient && !customAIClient) {
+    if (!isRemote && !this.aiClient) {
       console.log(colors.error('AI client not initialized'));
       return;
     }
@@ -971,17 +1219,28 @@ export class InteractiveSession {
       const toolDefinitions = toolRegistry.getToolDefinitions();
 
       // Available tools for this session
-      const availableTools = this.executionMode !== ExecutionMode.DEFAULT && allowedToolNames.length > 0
-        ? toolDefinitions.filter((tool: any) => allowedToolNames.includes(tool.function.name))
-        : toolDefinitions;
-
-      const baseSystemPrompt = this.currentAgent?.systemPrompt;
-      const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
-      const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
+      const availableTools =
+        this.executionMode !== ExecutionMode.DEFAULT && allowedToolNames.length > 0
+          ? toolDefinitions.filter(
+              (tool): tool is { function: { name: string } } =>
+                typeof tool.function?.name === 'string' &&
+                allowedToolNames.includes(tool.function.name)
+            )
+          : toolDefinitions;
+
+      const baseSystemPrompt = this.currentAgent?.systemPrompt ?? '';
+      const systemPromptGenerator = new SystemPromptGenerator(
+        toolRegistry,
+        this.executionMode,
+        undefined,
+        this.mcpManager
+      );
+      const enhancedSystemPrompt =
+        await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
 
       const messages: ChatMessage[] = [
         { role: 'system', content: `${enhancedSystemPrompt}\n\n${memory}`, timestamp: Date.now() },
-        ...this.conversation
+        ...this.conversation,
       ];
 
       const operationId = `ai-response-${Date.now()}`;
@@ -989,7 +1248,8 @@ export class InteractiveSession {
         chatCompletion(messages, {
           tools: availableTools,
           toolChoice: availableTools.length > 0 ? 'auto' : 'none',
-          thinkingTokens
+          thinkingTokens,
+          isFirstApiCall: this.isFirstApiCall,
         }),
         operationId
       );
@@ -1002,9 +1262,7 @@ export class InteractiveSession {
 
       const assistantMessage = response.choices[0].message;
 
-      const content = typeof assistantMessage.content === 'string'
-        ? assistantMessage.content
-        : '';
+      const content = typeof assistantMessage.content === 'string' ? assistantMessage.content : '';
       const reasoningContent = assistantMessage.reasoning_content || '';
       // Display reasoning content if available and thinking mode is enabled
       if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
@@ -1013,9 +1271,14 @@ export class InteractiveSession {
 
       console.log('');
       console.log(`${indent}${colors.primaryBright(`${icons.robot} Assistant:`)}`);
-      console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
+      console.log(
+        `${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`
+      );
       console.log('');
-      const renderedContent = renderMarkdown(content, (process.stdout.columns || 80) - indent.length * 2);
+      const renderedContent = renderMarkdown(
+        content,
+        (process.stdout.columns || 80) - indent.length * 2
+      );
       console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
       console.log('');
 
@@ -1023,8 +1286,8 @@ export class InteractiveSession {
         role: 'assistant',
         content,
         timestamp: Date.now(),
-        reasoningContent,
-        toolCalls: assistantMessage.tool_calls
+        reasoning_content: reasoningContent,
+        tool_calls: assistantMessage.tool_calls,
       });
 
       // Record output to session manager
@@ -1032,19 +1295,21 @@ export class InteractiveSession {
         role: 'assistant',
         content,
         timestamp: Date.now(),
-        reasoningContent,
-        toolCalls: assistantMessage.tool_calls
+        reasoning_content: reasoningContent,
+        tool_calls: assistantMessage.tool_calls,
       });
 
       if (assistantMessage.tool_calls) {
-        await this.handleToolCalls(assistantMessage.tool_calls);
+        await this.handleToolCalls(assistantMessage.tool_calls as unknown as import('./types.js').ToolCallItem[]);
+      } else {
+        await this.checkAndCompressContext();
       }
 
       if (this.checkpointManager.isEnabled()) {
         await this.checkpointManager.createCheckpoint(
           `Response generated at ${new Date().toLocaleString()}`,
           [...this.conversation],
-          [...this.toolCalls]
+          [...this.tool_calls]
         );
       }
 
@@ -1058,17 +1323,22 @@ export class InteractiveSession {
       (this as any)._isOperationInProgress = false;
 
       if (error.message === 'Operation cancelled by user') {
-        // Mark task as cancelled
+        // Notify backend to cancel the task
         if (this.remoteAIClient && this.currentTaskId) {
-          await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => {});
+          await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => {});
         }
         return;
       }
 
-      // Mark task as cancelled when error occurs (发送 status: 'cancel')
-      logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}`);
+      // Distinguish error types: timeout vs other failures
+      const isTimeout = error.message.includes('timeout') || error.message.includes('Timeout');
+      const failureReason = isTimeout ? 'timeout' : 'failure';
+
+      logger.debug(
+        `[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}, reason: ${failureReason}`
+      );
       if (this.remoteAIClient && this.currentTaskId) {
-        await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => {});
+        await this.remoteAIClient.failTask?.(this.currentTaskId, failureReason).catch(() => {});
       }
 
       console.log(colors.error(`Error: ${error.message}`));
@@ -1082,20 +1352,24 @@ export class InteractiveSession {
    * @param thinkingTokens - Optional thinking tokens config
    * @param existingTaskId - Optional existing taskId to reuse (for tool call continuation)
    */
-  private async generateRemoteResponse(thinkingTokens: number = 0, existingTaskId?: string): Promise<void> {
+  private async generateRemoteResponse(
+    thinkingTokens: number = 0,
+    existingTaskId?: string
+  ): Promise<void> {
     // Reuse existing taskId or create new one for this user interaction
     const taskId = existingTaskId || crypto.randomUUID();
     this.currentTaskId = taskId;
-    logger.debug(`[Session] generateRemoteResponse: taskId=${taskId}, existingTaskId=${!!existingTaskId}`);
-
-    // Reset isFirstApiCall for new task, keep true for continuation
-    if (!existingTaskId) {
-      this.isFirstApiCall = true;
-    }
+    logger.debug(
+      `[Session] generateRemoteResponse: taskId=${taskId}, existingTaskId=${!!existingTaskId}`
+    );
 
-    // Determine status based on whether this is the first API call
-    const status: 'begin' | 'continue' = this.isFirstApiCall ? 'begin' : 'continue';
-    logger.debug(`[Session] Status for this call: ${status}, isFirstApiCall=${this.isFirstApiCall}`);
+    // Each new user message is a fresh task - always set isFirstApiCall = true
+    // This ensures status is 'begin' for every user message
+    this.isFirstApiCall = true;
+    const status: 'begin' | 'continue' = 'begin';
+    logger.debug(
+      `[Session] Status for this call: ${status}, isFirstApiCall=${this.isFirstApiCall}`
+    );
 
     // Check if remote client is available
     if (!this.remoteAIClient) {
@@ -1104,20 +1378,24 @@ export class InteractiveSession {
     }
 
     try {
-      // Reuse generateResponse with remote client, pass taskId to avoid generating new one
-      await this.generateResponse(thinkingTokens, this.remoteAIClient as any, taskId);
+      // Use unified generateResponse without passing customAIClient,
+      // let createLLMCaller handle remote/local selection
+      await this.generateResponse(thinkingTokens, undefined, taskId);
 
       // Mark task as completed (发送 status: 'end')
       logger.debug(`[Session] Task completed: taskId=${this.currentTaskId}`);
-      if (this.currentTaskId) {
-        await this.remoteAIClient.completeTask(this.currentTaskId);
+      if (this.remoteAIClient && this.currentTaskId) {
+        await this.remoteAIClient.completeTask?.(this.currentTaskId);
       }
-
     } catch (error: any) {
       // Clear the operation flag
       (this as any)._isOperationInProgress = false;
 
       if (error.message === 'Operation cancelled by user') {
+        // Notify backend to cancel the task
+        if (this.remoteAIClient && this.currentTaskId) {
+          await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => {});
+        }
         return;
       }
 
@@ -1129,28 +1407,29 @@ export class InteractiveSession {
         console.log('');
 
         // Clear invalid credentials and persist
-        await this.configManager.set('apiKey', '');
-        await this.configManager.set('refreshToken', '');
-        await this.configManager.save('global');
+        this.configManager.set('apiKey', '');
+        this.configManager.set('refreshToken', '');
+        this.configManager.save('global');
 
-        logger.debug('[DEBUG generateRemoteResponse] Cleared invalid credentials, starting re-authentication...');
+        logger.debug(
+          '[DEBUG generateRemoteResponse] Cleared invalid credentials, starting re-authentication...'
+        );
 
         // Re-authenticate
         await this.setupAuthentication();
 
         // Reload config to ensure we have the latest authConfig
-        logger.debug('[DEBUG generateRemoteResponse] Re-authentication completed, reloading config...');
-        await this.configManager.load();
+        this.configManager.load();
         const authConfig = this.configManager.getAuthConfig();
 
         logger.debug('[DEBUG generateRemoteResponse] After re-auth:');
         logger.debug('  - authConfig.apiKey exists:', !!authConfig.apiKey ? 'true' : 'false');
 
-        // Recreate readline interface after inquirer
+        // Recreate readline interface after interactive prompt
         this.rl.close();
         this.rl = readline.createInterface({
           input: process.stdin,
-          output: process.stdout
+          output: process.stdout,
         });
         this.rl.on('close', () => {
           logger.debug('DEBUG: readline interface closed');
@@ -1158,13 +1437,19 @@ export class InteractiveSession {
 
         // Reinitialize RemoteAIClient with new token
         if (authConfig.apiKey) {
-          const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
-          logger.debug('[DEBUG generateRemoteResponse] Reinitializing RemoteAIClient with new token');
-          this.remoteAIClient = new RemoteAIClient(authConfig.apiKey, webBaseUrl, authConfig.showAIDebugInfo);
+          logger.debug(
+            '[DEBUG generateRemoteResponse] Reinitializing RemoteAIClient with new token'
+          );
+          this.remoteAIClient = createAIClient(authConfig);
         } else {
-          logger.debug('[DEBUG generateRemoteResponse] WARNING: No apiKey after re-authentication!');
+          logger.debug(
+            '[DEBUG generateRemoteResponse] WARNING: No apiKey after re-authentication!'
+          );
         }
 
+        // Sync remoteAIClient reference to slashCommandHandler for /provider command
+        this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
+
         // Retry the current operation
         console.log('');
         console.log(colors.info('Retrying with new authentication...'));
@@ -1172,10 +1457,15 @@ export class InteractiveSession {
         return this.generateRemoteResponse(thinkingTokens);
       }
 
-      // Mark task as cancelled when error occurs (发送 status: 'cancel')
-      logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}`);
+      // Distinguish error types: timeout vs other failures
+      const isTimeout = error.message.includes('timeout') || error.message.includes('Timeout');
+      const failureReason = isTimeout ? 'timeout' : 'failure';
+
+      logger.debug(
+        `[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}, reason: ${failureReason}`
+      );
       if (this.remoteAIClient && this.currentTaskId) {
-        await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => {});
+        await this.remoteAIClient.failTask?.(this.currentTaskId, failureReason).catch(() => {});
       }
 
       console.log(colors.error(`Error: ${error.message}`));
@@ -1183,7 +1473,10 @@ export class InteractiveSession {
     }
   }
 
-  private async handleToolCalls(toolCalls: any[], onComplete?: () => Promise<void>): Promise<void> {
+  private async handleToolCalls(
+    toolCalls: ToolCallItem[],
+    onComplete?: () => Promise<void>
+  ): Promise<void> {
     // Mark that tool execution is in progress
     (this as any)._isOperationInProgress = true;
 
@@ -1219,20 +1512,45 @@ export class InteractiveSession {
 
     // Execute all tools in parallel
     const results = await toolRegistry.executeAll(
-      preparedToolCalls.map(tc => ({ name: tc.name, params: tc.params })),
+      preparedToolCalls.map((tc) => ({ name: tc.name, params: tc.params })),
       this.executionMode
     );
 
-    // Process results and maintain order
-    let hasError = false;
-    for (const { tool, result, error } of results) {
-      const toolCall = preparedToolCalls.find(tc => tc.name === tool);
-      if (!toolCall) continue;
+    // Create a map to store results by tool call index to maintain original order
+    const resultsByIndex = new Map<number, { tool: string; result: any; error?: string }>();
+    const usedIndices = new Set<number>();
+    
+    for (const result of results) {
+      // Find the first unused original index in preparedToolCalls that matches the tool name
+      const originalIndex = preparedToolCalls.findIndex((tc, idx) => 
+        tc.name === result.tool && !usedIndices.has(idx)
+      );
+      if (originalIndex !== -1) {
+        usedIndices.add(originalIndex);
+        resultsByIndex.set(originalIndex, result);
+      }
+    }
 
-      const { params } = toolCall;
+    // Process results in the original tool_calls order (critical for Anthropic format APIs)
+    let hasError = false;
+    for (let i = 0; i < preparedToolCalls.length; i++) {
+      const toolCall = preparedToolCalls[i];
+      const { name: tool, params } = toolCall;
+      
+      const resultData = resultsByIndex.get(i);
+      const result = resultData?.result;
+      const error = resultData?.error;
 
       if (error) {
         if (error === 'Operation cancelled by user') {
+          // Notify backend to cancel the task
+          if (this.remoteAIClient && this.currentTaskId) {
+            await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => {});
+          }
+
+          // 清理 conversation 中未完成的 tool_call
+          this.cleanupIncompleteToolCalls();
+
           (this as any)._isOperationInProgress = false;
           return;
         }
@@ -1242,16 +1560,16 @@ export class InteractiveSession {
         console.log('');
         console.log(`${indent}${colors.error(`${icons.cross} Tool Error: ${tool} - ${error}`)}`);
 
-        // 添加详细的错误信息，包含工具名称和参数，便于 AI 理解和修正
+        // Add detailed error info including tool name and params for AI understanding and correction
         this.conversation.push({
           role: 'tool',
           content: JSON.stringify({
             name: tool,
             parameters: params,
-            error: error
+            error: error,
           }),
           tool_call_id: toolCall.id,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         });
       } else {
         // Use correct indent for gui-subagent tasks
@@ -1294,7 +1612,10 @@ export class InteractiveSession {
           // Show edit result with diff
           console.log('');
           const diffOutput = renderDiff(result.diff);
-          const indentedDiff = diffOutput.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
+          const indentedDiff = diffOutput
+            .split('\n')
+            .map((line) => `${displayIndent}  ${line}`)
+            .join('\n');
           console.log(`${indentedDiff}`);
         } else if (hasFilePreview) {
           // Show new file content in diff-like style
@@ -1306,24 +1627,34 @@ export class InteractiveSession {
         } else if (hasDeleteInfo) {
           // Show DeleteFile result
           console.log('');
-          console.log(`${displayIndent}${colors.success(`${icons.check} Deleted: ${result.filePath}`)}`);
+          console.log(
+            `${displayIndent}${colors.success(`${icons.check} Deleted: ${result.filePath}`)}`
+          );
         } else if (isTaskTool) {
           // Special handling for task tool (subagent) - show friendly summary
           console.log('');
           const subagentType = params.subagent_type;
-          const subagentName = params.description || (params.prompt ? params.prompt.substring(0, 50).replace(/\n/g, ' ') : 'Unknown task');
+          const subagentName =
+            params.description ||
+            (params.prompt ? params.prompt.substring(0, 50).replace(/\n/g, ' ') : 'Unknown task');
 
           if (result?.success) {
-            console.log(`${displayIndent}${colors.success(`${icons.check} ${subagentType}: Completed`)}`);
+            console.log(
+              `${displayIndent}${colors.success(`${icons.check} ${subagentType}: Completed`)}`
+            );
             console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
             if (result.message) {
               console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
             }
           } else if (result?.cancelled) {
-            console.log(`${displayIndent}${colors.warning(`${icons.cross} ${subagentType}: Cancelled`)}`);
+            console.log(
+              `${displayIndent}${colors.warning(`${icons.cross} ${subagentType}: Cancelled`)}`
+            );
             console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
           } else {
-            console.log(`${displayIndent}${colors.error(`${icons.cross} ${subagentType}: Failed`)}`);
+            console.log(
+              `${displayIndent}${colors.error(`${icons.cross} ${subagentType}: Failed`)}`
+            );
             console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
             if (result?.message) {
               console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
@@ -1375,7 +1706,9 @@ export class InteractiveSession {
           }
 
           if (result?.success !== false) {
-            console.log(`${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`);
+            console.log(
+              `${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`
+            );
             console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
             if (summary) {
               console.log(`${displayIndent}${colors.textDim(`  ${summary}`)}`);
@@ -1384,7 +1717,9 @@ export class InteractiveSession {
             console.log(`${displayIndent}${colors.error(`${icons.cross} ${serverName}: Failed`)}`);
             console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
             if (result?.message || result?.error) {
-              console.log(`${displayIndent}${colors.textDim(`  ${result?.message || result?.error}`)}`);
+              console.log(
+                `${displayIndent}${colors.textDim(`  ${result?.message || result?.error}`)}`
+              );
             }
           }
         } else if (tool === 'InvokeSkill') {
@@ -1397,7 +1732,8 @@ export class InteractiveSession {
             console.log(`${displayIndent}${colors.success(`${icons.check} Skill: Completed`)}`);
             console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
             if (taskDesc) {
-              const truncatedTask = taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
+              const truncatedTask =
+                taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
               console.log(`${displayIndent}${colors.textDim(`  Task: ${truncatedTask}`)}`);
             }
           } else {
@@ -1413,13 +1749,20 @@ export class InteractiveSession {
           console.log(`${displayIndent}${colors.textDim(JSON.stringify(result, null, 2))}`);
         } else if (result && result.success === false) {
           // GUI task or other tool failed
-          console.log(`${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`);
+          console.log(
+            `${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`
+          );
         } else if (result) {
           // Show brief preview by default (consistent with subagent behavior)
-          const resultPreview = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-          const truncatedPreview = resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
+          const resultPreview =
+            typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+          const truncatedPreview =
+            resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
           // Indent the preview
-          const indentedPreview = truncatedPreview.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
+          const indentedPreview = truncatedPreview
+            .split('\n')
+            .map((line) => `${displayIndent}  ${line}`)
+            .join('\n');
           console.log(`${indentedPreview}`);
         } else {
           console.log(`${displayIndent}${colors.textDim('(no result)')}`);
@@ -1429,10 +1772,10 @@ export class InteractiveSession {
           tool,
           params,
           result,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         };
 
-        this.toolCalls.push(toolCallRecord);
+        this.tool_calls.push(toolCallRecord);
 
         // Record tool output to session manager
         await this.sessionManager.addOutput({
@@ -1441,82 +1784,122 @@ export class InteractiveSession {
           toolName: tool,
           toolParams: params,
           toolResult: result,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         });
 
-        // 统一消息格式，包含工具名称和参数
+        // Unified message format with tool name and params
+        // Format: OpenAI-compatible tool result with plain text content
         this.conversation.push({
           role: 'tool',
-          content: JSON.stringify({
-            name: tool,
-            parameters: params,
-            result: result
-          }),
+          content: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
           tool_call_id: toolCall.id,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         });
       }
     }
 
     // Logic: Only skip returning results to main agent when user explicitly cancelled (ESC)
     // For all other cases (success, failure, errors), always return results for further processing
-    const guiSubagentCancelled = preparedToolCalls.some(tc => tc.name === 'task' && tc.params?.subagent_type === 'gui-subagent' && results.some(r => r.tool === 'task' && (r.result as any)?.cancelled === true));
+    const guiSubagentCancelled = preparedToolCalls.some(
+      (tc) =>
+        tc.name === 'task' &&
+        tc.params?.subagent_type === 'gui-subagent' &&
+        results.some((r) => r.tool === 'task' && (r.result as any)?.cancelled === true)
+    );
 
     // If GUI agent was cancelled by user, don't continue generating response
     // This avoids wasting API calls and tokens on cancelled tasks
     if (guiSubagentCancelled) {
-      console.log('');
-      console.log(`${indent}${colors.textMuted('GUI task cancelled by user')}`);
       (this as any)._isOperationInProgress = false;
       return;
     }
 
-    // Handle errors and completion based on whether onComplete callback is provided
-    if (hasError) {
-      (this as any)._isOperationInProgress = false;
-      // 不再抛出异常，而是将错误结果返回给 AI，让 AI 决定如何处理
-      // 这样可以避免工具错误导致程序退出
-    }
-
-    // Continue based on mode - 统一处理，无论是否有错误
+    // Continue based on mode - unified handling for both success and error cases
     if (onComplete) {
+      await this.checkAndCompressContext();
       // Remote mode: use provided callback
       await onComplete();
     } else {
+      await this.checkAndCompressContext();
       // Local mode: default behavior - continue with generateResponse
       await this.generateResponse();
     }
   }
 
+  /**
+   * Clean up incomplete tool calls from conversation after cancellation
+   * This removes assistant messages with tool_calls that don't have corresponding tool_results
+   */
+  private async cleanupIncompleteToolCalls(): Promise<void> {
+    // 从后往前找到包含 tool_calls 的 assistant 消息
+    for (let i = this.conversation.length - 1; i >= 0; i--) {
+      const msg = this.conversation[i];
+
+      if (msg.role === 'assistant' && msg.tool_calls?.length) {
+        // 收集所有 tool_call IDs
+        const allToolCallIds = new Set(msg.tool_calls.map((tc: any) => tc.id));
+
+        // 找出哪些 tool_call IDs 已经有对应的 tool_result
+        const completedToolCallIds = new Set<string>();
+        for (let k = i + 1; k < this.conversation.length; k++) {
+          const resultMsg = this.conversation[k];
+          if (resultMsg.role === 'tool' && resultMsg.tool_call_id) {
+            completedToolCallIds.add(resultMsg.tool_call_id);
+          } else if (resultMsg.role === 'user' || resultMsg.role === 'assistant') {
+            break; // 遇到下一个角色消息就停止
+          }
+        }
+
+        // 找出未完成的 tool_call IDs
+        const incompleteToolCallIds = [...allToolCallIds].filter(
+          id => !completedToolCallIds.has(id)
+        );
+
+        // 如果所有 tool_call 都已完成，不需要清理
+        if (incompleteToolCallIds.length === 0) {
+          break;
+        }
+
+        // 只移除未完成的 tool_call，不移除已完成的 tool_result
+        msg.tool_calls = msg.tool_calls.filter(
+          (tc: any) => !incompleteToolCallIds.includes(tc.id)
+        );
+
+        break;
+      }
+    }
+  }
+
   /**
    * Get user-friendly description for tool
    */
   private getToolDescription(toolName: string, params: any): string {
     const descriptions: Record<string, (params: any) => string> = {
-      'Read': (p) => `Read file: ${this.truncatePath(p.filePath)}`,
-      'Write': (p) => `Write file: ${this.truncatePath(p.filePath)}`,
-      'Grep': (p) => `Search text: "${p.pattern}"`,
-      'Bash': (p) => `Execute command: ${this.truncateCommand(p.command)}`,
-      'ListDirectory': (p) => `List directory: ${this.truncatePath(p.path || '.')}`,
-      'SearchFiles': (p) => `Search files: ${p.pattern}`,
-      'DeleteFile': (p) => `Delete file: ${this.truncatePath(p.filePath)}`,
-      'CreateDirectory': (p) => `Create directory: ${this.truncatePath(p.dirPath)}`,
-      'Edit': (p) => `Edit text: ${this.truncatePath(p.file_path)}`,
-      'web_search': (p) => `Web search: "${p.query}"`,
-      'todo_write': () => `Update todo list`,
-      'todo_read': () => `Read todo list`,
-      'task': (p) => `Launch subtask: ${p.description}`,
-      'ReadBashOutput': (p) => `Read task output: ${p.task_id}`,
-      'web_fetch': () => `Fetch web content`,
-      'ask_user_question': () => `Ask user`,
-      'save_memory': () => `Save memory`,
-      'exit_plan_mode': () => `Complete plan`,
-      'xml_escape': (p) => `XML escape: ${this.truncatePath(p.file_path)}`,
-      'image_read': (p) => `Read image: ${this.truncatePath(p.image_input)}`,
+      Read: (p) => `Read file: ${this.truncatePath(p.filePath)}`,
+      Write: (p) => `Write file: ${this.truncatePath(p.filePath)}`,
+      Grep: (p) => `Search text: "${p.pattern}"`,
+      Bash: (p) => `Execute command: ${this.truncateCommand(p.command)}`,
+      ListDirectory: (p) => `List directory: ${this.truncatePath(p.path || '.')}`,
+      SearchFiles: (p) => `Search files: ${p.pattern}`,
+      DeleteFile: (p) => `Delete file: ${this.truncatePath(p.filePath)}`,
+      CreateDirectory: (p) => `Create directory: ${this.truncatePath(p.dirPath)}`,
+      Edit: (p) => `Edit text: ${this.truncatePath(p.file_path)}`,
+      web_search: (p) => `Web search: "${p.query}"`,
+      todo_write: () => `Update todo list`,
+      todo_read: () => `Read todo list`,
+      task: (p) => `Launch subtask: ${p.description}`,
+      ReadBashOutput: (p) => `Read task output: ${p.task_id}`,
+      web_fetch: () => `Fetch web content`,
+      ask_user_question: () => `Ask user`,
+      save_memory: () => `Save memory`,
+      exit_plan_mode: () => `Complete plan`,
+      xml_escape: (p) => `XML escape: ${this.truncatePath(p.file_path)}`,
+      image_read: (p) => `Read image: ${this.truncatePath(p.image_input)}`,
       // 'Skill': (p) => `Execute skill: ${p.skill}`,
       // 'ListSkills': () => `List available skills`,
       // 'GetSkillDetails': (p) => `Get skill details: ${p.skill}`,
-      'InvokeSkill': (p) => `Invoke skill: ${p.skillId} - ${this.truncatePath(p.taskDescription || '', 40)}`
+      InvokeSkill: (p) =>
+        `Invoke skill: ${p.skillId} - ${this.truncatePath(p.taskDescription || '', 40)}`,
     };
 
     const getDescription = descriptions[toolName];
@@ -1549,11 +1932,14 @@ export class InteractiveSession {
       return `${indent}${colors.textMuted('No tasks')}`;
     }
 
-    const statusConfig: Record<string, { icon: string; color: (text: string) => string; label: string }> = {
-      'pending': { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
-      'in_progress': { icon: icons.loading, color: colors.warning, label: 'In Progress' },
-      'completed': { icon: icons.success, color: colors.success, label: 'Completed' },
-      'failed': { icon: icons.error, color: colors.error, label: 'Failed' }
+    const statusConfig: Record<
+      string,
+      { icon: string; color: (text: string) => string; label: string }
+    > = {
+      pending: { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
+      in_progress: { icon: icons.loading, color: colors.warning, label: 'In Progress' },
+      completed: { icon: icons.success, color: colors.success, label: 'Completed' },
+      failed: { icon: icons.error, color: colors.error, label: 'Failed' },
     };
 
     const lines: string[] = [];
@@ -1592,18 +1978,18 @@ export class InteractiveSession {
   //     const messages = data as any[];
   //     const tools = extra as any[];
   //
-      //     // System prompt
-      //     const systemMsg = messages.find((m: any) => m.role === 'system');
-      //     console.log(colors.border(`${boxChar.vertical}`) + ' 🟫 SYSTEM: ' +
-      //       colors.textMuted(systemMsg?.content?.toString().substring(0, 50) || '(none)') + ' '.repeat(3) + colors.border(boxChar.vertical));
-      //
-      //     // Messages count
-      //     console.log(colors.border(`${boxChar.vertical}`) + ' 💬 MESSAGES: ' +
-      //       colors.text(messages.length.toString()) + ' items' + ' '.repeat(40) + colors.border(boxChar.vertical));
-      //
-      //     // Tools count
-      //     console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOLS: ' +
-      //       colors.text((tools?.length || 0).toString()) + '' + ' '.repeat(43) + colors.border(boxChar.vertical));  //
+  //     // System prompt
+  //     const systemMsg = messages.find((m: any) => m.role === 'system');
+  //     console.log(colors.border(`${boxChar.vertical}`) + ' 🟫 SYSTEM: ' +
+  //       colors.textMuted(systemMsg?.content?.toString().substring(0, 50) || '(none)') + ' '.repeat(3) + colors.border(boxChar.vertical));
+  //
+  //     // Messages count
+  //     console.log(colors.border(`${boxChar.vertical}`) + ' 💬 MESSAGES: ' +
+  //       colors.text(messages.length.toString()) + ' items' + ' '.repeat(40) + colors.border(boxChar.vertical));
+  //
+  //     // Tools count
+  //     console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOLS: ' +
+  //       colors.text((tools?.length || 0).toString()) + '' + ' '.repeat(43) + colors.border(boxChar.vertical));  //
   //     // Show last 2 messages
   //     const recentMessages = messages.slice(-2);
   //     for (const msg of recentMessages) {
@@ -1627,8 +2013,8 @@ export class InteractiveSession {
   //       colors.text(`Prompt: ${response.usage?.prompt_tokens || '?'}, Completion: ${response.usage?.completion_tokens || '?'}`) +
   //       ' '.repeat(15) + colors.border(boxChar.vertical));
   //
-        // console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOL_CALLS: ' +
-        //   colors.text((message.tool_calls?.length || 0).toString()) + '' + ' '.repeat(37) + colors.border(boxChar.vertical));
+  // console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOL_CALLS: ' +
+  //   colors.text((message.tool_calls?.length || 0).toString()) + '' + ' '.repeat(37) + colors.border(boxChar.vertical));
   //
   //     // Content preview
   //     const contentStr = typeof message.content === 'string'
@@ -1676,7 +2062,174 @@ export class InteractiveSession {
   }
 }
 
+/**
+ * Clean up stale temporary workspaces from previous sessions.
+ * Called at startup to ensure no leftover temp files accumulate.
+ */
+async function cleanupStaleWorkspaces(): Promise<void> {
+  try {
+    const configManager = getConfigManager();
+    const workspacePath = configManager.getWorkspacePath();
+    // Use default workspace path if workspacePath is empty or undefined
+    const effectiveWorkspacePath = (workspacePath && workspacePath.trim()) 
+      ? workspacePath 
+      : os.homedir();
+    const baseWorkspaceDir = path.join(effectiveWorkspacePath, '.xagent', 'workspace');
+
+    // First, verify the workspace directory exists before attempting cleanup
+    try {
+      const stats = await fsPromises.stat(baseWorkspaceDir);
+      if (!stats.isDirectory()) {
+        return; // Not a directory, skip cleanup
+      }
+    } catch {
+      // Directory doesn't exist - nothing to clean
+      return;
+    }
+
+    try {
+      const entries = await fsPromises.readdir(baseWorkspaceDir, { withFileTypes: true });
+
+      let cleanedCount = 0;
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const fullPath = path.join(baseWorkspaceDir, entry.name);
+          try {
+            await fsPromises.rm(fullPath, { recursive: true, force: true });
+            cleanedCount++;
+          } catch {
+            // Skip directories that can't be removed (in use or permission issues)
+          }
+        }
+      }
+
+      if (cleanedCount > 0) {
+        console.log(colors.textDim(`🧹 Cleaned up ${cleanedCount} stale workspace(s)`));
+      }
+    } catch {
+      // Can't read directory - skip cleanup
+    }
+  } catch {
+    // Config not available - skip cleanup
+  }
+}
+
+/**
+ * Initialize built-in skills on first run.
+ * Checks if user skills directory is empty or doesn't exist,
+ * then copies all built-in skills including the protected find-skills.
+ * @returns Number of skills initialized, or 0 if no initialization was needed.
+ */
+async function initializeSkillsOnDemand(): Promise<number> {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+
+  // Get user skills directory (respects OS-specific paths)
+  const configManager = getConfigManager();
+  const userSkillsPath = configManager.getUserSkillsPath() || path.join(os.homedir(), '.xagent', 'skills');
+
+  // Check if user skills directory exists and has skills
+  let hasSkills = false;
+  try {
+    const entries = await fsPromises.readdir(userSkillsPath, { withFileTypes: true });
+    hasSkills = entries.some(e => e.isDirectory());
+  } catch {
+    hasSkills = false;
+  }
+
+  // If skills already exist, skip initialization
+  if (hasSkills) {
+    return 0;
+  }
+
+  // Ensure user skills directory exists
+  await fsPromises.mkdir(userSkillsPath, { recursive: true });
+
+  // Define skill source directories
+  const builtinSkillsDir = path.join(__dirname, '..', 'skills', 'skills');
+  const findSkillsDir = path.join(__dirname, '..', 'find-skills');
+
+  const skillsToInstall: { source: string; name: string }[] = [];
+
+  // Add find-skills from root directory
+  if (fs.existsSync(findSkillsDir) && fs.existsSync(path.join(findSkillsDir, 'SKILL.md'))) {
+    skillsToInstall.push({ source: findSkillsDir, name: 'find-skills' });
+  }
+
+  // Add skills from skills/skills directory
+  if (fs.existsSync(builtinSkillsDir)) {
+    const entries = fs.readdirSync(builtinSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = path.join(builtinSkillsDir, entry.name);
+        if (fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+          skillsToInstall.push({ source: skillPath, name: entry.name });
+        }
+      }
+    }
+  }
+
+  if (skillsToInstall.length === 0) {
+    return 0;
+  }
+
+  // Create user skills directory (already done above, but ensure it exists)
+  await fsPromises.mkdir(userSkillsPath, { recursive: true });
+
+  // Copy all skills
+  for (const { source, name } of skillsToInstall) {
+    const destPath = path.join(userSkillsPath, name);
+    if (!fs.existsSync(destPath)) {
+      await copyDirectoryRecursiveAsync(source, destPath);
+    }
+  }
+
+  return skillsToInstall.length;
+}
+
+// Synchronous version (kept for backwards compatibility)
+function copyDirectoryRecursive(src: string, dest: string): void {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectoryRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Asynchronous version for concurrent-safe initialization
+async function copyDirectoryRecursiveAsync(src: string, dest: string): Promise<void> {
+  await fsPromises.mkdir(dest, { recursive: true });
+  const entries = await fsPromises.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursiveAsync(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await fsPromises.copyFile(srcPath, destPath);
+    }
+  }
+}
+
 export async function startInteractiveSession(): Promise<void> {
+  // Clean up any leftover temp workspaces from previous sessions
+  await cleanupStaleWorkspaces();
+
+  // Initialize built-in skills on first run (silent, returns count)
+  const initializedCount = await initializeSkillsOnDemand();
+
   const session = new InteractiveSession();
 
   // Flag to control shutdown
@@ -1721,6 +2274,15 @@ export async function startInteractiveSession(): Promise<void> {
     process.exit(0);
   });
 
+  await session.start(initializedCount);
+  // Check for updates on startup
+  try {
+    const { checkUpdatesOnStartup } = await import('./update.js');
+    await checkUpdatesOnStartup();
+  } catch (error) {
+    // Silently ignore update check failures
+  }
+
   await session.start();
 }